Update requirements.txt

.dockerignore

@@ -1,24 +0,0 @@
-# deps & build output (installed/built inside the image)
-node_modules
-**/node_modules
-.next
-**/.next
-dist
-**/dist
-out
-**/out
-
-# vcs & local
-.git
-.github
-*.tsbuildinfo
-
-# env & secrets — never bake into images
-.env
-.env.*
-**/.env
-**/.env.*
-
-# misc
-.DS_Store
-*.log

.env.development.local.example

@@ -1,20 +0,0 @@
-# App secrets — copy to `.env.development.local` and fill in. Gitignored.
-
-# Session cookie signing secret (openssl rand -hex 32). Required for auth.
-SESSION_SECRET=
-
-# Hugging Face OAuth (huggingface.co/settings/applications)
-# Redirect URL: ${APP_URL}/api/auth/callback
-HF_OAUTH_CLIENT_ID=
-HF_OAUTH_CLIENT_SECRET=
-
-# Admin usernames (comma-separated, lowercased). Grants /admin access.
-ADMIN_USERS=mrfakename
-
-# Provider API keys — each provider activates when its key(s) are set.
-ELEVENLABS_API_KEY=
-MINIMAX_API_KEY=
-MINIMAX_GROUP_ID=
-
-# Optional private provider plugin packages (comma-separated)
-PROVIDER_PLUGINS=

.env.example

@@ -1,10 +1,15 @@
-# Compose-level config — copy to `.env` and adjust. Safe dev defaults shown.
-# (App secrets go in .env.development.local, not here.)
+SECRET_KEY=your-secret-key-here
+OAUTH_CLIENT_ID=your-huggingface-client-id
+OAUTH_CLIENT_SECRET=your-huggingface-client-secret
+DATABASE_URI=sqlite:///tts_arena.db 
 
-WEB_PORT=3000
-ROUTER_PORT=8080
+FAL_KEY=
+PLAY_USERID=
+PLAY_SECRETKEY=
 
-APP_URL=http://localhost:3000
+TURNSTILE_ENABLED=
+TURNSTILE_SITE_KEY=
+TURNSTILE_SECRET_KEY=
+TURNSTILE_TIMEOUT_HOURS=24
 
-# Shared bearer key between web and router (empty = open local dev).
-ROUTER_API_KEY=
+HF_TOKEN=your-huggingface-token-here

.gitattributes

@@ -1,5 +1,35 @@
-# Bun's text lockfile — keep it diffable and never treated as binary (HF Spaces
-# reject binary files outside Xet/LFS).
-bun.lock text eol=lf linguist-generated=true
-# Large prompt corpus is stored via Git LFS.
-apps/web/data/combined_prompts.txt filter=lfs diff=lfs merge=lfs -text
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.github/workflows/ci.yml

@@ -1,52 +0,0 @@
-name: CI
-
-on:
-  push:
-    branches: [main]
-  pull_request:
-    branches: [main]
-  workflow_dispatch:
-
-# Cancel superseded runs on the same ref to save CI minutes.
-concurrency:
-  group: ci-${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: true
-
-permissions:
-  contents: read
-
-jobs:
-  quality:
-    name: Lint, typecheck, test & build
-    runs-on: ubuntu-latest
-    timeout-minutes: 15
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Setup Bun
-        uses: oven-sh/setup-bun@v2
-        with:
-          # Pin to the version that writes the lockfile (the Space image uses
-          # bun 1.1.42 too). "latest" drifted and failed to resolve the newer
-          # apps/docs deps from a 1.1.42-written lockfile.
-          bun-version: 1.1.42
-
-      - name: Install dependencies
-        run: bun install
-
-      - name: Format check
-        run: bun run format:check
-
-      - name: Lint
-        run: bun run lint
-
-      - name: Typecheck
-        run: bun run typecheck
-
-      - name: Test
-        run: bun test
-
-      - name: Build
-        run: bun run build

.github/workflows/deploy-docs.yml

@@ -1,62 +0,0 @@
-name: Deploy Docs to Hugging Face Space
-
-# Pushes apps/docs to the TTS-AGI/docs Space (served at https://docs.ttsarena.org).
-# Runs after CI passes on main. The Space builds the Dockerfile itself.
-on:
-  workflow_run:
-    workflows: ["CI"]
-    types: [completed]
-    branches: [main]
-  workflow_dispatch:
-
-concurrency:
-  group: deploy-docs
-  cancel-in-progress: false
-
-permissions:
-  contents: read
-
-env:
-  HF_OWNER: TTS-AGI
-  HF_SPACE: docs
-
-jobs:
-  deploy:
-    name: Sync docs to Space
-    runs-on: ubuntu-latest
-    if: >
-      github.event_name == 'workflow_dispatch' ||
-      github.event.workflow_run.conclusion == 'success'
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Push to the docs Space
-        env:
-          HF_TOKEN: ${{ secrets.HF_TOKEN }}
-        run: |
-          git config --global user.email "actions@github.com"
-          git config --global user.name "GitHub Actions"
-
-          REMOTE="https://${HF_OWNER}:${HF_TOKEN}@huggingface.co/spaces/${HF_OWNER}/${HF_SPACE}"
-
-          # The docs app is self-contained (no @ttsa/* workspace deps), and its
-          # Dockerfile builds apps/docs in isolation. So the Space only needs the
-          # apps/docs tree + the Dockerfile + README — nothing else from the
-          # monorepo (no LFS corpus, no sibling apps, no native deps).
-          DEST=/tmp/docs-space
-          rm -rf "$DEST" && mkdir -p "$DEST/apps/docs"
-          rsync -a \
-            --exclude='.git' --exclude='node_modules' --exclude='.next' \
-            --exclude='.source' \
-            apps/docs/ "$DEST/apps/docs/"
-          cp Dockerfile.docs "$DEST/Dockerfile"
-          cp SPACES_DOCS_README.md "$DEST/README.md"
-
-          # Single fresh commit (orphan history). Plain text — no LFS.
-          cd "$DEST"
-          git init -q
-          git checkout -q -b main
-          git add -A
-          git commit -q -m "Deploy docs from github.com/${{ github.repository }}@${GITHUB_SHA::7}"
-          git push -f "$REMOTE" main

.github/workflows/deploy-space.yml

@@ -1,119 +0,0 @@
-name: Deploy to Hugging Face Space
-
-# Pushes the repo to the HF Space and syncs Space secrets. Runs after CI passes
-# on main. The Space README and Dockerfile are derived during the sync so the
-# GitHub repo keeps its own.
-on:
-  workflow_run:
-    workflows: ["CI"]
-    types: [completed]
-    branches: [main]
-  workflow_dispatch:
-
-concurrency:
-  group: deploy-space
-  cancel-in-progress: false
-
-permissions:
-  contents: read
-
-env:
-  HF_OWNER: TTS-AGI
-  HF_SPACE: TTS-Arena-V2
-
-jobs:
-  deploy:
-    name: Sync to Space
-    runs-on: ubuntu-latest
-    # Only deploy when the triggering CI run succeeded (or on manual dispatch).
-    if: >
-      github.event_name == 'workflow_dispatch' ||
-      github.event.workflow_run.conclusion == 'success'
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-        with:
-          lfs: true # pull the prompt corpus content, not just LFS pointers
-
-      - name: Sync deployment secrets to the Space
-        env:
-          HF_TOKEN: ${{ secrets.HF_TOKEN }}
-          # Pass ALL repo secrets as one JSON blob so provider names (public or
-          # private) never appear in this public workflow. set-secrets.sh syncs
-          # every key to the Space except the infra-only ones it excludes.
-          ALL_SECRETS: ${{ toJSON(secrets) }}
-        run: |
-          chmod +x deploy/space/set-secrets.sh
-          deploy/space/set-secrets.sh "${HF_OWNER}/${HF_SPACE}"
-
-      - name: Push to the Space
-        env:
-          HF_TOKEN: ${{ secrets.HF_TOKEN }}
-          PRIVATE_PROVIDERS_TOKEN: ${{ secrets.PRIVATE_PROVIDERS_TOKEN }}
-        run: |
-          git config --global user.email "actions@github.com"
-          git config --global user.name "GitHub Actions"
-
-          REMOTE="https://${HF_OWNER}:${HF_TOKEN}@huggingface.co/spaces/${HF_OWNER}/${HF_SPACE}"
-
-          # Build a Space-flavored copy of the repo (no .git). The private
-          # providers are NOT vendored here — the Space's Docker build clones
-          # them itself using the PRIVATE_PROVIDERS_TOKEN Space secret (mounted
-          # as a build secret), so the private source never enters the Space
-          # repo and the Space can be made public safely.
-          rsync -a --exclude='.git' --exclude='node_modules' ./ /tmp/space/
-          # Space README + Dockerfile take precedence; GitHub's stay in the repo.
-          mv /tmp/space/SPACES_README.md /tmp/space/README.md
-          mv /tmp/space/Dockerfile.space /tmp/space/Dockerfile
-
-          # Cache-bust the private-providers clone layer. That RUN clones a repo
-          # behind a fixed command, so Docker reuses a stale layer and the Space
-          # keeps an OLD snapshot of the private repo forever (new private models
-          # never appear). Stamp the private repo's current HEAD SHA into the
-          # Dockerfile's PRIVATE_PROVIDERS_REF default so the layer's cache key
-          # changes whenever the private repo changes. Read the repo path from
-          # the Dockerfile default (authoritative) rather than a secret whose
-          # format we can't rely on.
-          REPO="$(sed -n 's/^ARG PRIVATE_PROVIDERS_REPO=//p' /tmp/space/Dockerfile | head -1)"
-          REPO="${REPO:-TTS-AGI/private-providers}"
-          if [ -z "${PRIVATE_PROVIDERS_TOKEN:-}" ]; then
-            echo "note: PRIVATE_PROVIDERS_TOKEN not available to this job"
-          fi
-          # Resolve HEAD via the GitHub API (works reliably with fine-grained
-          # PATs); fall back to git ls-remote. Either way it's non-fatal.
-          REF="$(curl -sf \
-            -H "Authorization: Bearer ${PRIVATE_PROVIDERS_TOKEN}" \
-            -H "Accept: application/vnd.github+json" \
-            "https://api.github.com/repos/${REPO}/commits/HEAD" \
-            | python3 -c 'import sys,json;print(json.load(sys.stdin)["sha"])' 2>/dev/null || true)"
-          if [ -z "$REF" ]; then
-            REF="$(git ls-remote "https://x-access-token:${PRIVATE_PROVIDERS_TOKEN}@github.com/${REPO}.git" HEAD 2>/dev/null | cut -f1)"
-          fi
-          if [ -n "$REF" ]; then
-            sed -i "s|^ARG PRIVATE_PROVIDERS_REF=.*|ARG PRIVATE_PROVIDERS_REF=${REF}|" /tmp/space/Dockerfile
-            echo "pinned private providers ref to ${REF:0:7}"
-          else
-            # Last resort: a timestamp still busts the cache every deploy (the
-            # clone always fetches latest), at the cost of no layer reuse.
-            STAMP="$(date -u +%Y%m%d%H%M%S)"
-            sed -i "s|^ARG PRIVATE_PROVIDERS_REF=.*|ARG PRIVATE_PROVIDERS_REF=ts-${STAMP}|" /tmp/space/Dockerfile
-            echo "WARNING: could not resolve private HEAD; busting cache with timestamp ts-${STAMP}" >&2
-          fi
-
-          # Deploy as a single fresh commit (orphan history). This keeps the
-          # Space itself (repo + config) intact while ensuring no stray blob
-          # from past history can block the push (HF rejects binaries even from
-          # history). The prompt corpus ships via Git LFS; everything else is
-          # text (bun.lock is the text lockfile).
-          cd /tmp/space
-          git init -q
-          git lfs install --local
-          # Honor the repo's LFS rules and ensure the corpus is LFS-tracked.
-          git lfs track "apps/web/data/combined_prompts.txt"
-          git checkout -q -b main
-          git add -A
-          git commit -q -m "Deploy from github.com/${{ github.repository }}@${GITHUB_SHA::7}"
-          # Sanity: the corpus must be an LFS object, not an inlined blob.
-          git lfs ls-files | grep -q combined_prompts.txt \
-            || { echo "ERROR: prompt corpus is not LFS-tracked"; exit 1; }
-          git push -f "$REMOTE" main

.github/workflows/sync-to-hf.yaml

@@ -0,0 +1,43 @@
+name: Sync to Hugging Face Space
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  sync-to-hf:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v3
+
+      - name: Set up Git
+        run: |
+          git config --global user.email "actions@github.com"
+          git config --global user.name "GitHub Actions"
+
+      - name: Push to Hugging Face Space
+        env:
+          HF_TOKEN: ${{ secrets.HF_TOKEN }}
+        run: |
+          # Replace these with your HF username and space name
+          HF_USERNAME="TTS-AGI"
+          SPACE_NAME="TTS-Arena-V2"
+
+          # Clone the HF space repo
+          git clone https://$HF_USERNAME:$HF_TOKEN@huggingface.co/spaces/$HF_USERNAME/$SPACE_NAME hf-space
+          
+          # Copy all files to the space repo (except .git and hf-space folder)
+          rsync -av --exclude='.git' --exclude='hf-space' ./ hf-space/
+          
+          # Rename SPACES_README.md to README.md for Hugging Face
+          if [ -f hf-space/SPACES_README.md ]; then
+            mv hf-space/SPACES_README.md hf-space/README.md
+          fi
+
+          cd hf-space
+          git add .
+          git commit -m "Sync from GitHub repo" || echo "No changes to commit"
+          git push

.gitignore

@@ -1,50 +1,56 @@
-# dependencies
-node_modules
-.pnp
-.pnp.*
-
-# testing
-coverage
-
-# next.js
-.next/
-out/
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Environment and local development
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+.flaskenv
+
+# Database
+instance/
+*.db
+*.sqlite
+*.sqlite3
 
-# production
-build
-dist
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
 
-# misc
+# OS
 .DS_Store
-*.pem
-
-# debug
-npm-debug.log*
-yarn-debug.log*
-*-debug.log*
+Thumbs.db 
 
-# env files
-.env*
-!.env.example
-!*.env.example
-!.env.development.local.example
+# Uploads
+static/temp_audio
 
-# vercel
-.vercel
+votes/
 
-# typescript
-*.tsbuildinfo
-next-env.d.ts
-
-# drizzle
-drizzle/meta/_journal.json.bak
-
-# local sqlite
-*.db
-*.sqlite
+.claude
 
-# battle audio cache
-.audio-cache/
-**/.audio-cache/
-.claude/
-packages/providers/_private/
+recalibrate_*

.prettierignore

@@ -1,20 +0,0 @@
-# build output & deps
-node_modules
-.next
-out
-build
-dist
-
-# lockfiles & generated
-bun.lockb
-*.tsbuildinfo
-next-env.d.ts
-
-# fumadocs generated content (regenerated on install/build)
-**/.source/**
-
-# drizzle generated migrations
-**/drizzle/**
-
-# assets we don't want reformatted
-apps/web/public/hf-logo.svg

.prettierrc.json

@@ -1,9 +0,0 @@
-{
-  "semi": true,
-  "singleQuote": false,
-  "trailingComma": "all",
-  "printWidth": 80,
-  "tabWidth": 2,
-  "plugins": ["prettier-plugin-tailwindcss"],
-  "tailwindStylesheet": "./apps/web/src/app/globals.css"
-}

COPYING

@@ -0,0 +1,15 @@
+This project is dual-licensed under the MIT license and the Apache 2.0 license. See the LICENSE.MIT and LICENSE.APACHE files respectively for details.
+
+Copyright 2025 mrfakename
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

Dockerfile

@@ -1,115 +0,0 @@
-# syntax=docker/dockerfile:1
-#
-# Combined image for the Hugging Face Space. One container runs two processes
-# under supervisord:
-#   - router     (:8080, internal)
-#   - web        (:7860, the port HF exposes)
-#
-# The database is Postgres on a VPS (DATABASE_URL secret, over a Cloudflare
-# tunnel). Generated audio is logged to /audio (a persistent bucket).
-FROM oven/bun:1.1.42-debian AS base
-WORKDIR /app
-
-# ── deps ──
-FROM base AS deps
-# git + ca-certificates for cloning the private providers over HTTPS; build
-# toolchain for native modules (better-sqlite3) when no prebuilt binary matches.
-RUN apt-get update \
-  && apt-get install -y --no-install-recommends \
-       git ca-certificates python3 make g++ \
-  && rm -rf /var/lib/apt/lists/*
-COPY package.json bun.lock ./
-COPY apps/web/package.json apps/web/package.json
-COPY apps/router/package.json apps/router/package.json
-# Copy every workspace manifest (providers grow over time, so copy the tree's
-# package.json files rather than enumerating each).
-COPY packages/ packages/
-
-# Pull the private providers straight into the workspace using a build-time
-# secret (a read-only GH token Space secret). This keeps the private source out
-# of BOTH the Space repo and the build context — the Space can be public without
-# exposing it. The token is mounted only for this layer and never persisted.
-# PRIVATE_PROVIDERS_REPO defaults to the known repo; override via build arg.
-# If the secret is absent the build still succeeds (no private providers).
-ARG PRIVATE_PROVIDERS_REPO=TTS-AGI/private-providers
-# Cache-buster: the `git clone` below is a fixed command, so Docker would reuse
-# a stale layer and silently keep an OLD snapshot of the private repo forever
-# (new private providers never appear). The deploy passes the private repo's
-# current HEAD SHA here; when it changes, this layer's cache key changes and the
-# clone re-runs. Defaults to "dev" for local builds.
-ARG PRIVATE_PROVIDERS_REF=31c60ea768fb7b46aa7f04a7916041200052951a
-RUN --mount=type=secret,id=PRIVATE_PROVIDERS_TOKEN,mode=0444,required=false \
-    echo "private providers ref: ${PRIVATE_PROVIDERS_REF}"; \
-    if [ -s /run/secrets/PRIVATE_PROVIDERS_TOKEN ]; then \
-      tok="$(cat /run/secrets/PRIVATE_PROVIDERS_TOKEN)"; \
-      git clone --depth 1 \
-        "https://x-access-token:${tok}@github.com/${PRIVATE_PROVIDERS_REPO}.git" \
-        packages/providers/_private \
-      && rm -rf packages/providers/_private/.git \
-      && echo "cloned private providers into workspace" \
-      || { echo "ERROR: token present but private provider clone failed" >&2; exit 1; }; \
-    else \
-      echo "no PRIVATE_PROVIDERS_TOKEN secret; building without private providers"; \
-    fi; \
-    # Ensure the dir always exists so later COPY --from=deps never fails. A stub
-    # package.json (private, not a workspace match) keeps it inert when empty.
-    if [ ! -e packages/providers/_private/package.json ]; then \
-      mkdir -p packages/providers/_private; \
-      echo '{"name":"@ttsa-private/_placeholder","private":true,"version":"0.0.0"}' \
-        > packages/providers/_private/package.json; \
-    fi
-
-# Install after the private package is in place so bun links it as a workspace
-# (node_modules/@ttsa-private/providers), resolvable by the router.
-RUN bun install
-
-# ── build the web app ──
-FROM base AS build
-COPY --from=deps /app/node_modules ./node_modules
-COPY . .
-RUN cd apps/web && bun run build
-
-# ── runtime ──
-FROM base AS runtime
-ENV NODE_ENV=production
-
-# System deps: supervisord, ffmpeg (router audio normalization), ca-certificates
-# (verify TLS to the Postgres host). The app connects directly to the VPS
-# Postgres over a TLS connection (DATABASE_URL) — no tunnel client in the Space.
-RUN apt-get update \
-  && apt-get install -y --no-install-recommends \
-       supervisor ffmpeg ca-certificates \
-  && rm -rf /var/lib/apt/lists/*
-
-# App: built web + full source for the router (run from source via bun).
-COPY --from=deps /app/node_modules ./node_modules
-COPY --from=build /app/apps/web/.next/standalone ./standalone
-COPY --from=build /app/apps/web/.next/static ./standalone/apps/web/.next/static
-COPY --from=build /app/apps/web/public ./standalone/apps/web/public
-COPY apps/router ./apps/router
-COPY apps/web/drizzle ./apps/web/drizzle
-COPY apps/web/drizzle.config.ts ./apps/web/drizzle.config.ts
-COPY apps/web/src/server/db ./apps/web/src/server/db
-# Public packages from the repo, then the private providers cloned in `deps`
-# (kept out of the repo + build context). The node_modules copied from `deps`
-# already contains bun's workspace symlink node_modules/@ttsa-private/providers
-# -> packages/providers/_private, so the router resolves it via PROVIDER_PLUGINS.
-COPY packages ./packages
-COPY --from=deps /app/packages/providers/_private ./packages/providers/_private
-
-# The prompt corpus (Git LFS). Baked into the image so it ships with the deploy
-# (the source URL is not guaranteed to stay up). PROMPTS_FILE points the app at
-# it; the loader memory-maps it via a line-offset index, never loading it whole.
-COPY apps/web/data/combined_prompts.txt /app/data/combined_prompts.txt
-ENV PROMPTS_FILE=/app/data/combined_prompts.txt
-
-# Entrypoint + supervisor config.
-COPY deploy/space/entrypoint.sh /entrypoint.sh
-COPY deploy/space/supervisord.conf /etc/supervisor/conf.d/tts-arena.conf
-RUN chmod +x /entrypoint.sh
-
-# HF mounts /data and /audio as persistent buckets; create mountpoints.
-RUN mkdir -p /data /audio
-
-EXPOSE 7860
-ENTRYPOINT ["/entrypoint.sh"]

Dockerfile.docs

@@ -1,46 +0,0 @@
-# syntax=docker/dockerfile:1
-#
-# Hugging Face Space image for the docs site (Fumadocs/Next.js). The docs app is
-# fully self-contained — it has no @ttsa/* workspace dependencies — so we build
-# it in isolation, NOT as part of the monorepo workspace. That avoids pulling in
-# unrelated packages (e.g. web's native better-sqlite3) that would need a build
-# toolchain and have nothing to do with the docs.
-FROM oven/bun:1.1.42-debian AS base
-WORKDIR /app/docs
-
-# ── deps ──
-FROM base AS deps
-# Standalone install: only the docs package.json (no root workspace context).
-COPY apps/docs/package.json ./package.json
-RUN bun install
-
-# ── build ──
-FROM base AS build
-COPY --from=deps /app/docs/node_modules ./node_modules
-COPY apps/docs/ ./
-RUN bun run build
-# Stage a flat runtime dir. In this isolated build (no parent workspace) Next's
-# standalone output is flat — server.js, node_modules and package.json at the
-# standalone root — but we locate server.js explicitly so the image is correct
-# regardless of any workspace-root inference, then add the static + public dirs
-# the standalone server expects beside it.
-RUN set -e; \
-    SA="$PWD/.next/standalone"; \
-    SERVER="$(find "$SA" -name server.js -not -path '*/node_modules/*' | head -1)"; \
-    test -n "$SERVER"; \
-    ROOT="$(dirname "$SERVER")"; \
-    mkdir -p "$ROOT/.next"; \
-    cp -a "$PWD/.next/static" "$ROOT/.next/static"; \
-    [ -d "$PWD/public" ] && cp -a "$PWD/public" "$ROOT/public" || true; \
-    cp -a "$ROOT" /out
-
-# ── runtime ──
-FROM base AS runtime
-ENV NODE_ENV=production
-ENV PORT=7860
-ENV HOSTNAME=0.0.0.0
-EXPOSE 7860
-
-WORKDIR /app
-COPY --from=build /out/ ./
-CMD ["bun", "server.js"]

LICENSE

@@ -1,202 +1,20 @@
+Copyright (c) 2024 TTS-AGI Contributors
 
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
+This software is provided ‘as-is’, without any express or implied
+warranty. In no event will the authors be held liable for any damages
+arising from the use of this software.
 
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it
+freely, subject to the following restrictions:
 
-   1. Definitions.
+1. The origin of this software must not be misrepresented; you must not
+claim that you wrote the original software. If you use this software
+in a product, an acknowledgment in the product documentation would be
+appreciated but is not required.
 
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
+2. Altered source versions must be plainly marked as such, and must not be
+misrepresented as being the original software.
 
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
+3. This notice may not be removed or altered from any source
+distribution.

LICENSE.APACHE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

LICENSE.MIT

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 mrfakename
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,16 +1,16 @@
 ---
 title: TTS Arena V2
-emoji: 🗣️
-colorFrom: indigo
-colorTo: purple
-sdk: docker
-app_port: 7860
+emoji: 🏆
+colorFrom: blue
+colorTo: blue
+sdk: gradio
+app_file: app.py
+short_description: Vote on the latest TTS models!
 pinned: true
+
 hf_oauth: true
-hf_oauth_scopes:
-  - email
 ---
 
-# TTS Arena V2
+Please see the [GitHub repo](https://github.com/TTS-AGI/TTS-Arena-V2) for information.
 
-> Source: https://github.com/TTS-AGI/TTS-Arena
+Join the [Discord server](https://discord.gg/HB8fMR6GTr) for updates and support.

SPACES_DOCS_README.md

@@ -1,19 +0,0 @@
----
-title: TTS Arena Docs
-emoji: 📚
-colorFrom: indigo
-colorTo: purple
-sdk: docker
-app_port: 7860
-pinned: false
----
-
-# TTS Arena Docs
-
-Documentation for [TTS Arena](https://huggingface.co/spaces/TTS-AGI/TTS-Arena-V2),
-served at https://docs.ttsarena.org/.
-
-> Source: https://github.com/TTS-AGI/TTS-Arena (apps/docs)
->
-> Built with Fumadocs + Next.js. This Space is deployed automatically from the
-> GitHub repo; do not edit it directly.

TURNSTILE.md

@@ -0,0 +1,58 @@
+# Cloudflare Turnstile Integration
+
+TTS Arena supports Cloudflare Turnstile for bot protection. This guide explains how to set up and configure Turnstile for your deployment.
+
+## What is Cloudflare Turnstile?
+
+Cloudflare Turnstile is a CAPTCHA alternative that provides protection against bots and malicious traffic while maintaining a user-friendly experience. Unlike traditional CAPTCHAs, Turnstile uses a variety of signals to detect bots without forcing legitimate users to solve frustrating puzzles.
+
+## Setup Instructions
+
+### 1. Register for Cloudflare Turnstile
+
+1. Create a Cloudflare account or log in to your existing account
+2. Go to the [Turnstile dashboard](https://dash.cloudflare.com/?to=/:account/turnstile)
+3. Click "Add Site" and follow the instructions
+4. Create a new site key
+   - Choose "Managed" or "Invisible" mode (Managed is recommended for better balance of security and user experience)
+   - Set an appropriate domain policy
+   - Create the site key
+
+Once created, you'll receive a **Site Key** (public) and **Secret Key** (private).
+
+### 2. Configure Environment Variables
+
+Add the following environment variables to your deployment:
+
+```
+TURNSTILE_ENABLED=true
+TURNSTILE_SITE_KEY=your_site_key_here
+TURNSTILE_SECRET_KEY=your_secret_key_here
+TURNSTILE_TIMEOUT_HOURS=24
+```
+
+| Variable | Description |
+|----------|-------------|
+| `TURNSTILE_ENABLED` | Set to `true` to enable Turnstile protection |
+| `TURNSTILE_SITE_KEY` | Your Cloudflare Turnstile site key |
+| `TURNSTILE_SECRET_KEY` | Your Cloudflare Turnstile secret key |
+| `TURNSTILE_TIMEOUT_HOURS` | How often users need to verify (default: 24 hours) |
+
+### 3. Implementation Details
+
+When Turnstile is enabled:
+- All routes and API endpoints require Turnstile verification
+- Users are redirected to a verification page when they first visit
+- Verification status is stored in the session
+- Re-verification is required after the timeout period
+- API requests receive a 403 error if not verified
+
+## Customization
+
+The Turnstile verification page uses the same styling as the main application, providing a seamless user experience. You can customize the appearance by modifying `templates/turnstile.html`.
+
+## Troubleshooting
+
+- **Verification Loops**: If users get stuck in verification loops, check that cookies are being properly stored (ensure proper cookie settings and no browser extensions blocking cookies)
+- **API Errors**: If API clients receive 403 errors, they need to implement Turnstile verification
+- **Missing Environment Variables**: Ensure all required environment variables are set correctly 

admin.py

@@ -0,0 +1,891 @@
+from flask import Blueprint, render_template, current_app, jsonify, request, redirect, url_for, flash
+from models import (
+    db, User, Model, Vote, EloHistory, ModelType, 
+    CoordinatedVotingCampaign, CampaignParticipant, UserTimeout,
+    get_user_timeouts, get_coordinated_campaigns, resolve_campaign,
+    create_user_timeout, cancel_user_timeout, check_user_timeout
+)
+from auth import admin_required
+from security import check_user_security_score
+from sqlalchemy import func, desc, extract, text
+from datetime import datetime, timedelta
+import json
+import os
+from sqlalchemy import or_
+
+admin = Blueprint("admin", __name__, url_prefix="/admin")
+
+@admin.route("/")
+@admin_required
+def index():
+    """Admin dashboard homepage"""
+    # Get count statistics
+    stats = {
+        "total_users": User.query.count(),
+        "total_votes": Vote.query.count(),
+        "tts_votes": Vote.query.filter_by(model_type=ModelType.TTS).count(),
+        "conversational_votes": Vote.query.filter_by(model_type=ModelType.CONVERSATIONAL).count(),
+        "tts_models": Model.query.filter_by(model_type=ModelType.TTS).count(),
+        "conversational_models": Model.query.filter_by(model_type=ModelType.CONVERSATIONAL).count(),
+    }
+    
+    # Get recent votes
+    recent_votes = Vote.query.order_by(Vote.vote_date.desc()).limit(10).all()
+    
+    # Get recent users
+    recent_users = User.query.order_by(User.join_date.desc()).limit(10).all()
+    
+    # Get daily votes for the past 30 days
+    thirty_days_ago = datetime.utcnow().replace(hour=0, minute=0, second=0, microsecond=0) - timedelta(days=30)
+    
+    daily_votes = db.session.query(
+        func.date(Vote.vote_date).label('date'),
+        func.count().label('count')
+    ).filter(Vote.vote_date >= thirty_days_ago).group_by(
+        func.date(Vote.vote_date)
+    ).order_by(func.date(Vote.vote_date)).all()
+    
+    # Generate a complete list of dates for the past 30 days
+    date_list = []
+    current_date = datetime.utcnow()
+    for i in range(30, -1, -1):
+        date_list.append((current_date - timedelta(days=i)).date())
+    
+    # Create a dictionary with actual vote counts
+    vote_counts = {day.date: day.count for day in daily_votes}
+    
+    # Build complete datasets including days with zero votes
+    formatted_dates = [date.strftime("%Y-%m-%d") for date in date_list]
+    vote_counts_list = [vote_counts.get(date, 0) for date in date_list]
+    
+    daily_votes_data = {
+        "labels": formatted_dates,
+        "counts": vote_counts_list
+    }
+    
+    # Get top models
+    top_tts_models = Model.query.filter_by(
+        model_type=ModelType.TTS
+    ).order_by(Model.current_elo.desc()).limit(5).all()
+    
+    top_conversational_models = Model.query.filter_by(
+        model_type=ModelType.CONVERSATIONAL
+    ).order_by(Model.current_elo.desc()).limit(5).all()
+    
+    return render_template(
+        "admin/index.html",
+        stats=stats,
+        recent_votes=recent_votes,
+        recent_users=recent_users,
+        daily_votes_data=json.dumps(daily_votes_data),
+        top_tts_models=top_tts_models,
+        top_conversational_models=top_conversational_models
+    )
+
+@admin.route("/models")
+@admin_required
+def models():
+    """Manage models"""
+    tts_models = Model.query.filter_by(model_type=ModelType.TTS).order_by(Model.name).all()
+    conversational_models = Model.query.filter_by(model_type=ModelType.CONVERSATIONAL).order_by(Model.name).all()
+    
+    return render_template(
+        "admin/models.html",
+        tts_models=tts_models,
+        conversational_models=conversational_models
+    )
+
+
+@admin.route("/model/<model_id>", methods=["GET", "POST"])
+@admin_required
+def edit_model(model_id):
+    """Edit a model"""
+    model = Model.query.get_or_404(model_id)
+    
+    if request.method == "POST":
+        model.name = request.form.get("name")
+        model.is_active = "is_active" in request.form
+        model.is_open = "is_open" in request.form
+        model.model_url = request.form.get("model_url")
+        
+        db.session.commit()
+        flash(f"Model '{model.name}' updated successfully", "success")
+        return redirect(url_for("admin.models"))
+    
+    return render_template("admin/edit_model.html", model=model)
+
+@admin.route("/users")
+@admin_required
+def users():
+    """Manage users"""
+    users = User.query.order_by(User.username).all()
+    admin_users = os.getenv("ADMIN_USERS", "").split(",")
+    admin_users = [username.strip() for username in admin_users]
+    
+    # Calculate security scores for all users
+    users_with_scores = []
+    for user in users:
+        score, factors = check_user_security_score(user.id)
+        users_with_scores.append({
+            'user': user,
+            'security_score': score,
+            'security_factors': factors
+        })
+    
+    # Sort by security score (lowest first to highlight problematic users)
+    users_with_scores.sort(key=lambda x: x['security_score'])
+    
+    return render_template("admin/users.html", users_with_scores=users_with_scores, admin_users=admin_users)
+
+@admin.route("/user/<int:user_id>")
+@admin_required
+def user_detail(user_id):
+    """View user details"""
+    user = User.query.get_or_404(user_id)
+    
+    # Get security score and factors
+    security_score, security_factors = check_user_security_score(user_id)
+    
+    # Get user votes
+    recent_votes = Vote.query.filter_by(user_id=user_id).order_by(Vote.vote_date.desc()).limit(20).all()
+    
+    # Get vote statistics
+    tts_votes = Vote.query.filter_by(user_id=user_id, model_type=ModelType.TTS).count()
+    conversational_votes = Vote.query.filter_by(user_id=user_id, model_type=ModelType.CONVERSATIONAL).count()
+    
+    # Get comprehensive model bias analysis
+    # This counts how often each model was chosen vs how often it appeared
+    model_bias_analysis = []
+    
+    # Get all votes by this user
+    user_votes = Vote.query.filter_by(user_id=user_id).all()
+    
+    if user_votes:
+        model_stats = {}
+        
+        for vote in user_votes:
+            # Track model_chosen
+            chosen_id = vote.model_chosen
+            rejected_id = vote.model_rejected
+            
+            # Initialize model stats if not exists
+            if chosen_id not in model_stats:
+                model_stats[chosen_id] = {'chosen': 0, 'appeared': 0, 'name': None}
+            if rejected_id not in model_stats:
+                model_stats[rejected_id] = {'chosen': 0, 'appeared': 0, 'name': None}
+            
+            # Count appearances and choices
+            model_stats[chosen_id]['chosen'] += 1
+            model_stats[chosen_id]['appeared'] += 1
+            model_stats[rejected_id]['appeared'] += 1
+        
+        # Get model names and calculate bias ratios
+        for model_id, stats in model_stats.items():
+            model = Model.query.get(model_id)
+            if model:
+                stats['name'] = model.name
+                stats['bias_ratio'] = stats['chosen'] / stats['appeared'] if stats['appeared'] > 0 else 0
+                stats['model_id'] = model_id
+        
+        # Sort by bias ratio (highest bias first) and take top 5
+        model_bias_analysis = sorted(
+            [stats for stats in model_stats.values() if stats['name'] is not None],
+            key=lambda x: x['bias_ratio'],
+            reverse=True
+        )[:5]
+    
+    return render_template(
+        "admin/user_detail.html",
+        user=user,
+        security_score=security_score,
+        security_factors=security_factors,
+        recent_votes=recent_votes,
+        tts_votes=tts_votes,
+        conversational_votes=conversational_votes,
+        model_bias_analysis=model_bias_analysis,
+        total_votes=tts_votes + conversational_votes
+    )
+
+@admin.route("/votes")
+@admin_required
+def votes():
+    """View recent votes"""
+    page = request.args.get('page', 1, type=int)
+    per_page = 50
+    
+    # Get votes with pagination
+    votes_pagination = Vote.query.order_by(
+        Vote.vote_date.desc()
+    ).paginate(page=page, per_page=per_page)
+    
+    return render_template(
+        "admin/votes.html",
+        votes=votes_pagination.items,
+        pagination=votes_pagination
+    )
+
+@admin.route("/statistics")
+@admin_required
+def statistics():
+    """View detailed statistics"""
+    # Get daily votes for the past 30 days by model type
+    thirty_days_ago = datetime.utcnow().replace(hour=0, minute=0, second=0, microsecond=0) - timedelta(days=30)
+    
+    tts_daily_votes = db.session.query(
+        func.date(Vote.vote_date).label('date'),
+        func.count().label('count')
+    ).filter(
+        Vote.vote_date >= thirty_days_ago,
+        Vote.model_type == ModelType.TTS
+    ).group_by(
+        func.date(Vote.vote_date)
+    ).order_by(func.date(Vote.vote_date)).all()
+    
+    conv_daily_votes = db.session.query(
+        func.date(Vote.vote_date).label('date'),
+        func.count().label('count')
+    ).filter(
+        Vote.vote_date >= thirty_days_ago,
+        Vote.model_type == ModelType.CONVERSATIONAL
+    ).group_by(
+        func.date(Vote.vote_date)
+    ).order_by(func.date(Vote.vote_date)).all()
+    
+    # Monthly new users
+    monthly_users = db.session.query(
+        extract('year', User.join_date).label('year'),
+        extract('month', User.join_date).label('month'),
+        func.count().label('count')
+    ).group_by(
+        'year', 'month'
+    ).order_by('year', 'month').all()
+    
+    # Generate a complete list of dates for the past 30 days
+    date_list = []
+    current_date = datetime.utcnow()
+    for i in range(30, -1, -1):
+        date_list.append((current_date - timedelta(days=i)).date())
+    
+    # Create dictionaries with actual vote counts
+    tts_vote_counts = {day.date: day.count for day in tts_daily_votes}
+    conv_vote_counts = {day.date: day.count for day in conv_daily_votes}
+    
+    # Format dates consistently for charts
+    formatted_dates = [date.strftime("%Y-%m-%d") for date in date_list]
+    
+    # Build complete datasets including days with zero votes
+    tts_counts = [tts_vote_counts.get(date, 0) for date in date_list]
+    conv_counts = [conv_vote_counts.get(date, 0) for date in date_list]
+    
+    # Generate all month/year combinations for the past 12 months
+    current_date = datetime.utcnow()
+    month_list = []
+    for i in range(11, -1, -1):
+        past_date = current_date - timedelta(days=i*30)  # Approximate
+        month_list.append((past_date.year, past_date.month))
+    
+    # Create a dictionary with actual user counts
+    user_counts = {(record.year, record.month): record.count for record in monthly_users}
+    
+    # Build complete monthly datasets including months with zero new users
+    monthly_labels = [f"{month}/{year}" for year, month in month_list]
+    monthly_counts = [user_counts.get((year, month), 0) for year, month in month_list]
+    
+    # Model performance over time
+    top_models = Model.query.order_by(Model.match_count.desc()).limit(5).all()
+    
+    # Get first and last timestamp to create a consistent timeline
+    earliest = datetime.utcnow() - timedelta(days=30)  # Default to 30 days ago
+    latest = datetime.utcnow()  # Default to now
+    
+    # Find actual earliest and latest timestamps across all models
+    has_elo_history = False
+    for model in top_models:
+        first = EloHistory.query.filter_by(model_id=model.id).order_by(EloHistory.timestamp).first()
+        last = EloHistory.query.filter_by(model_id=model.id).order_by(EloHistory.timestamp.desc()).first()
+        
+        if first and last:
+            has_elo_history = True
+            if first.timestamp < earliest:
+                earliest = first.timestamp
+            if last.timestamp > latest:
+                latest = last.timestamp
+    
+    # If no history was found, use a default range of the last 30 days
+    if not has_elo_history:
+        earliest = datetime.utcnow() - timedelta(days=30)
+        latest = datetime.utcnow()
+    
+    # Make sure the date range is valid (earliest before latest)
+    if earliest > latest:
+        earliest = latest - timedelta(days=30)
+    
+    # Generate a list of dates for the ELO history timeline
+    # Using 1-day intervals for a smoother chart
+    elo_dates = []
+    current = earliest
+    while current <= latest:
+        elo_dates.append(current.date())
+        current += timedelta(days=1)
+    
+    # Format dates consistently
+    formatted_elo_dates = [date.strftime("%Y-%m-%d") for date in elo_dates]
+    
+    model_history = {}
+    
+    # Initialize empty data for all top models
+    for model in top_models:
+        model_history[model.name] = {
+            "timestamps": formatted_elo_dates,
+            "scores": [None] * len(formatted_elo_dates)  # Initialize with None values
+        }
+        
+        history = EloHistory.query.filter_by(
+            model_id=model.id
+        ).order_by(EloHistory.timestamp).all()
+        
+        if history:
+            # Create a dictionary mapping dates to scores
+            history_dict = {}
+            for h in history:
+                date_key = h.timestamp.date().strftime("%Y-%m-%d")
+                history_dict[date_key] = h.elo_score
+            
+            # Fill in missing dates with the previous score
+            last_score = model.current_elo  # Default to current ELO if no history
+            scores = []
+            
+            for date in formatted_elo_dates:
+                if date in history_dict:
+                    last_score = history_dict[date]
+                scores.append(last_score)
+            
+            model_history[model.name]["scores"] = scores
+        else:
+            # If no history, use the current Elo for all dates
+            model_history[model.name]["scores"] = [model.current_elo] * len(formatted_elo_dates)
+    
+    chart_data = {
+        "dailyVotes": {
+            "labels": formatted_dates,
+            "ttsCounts": tts_counts,
+            "convCounts": conv_counts
+        },
+        "monthlyUsers": {
+            "labels": monthly_labels,
+            "counts": monthly_counts
+        },
+        "modelHistory": model_history
+    }
+    
+    return render_template(
+        "admin/statistics.html",
+        chart_data=json.dumps(chart_data)
+    )
+
+@admin.route("/activity")
+@admin_required
+def activity():
+    """View recent text generations"""
+    # Check if we have any active sessions from app.py
+    tts_session_count = 0
+    conversational_session_count = 0
+    
+    # Access global variables from app.py through current_app
+    if hasattr(current_app, 'tts_sessions'):
+        tts_session_count = len(current_app.tts_sessions)
+    else:  # Try to access through app module
+        from app import tts_sessions
+        tts_session_count = len(tts_sessions)
+    
+    if hasattr(current_app, 'conversational_sessions'):
+        conversational_session_count = len(current_app.conversational_sessions)
+    else:  # Try to access through app module
+        from app import conversational_sessions
+        conversational_session_count = len(conversational_sessions)
+    
+    # Get recent votes which represent completed generations
+    recent_tts_votes = Vote.query.filter_by(
+        model_type=ModelType.TTS
+    ).order_by(Vote.vote_date.desc()).limit(20).all()
+    
+    recent_conv_votes = Vote.query.filter_by(
+        model_type=ModelType.CONVERSATIONAL
+    ).order_by(Vote.vote_date.desc()).limit(20).all()
+    
+    # Get votes per hour for the last 24 hours
+    current_time = datetime.utcnow()
+    last_24h = current_time.replace(minute=0, second=0, microsecond=0) - timedelta(hours=24)
+    
+    # Use SQLite-compatible date formatting
+    hourly_votes = db.session.query(
+        func.strftime('%Y-%m-%d %H:00', Vote.vote_date).label('hour'),
+        func.count().label('count')
+    ).filter(
+        Vote.vote_date >= last_24h
+    ).group_by('hour').order_by('hour').all()
+    
+    # Generate all hours for the past 24 hours with correct hour formatting
+    hour_list = []
+    for i in range(24, -1, -1):
+        # Calculate the hour time and truncate to hour
+        hour_time = current_time - timedelta(hours=i)
+        hour_time = hour_time.replace(minute=0, second=0, microsecond=0)
+        hour_list.append(hour_time.strftime('%Y-%m-%d %H:00'))
+    
+    # Create a dictionary with actual vote counts
+    vote_counts = {hour.hour: hour.count for hour in hourly_votes}
+    
+    # Build complete hourly datasets including hours with zero votes
+    hourly_data = {
+        "labels": hour_list,
+        "counts": [vote_counts.get(hour, 0) for hour in hour_list]
+    }
+    
+    return render_template(
+        "admin/activity.html",
+        tts_session_count=tts_session_count,
+        conversational_session_count=conversational_session_count,
+        recent_tts_votes=recent_tts_votes,
+        recent_conv_votes=recent_conv_votes,
+        hourly_data=json.dumps(hourly_data)
+    )
+
+@admin.route("/analytics")
+@admin_required
+def analytics():
+    """View analytics data including session duration, IP addresses, etc."""
+    
+    # Get analytics statistics
+    analytics_stats = {}
+    
+    try:
+        # Session duration statistics
+        duration_stats = db.session.execute(text("""
+            SELECT 
+                AVG(session_duration_seconds) as avg_duration,
+                MIN(session_duration_seconds) as min_duration,
+                MAX(session_duration_seconds) as max_duration,
+                COUNT(session_duration_seconds) as total_with_duration
+            FROM vote 
+            WHERE session_duration_seconds IS NOT NULL
+        """)).fetchone()
+        
+        analytics_stats['duration'] = {
+            'avg': round(duration_stats.avg_duration, 2) if duration_stats.avg_duration else 0,
+            'min': round(duration_stats.min_duration, 2) if duration_stats.min_duration else 0,
+            'max': round(duration_stats.max_duration, 2) if duration_stats.max_duration else 0,
+            'total': duration_stats.total_with_duration or 0
+        }
+        
+        # Cache hit statistics
+        cache_stats = db.session.execute(text("""
+            SELECT 
+                cache_hit,
+                COUNT(*) as count
+            FROM vote 
+            WHERE cache_hit IS NOT NULL
+            GROUP BY cache_hit
+        """)).fetchall()
+        
+        analytics_stats['cache'] = {
+            'hits': 0,
+            'misses': 0,
+            'total': 0
+        }
+        
+        for stat in cache_stats:
+            if stat.cache_hit:
+                analytics_stats['cache']['hits'] = stat.count
+            else:
+                analytics_stats['cache']['misses'] = stat.count
+            analytics_stats['cache']['total'] += stat.count
+        
+        # Top IP address regions (anonymized)
+        ip_stats = db.session.execute(text("""
+            SELECT 
+                ip_address_partial,
+                COUNT(*) as count
+            FROM vote 
+            WHERE ip_address_partial IS NOT NULL
+            GROUP BY ip_address_partial
+            ORDER BY count DESC
+            LIMIT 10
+        """)).fetchall()
+        
+        analytics_stats['top_ips'] = [
+            {'ip': stat.ip_address_partial, 'count': stat.count}
+            for stat in ip_stats
+        ]
+        
+        # User agent statistics (top browsers/devices)
+        ua_stats = db.session.execute(text("""
+            SELECT 
+                CASE 
+                    WHEN user_agent LIKE '%Chrome%' THEN 'Chrome'
+                    WHEN user_agent LIKE '%Firefox%' THEN 'Firefox'
+                    WHEN user_agent LIKE '%Safari%' AND user_agent NOT LIKE '%Chrome%' THEN 'Safari'
+                    WHEN user_agent LIKE '%Edge%' THEN 'Edge'
+                    WHEN user_agent LIKE '%Mobile%' OR user_agent LIKE '%Android%' THEN 'Mobile'
+                    ELSE 'Other'
+                END as browser,
+                COUNT(*) as count
+            FROM vote 
+            WHERE user_agent IS NOT NULL
+            GROUP BY browser
+            ORDER BY count DESC
+        """)).fetchall()
+        
+        analytics_stats['browsers'] = [
+            {'browser': stat.browser, 'count': stat.count}
+            for stat in ua_stats
+        ]
+        
+        # Recent votes with analytics data
+        recent_analytics = db.session.execute(text("""
+            SELECT 
+                v.id,
+                v.vote_date,
+                v.session_duration_seconds,
+                v.ip_address_partial,
+                v.cache_hit,
+                v.model_type,
+                u.username,
+                m1.name as chosen_model,
+                m2.name as rejected_model
+            FROM vote v
+            LEFT JOIN user u ON v.user_id = u.id
+            LEFT JOIN model m1 ON v.model_chosen = m1.id
+            LEFT JOIN model m2 ON v.model_rejected = m2.id
+            WHERE v.session_duration_seconds IS NOT NULL
+            ORDER BY v.vote_date DESC
+            LIMIT 20
+        """)).fetchall()
+        
+        analytics_stats['recent_votes'] = [
+            {
+                'id': vote.id,
+                'vote_date': vote.vote_date if isinstance(vote.vote_date, datetime) else datetime.fromisoformat(str(vote.vote_date).replace('Z', '+00:00')) if vote.vote_date else None,
+                'duration': round(vote.session_duration_seconds, 2) if vote.session_duration_seconds else None,
+                'ip': vote.ip_address_partial,
+                'cache_hit': vote.cache_hit,
+                'model_type': vote.model_type,
+                'username': vote.username,
+                'chosen_model': vote.chosen_model,
+                'rejected_model': vote.rejected_model
+            }
+            for vote in recent_analytics
+        ]
+        
+    except Exception as e:
+        flash(f"Error retrieving analytics data: {str(e)}", "error")
+        analytics_stats = {}
+    
+    return render_template(
+        "admin/analytics.html", 
+        analytics_stats=analytics_stats
+    )
+
+@admin.route("/security")
+@admin_required
+def security():
+    """View security monitoring data and suspicious activity."""
+    try:
+        from security import (
+            detect_suspicious_voting_patterns, 
+            detect_coordinated_voting, 
+            check_user_security_score,
+            detect_model_bias
+        )
+        
+        # Get recent suspicious users
+        recent_users = User.query.order_by(User.join_date.desc()).limit(50).all()
+        suspicious_users = []
+        
+        for user in recent_users:
+            score, factors = check_user_security_score(user.id)
+            if score < 50:  # Flag users with low security scores
+                suspicious_users.append({
+                    'user': user,
+                    'score': score,
+                    'factors': factors
+                })
+        
+        # Sort by lowest score first
+        suspicious_users.sort(key=lambda x: x['score'])
+        
+        # Check for coordinated voting on top models
+        top_models = Model.query.order_by(Model.current_elo.desc()).limit(10).all()
+        coordinated_campaigns = []
+        
+        for model in top_models:
+            is_coordinated, user_count, vote_count, suspicious_users_list = detect_coordinated_voting(model.id)
+            if is_coordinated:
+                coordinated_campaigns.append({
+                    'model': model,
+                    'user_count': user_count,
+                    'vote_count': vote_count,
+                    'suspicious_users': suspicious_users_list
+                })
+        
+        # Get users with high model bias
+        biased_users = []
+        for model in top_models:
+            # Check recent voters for this model
+            recent_voters = db.session.query(Vote.user_id).filter(
+                Vote.model_chosen == model.id
+            ).distinct().limit(20).all()
+            
+            for voter in recent_voters:
+                if voter.user_id:
+                    is_biased, bias_ratio, votes_for_model, total_votes = detect_model_bias(
+                        voter.user_id, model.id
+                    )
+                    if is_biased and total_votes >= 5:
+                        user = User.query.get(voter.user_id)
+                        if user:
+                            biased_users.append({
+                                'user': user,
+                                'model': model,
+                                'bias_ratio': bias_ratio,
+                                'votes_for_model': votes_for_model,
+                                'total_votes': total_votes
+                            })
+        
+        # Remove duplicates and sort by bias ratio
+        seen_users = set()
+        unique_biased_users = []
+        for item in biased_users:
+            user_model_key = (item['user'].id, item['model'].id)
+            if user_model_key not in seen_users:
+                seen_users.add(user_model_key)
+                unique_biased_users.append(item)
+        
+        unique_biased_users.sort(key=lambda x: x['bias_ratio'], reverse=True)
+        
+        # Get recent security blocks from logs (if available)
+        security_blocks = []
+        try:
+            # This would require parsing application logs
+            # For now, we'll show a placeholder
+            pass
+        except Exception:
+            pass
+        
+        return render_template(
+            "admin/security.html",
+            suspicious_users=suspicious_users[:20],  # Limit to top 20
+            coordinated_campaigns=coordinated_campaigns,
+            biased_users=unique_biased_users[:20],  # Limit to top 20
+            security_blocks=security_blocks
+        )
+        
+    except ImportError:
+        flash("Security module not available", "error")
+        return redirect(url_for("admin.index"))
+    except Exception as e:
+        flash(f"Error loading security data: {str(e)}", "error")
+        return redirect(url_for("admin.index"))
+
+
+@admin.route("/timeouts")
+@admin_required
+def timeouts():
+    """Manage user timeouts"""
+    # Get active timeouts
+    active_timeouts = get_user_timeouts(active_only=True, limit=100)
+    
+    # Get recent expired/cancelled timeouts
+    recent_inactive = UserTimeout.query.filter(
+        or_(
+            UserTimeout.is_active == False,
+            UserTimeout.expires_at <= datetime.utcnow()
+        )
+    ).order_by(UserTimeout.created_at.desc()).limit(50).all()
+    
+    # Get coordinated campaigns for context
+    recent_campaigns = get_coordinated_campaigns(limit=20)
+    
+    return render_template(
+        "admin/timeouts.html",
+        active_timeouts=active_timeouts,
+        recent_inactive=recent_inactive,
+        recent_campaigns=recent_campaigns
+    )
+
+
+@admin.route("/timeout/create", methods=["POST"])
+@admin_required
+def create_timeout():
+    """Create a new user timeout"""
+    try:
+        user_id = request.form.get("user_id", type=int)
+        reason = request.form.get("reason", "").strip()
+        timeout_type = request.form.get("timeout_type", "manual")
+        duration_days = request.form.get("duration_days", type=int)
+        
+        if not all([user_id, reason, duration_days]):
+            flash("All fields are required", "error")
+            return redirect(url_for("admin.timeouts"))
+        
+        if duration_days < 1 or duration_days > 365:
+            flash("Duration must be between 1 and 365 days", "error")
+            return redirect(url_for("admin.timeouts"))
+        
+        # Check if user exists
+        user = User.query.get(user_id)
+        if not user:
+            flash("User not found", "error")
+            return redirect(url_for("admin.timeouts"))
+        
+        # Check if user already has an active timeout
+        is_timed_out, existing_timeout = check_user_timeout(user_id)
+        if is_timed_out:
+            flash(f"User {user.username} already has an active timeout until {existing_timeout.expires_at}", "error")
+            return redirect(url_for("admin.timeouts"))
+        
+        # Create timeout
+        from flask_login import current_user
+        timeout = create_user_timeout(
+            user_id=user_id,
+            reason=reason,
+            timeout_type=timeout_type,
+            duration_days=duration_days,
+            created_by=current_user.id if current_user.is_authenticated else None
+        )
+        
+        flash(f"Timeout created for {user.username} (expires: {timeout.expires_at})", "success")
+        
+    except Exception as e:
+        flash(f"Error creating timeout: {str(e)}", "error")
+    
+    return redirect(url_for("admin.timeouts"))
+
+
+@admin.route("/timeout/cancel/<int:timeout_id>", methods=["POST"])
+@admin_required
+def cancel_timeout(timeout_id):
+    """Cancel an active timeout"""
+    try:
+        cancel_reason = request.form.get("cancel_reason", "").strip()
+        if not cancel_reason:
+            flash("Cancel reason is required", "error")
+            return redirect(url_for("admin.timeouts"))
+        
+        from flask_login import current_user
+        success, message = cancel_user_timeout(
+            timeout_id=timeout_id,
+            cancelled_by=current_user.id if current_user.is_authenticated else None,
+            cancel_reason=cancel_reason
+        )
+        
+        if success:
+            flash(message, "success")
+        else:
+            flash(message, "error")
+            
+    except Exception as e:
+        flash(f"Error cancelling timeout: {str(e)}", "error")
+    
+    return redirect(url_for("admin.timeouts"))
+
+
+@admin.route("/campaigns")
+@admin_required
+def campaigns():
+    """View and manage coordinated voting campaigns"""
+    status_filter = request.args.get("status", "all")
+    
+    if status_filter == "all":
+        campaigns = get_coordinated_campaigns(limit=100)
+    else:
+        campaigns = get_coordinated_campaigns(status=status_filter, limit=100)
+    
+    # Get campaign statistics
+    stats = {
+        "total": CoordinatedVotingCampaign.query.count(),
+        "active": CoordinatedVotingCampaign.query.filter_by(status="active").count(),
+        "resolved": CoordinatedVotingCampaign.query.filter_by(status="resolved").count(),
+        "false_positive": CoordinatedVotingCampaign.query.filter_by(status="false_positive").count(),
+    }
+    
+    return render_template(
+        "admin/campaigns.html",
+        campaigns=campaigns,
+        stats=stats,
+        current_filter=status_filter
+    )
+
+
+@admin.route("/campaign/<int:campaign_id>")
+@admin_required
+def campaign_detail(campaign_id):
+    """View detailed information about a coordinated voting campaign"""
+    campaign = CoordinatedVotingCampaign.query.get_or_404(campaign_id)
+    
+    # Get participants with user details
+    participants = db.session.query(CampaignParticipant, User).join(
+        User, CampaignParticipant.user_id == User.id
+    ).filter(CampaignParticipant.campaign_id == campaign_id).all()
+    
+    # Get related timeouts
+    related_timeouts = UserTimeout.query.filter_by(
+        related_campaign_id=campaign_id
+    ).all()
+    
+    return render_template(
+        "admin/campaign_detail.html",
+        campaign=campaign,
+        participants=participants,
+        related_timeouts=related_timeouts
+    )
+
+
+@admin.route("/campaign/resolve/<int:campaign_id>", methods=["POST"])
+@admin_required
+def resolve_campaign_route(campaign_id):
+    """Mark a campaign as resolved"""
+    try:
+        status = request.form.get("status")
+        admin_notes = request.form.get("admin_notes", "").strip()
+        
+        if status not in ["resolved", "false_positive"]:
+            flash("Invalid status", "error")
+            return redirect(url_for("admin.campaign_detail", campaign_id=campaign_id))
+        
+        from flask_login import current_user
+        success, message = resolve_campaign(
+            campaign_id=campaign_id,
+            resolved_by=current_user.id if current_user.is_authenticated else None,
+            status=status,
+            admin_notes=admin_notes
+        )
+        
+        if success:
+            flash(f"Campaign marked as {status}", "success")
+        else:
+            flash(message, "error")
+            
+    except Exception as e:
+        flash(f"Error resolving campaign: {str(e)}", "error")
+    
+    return redirect(url_for("admin.campaign_detail", campaign_id=campaign_id))
+
+
+@admin.route("/api/user-search")
+@admin_required
+def user_search():
+    """Search for users by username (for timeout creation)"""
+    query = request.args.get("q", "").strip()
+    if len(query) < 2:
+        return jsonify([])
+    
+    users = User.query.filter(
+        User.username.ilike(f"%{query}%")
+    ).limit(10).all()
+    
+    return jsonify([{
+        "id": user.id,
+        "username": user.username,
+        "join_date": user.join_date.strftime("%Y-%m-%d") if user.join_date else "N/A"
+    } for user in users]) 

app.py

@@ -0,0 +1,1694 @@
+import os
+from huggingface_hub import HfApi, hf_hub_download
+from apscheduler.schedulers.background import BackgroundScheduler
+from concurrent.futures import ThreadPoolExecutor
+from datetime import datetime
+import threading # Added for locking
+from sqlalchemy import or_ # Added for vote counting query
+from datasets import load_dataset
+
+year = datetime.now().year
+month = datetime.now().month
+
+# Check if running in a Huggin Face Space
+IS_SPACES = False
+if os.getenv("SPACE_REPO_NAME"):
+    print("Running in a Hugging Face Space 🤗")
+    IS_SPACES = True
+
+    # Setup database sync for HF Spaces
+    if not os.path.exists("instance/tts_arena.db"):
+        os.makedirs("instance", exist_ok=True)
+        try:
+            print("Database not found, downloading from HF dataset...")
+            hf_hub_download(
+                repo_id="TTS-AGI/database-arena-v2",
+                filename="tts_arena.db",
+                repo_type="dataset",
+                local_dir="instance",
+                token=os.getenv("HF_TOKEN"),
+            )
+            print("Database downloaded successfully ✅")
+        except Exception as e:
+            print(f"Error downloading database from HF dataset: {str(e)} ⚠️")
+
+from flask import (
+    Flask,
+    render_template,
+    g,
+    request,
+    jsonify,
+    send_file,
+    redirect,
+    url_for,
+    session,
+    abort,
+)
+from flask_login import LoginManager, current_user
+from models import *
+from models import (
+    hash_sentence, is_sentence_consumed, mark_sentence_consumed,
+    get_unconsumed_sentences, get_consumed_sentences_count, get_random_unconsumed_sentence
+)
+from auth import auth, init_oauth, is_admin
+from admin import admin
+from security import is_vote_allowed, check_user_security_score, detect_coordinated_voting
+import os
+from dotenv import load_dotenv
+from flask_limiter import Limiter
+from flask_limiter.util import get_remote_address
+import uuid
+import tempfile
+import shutil
+from tts import predict_tts
+import random
+import json
+from datetime import datetime, timedelta
+from flask_migrate import Migrate
+import requests
+import functools
+import time # Added for potential retries
+from langdetect import detect, DetectorFactory
+
+# Set random seed for consistent language detection results
+DetectorFactory.seed = 0
+
+
+def is_english_text(text):
+    """
+    Detect if the given text is in English.
+    Returns True if English, False otherwise.
+    """
+    try:
+        # Remove leading/trailing whitespace and check if text is not empty
+        text = text.strip()
+        if not text:
+            return False
+        
+        # Detect language
+        detected_language = detect(text)
+        return detected_language == 'en'
+    except Exception:
+        # If detection fails, assume it's not English for safety
+        return False
+
+
+def get_client_ip():
+    """Get the client's IP address, handling proxies and load balancers."""
+    # Check for forwarded headers first (common with reverse proxies)
+    if request.headers.get('X-Forwarded-For'):
+        # X-Forwarded-For can contain multiple IPs, take the first one
+        return request.headers.get('X-Forwarded-For').split(',')[0].strip()
+    elif request.headers.get('X-Real-IP'):
+        return request.headers.get('X-Real-IP')
+    elif request.headers.get('CF-Connecting-IP'):  # Cloudflare
+        return request.headers.get('CF-Connecting-IP')
+    else:
+        return request.remote_addr
+
+
+# Load environment variables
+if not IS_SPACES:
+    load_dotenv()  # Only load .env if not running in a Hugging Face Space
+
+app = Flask(__name__)
+app.config["SECRET_KEY"] = os.getenv("SECRET_KEY", os.urandom(24))
+app.config["SQLALCHEMY_DATABASE_URI"] = os.getenv(
+    "DATABASE_URI", "sqlite:///tts_arena.db"
+)
+app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False
+app.config["SESSION_COOKIE_SECURE"] = True
+app.config["SESSION_COOKIE_SAMESITE"] = (
+    "None" if IS_SPACES else "Lax"
+)  # HF Spaces uses iframes to load the app, so we need to set SAMESITE to None
+app.config["PERMANENT_SESSION_LIFETIME"] = timedelta(days=30)  # Set to desired duration
+
+# Force HTTPS when running in HuggingFace Spaces
+if IS_SPACES:
+    app.config["PREFERRED_URL_SCHEME"] = "https"
+
+# Cloudflare Turnstile settings
+app.config["TURNSTILE_ENABLED"] = (
+    os.getenv("TURNSTILE_ENABLED", "False").lower() == "true"
+)
+app.config["TURNSTILE_SITE_KEY"] = os.getenv("TURNSTILE_SITE_KEY", "")
+app.config["TURNSTILE_SECRET_KEY"] = os.getenv("TURNSTILE_SECRET_KEY", "")
+app.config["TURNSTILE_VERIFY_URL"] = (
+    "https://challenges.cloudflare.com/turnstile/v0/siteverify"
+)
+
+migrate = Migrate(app, db)
+
+# Initialize extensions
+db.init_app(app)
+login_manager = LoginManager()
+login_manager.init_app(app)
+login_manager.login_view = "auth.login"
+
+# Initialize OAuth
+init_oauth(app)
+
+# Configure rate limits
+limiter = Limiter(
+    app=app,
+    key_func=get_remote_address,
+    default_limits=["2000 per day", "50 per minute"],
+    storage_uri="memory://",
+)
+
+# TTS Cache Configuration - Read from environment
+TTS_CACHE_SIZE = int(os.getenv("TTS_CACHE_SIZE", "10"))
+CACHE_AUDIO_SUBDIR = "cache"
+tts_cache = {} # sentence -> {model_a, model_b, audio_a, audio_b, created_at}
+tts_cache_lock = threading.Lock()
+SMOOTHING_FACTOR_MODEL_SELECTION = 500 # For weighted random model selection
+# Increased max_workers to 8 for concurrent generation/refill
+cache_executor = ThreadPoolExecutor(max_workers=8, thread_name_prefix='CacheReplacer')
+all_harvard_sentences = [] # Keep the full list available
+
+# Create temp directories
+TEMP_AUDIO_DIR = os.path.join(tempfile.gettempdir(), "tts_arena_audio")
+CACHE_AUDIO_DIR = os.path.join(TEMP_AUDIO_DIR, CACHE_AUDIO_SUBDIR)
+os.makedirs(TEMP_AUDIO_DIR, exist_ok=True)
+os.makedirs(CACHE_AUDIO_DIR, exist_ok=True) # Ensure cache subdir exists
+
+
+# Store active TTS sessions
+app.tts_sessions = {}
+tts_sessions = app.tts_sessions
+
+# Store active conversational sessions
+app.conversational_sessions = {}
+conversational_sessions = app.conversational_sessions
+
+# Register blueprints
+app.register_blueprint(auth, url_prefix="/auth")
+app.register_blueprint(admin)
+
+
+@login_manager.user_loader
+def load_user(user_id):
+    return User.query.get(int(user_id))
+
+
+@app.before_request
+def before_request():
+    g.user = current_user
+    g.is_admin = is_admin(current_user)
+
+    # Ensure HTTPS for HuggingFace Spaces environment
+    if IS_SPACES and request.headers.get("X-Forwarded-Proto") == "http":
+        url = request.url.replace("http://", "https://", 1)
+        return redirect(url, code=301)
+
+    # Check if Turnstile verification is required
+    if app.config["TURNSTILE_ENABLED"]:
+        # Exclude verification routes
+        excluded_routes = ["verify_turnstile", "turnstile_page", "static"]
+        if request.endpoint not in excluded_routes:
+            # Check if user is verified
+            if not session.get("turnstile_verified"):
+                # Save original URL for redirect after verification
+                redirect_url = request.url
+                # Force HTTPS in HuggingFace Spaces
+                if IS_SPACES and redirect_url.startswith("http://"):
+                    redirect_url = redirect_url.replace("http://", "https://", 1)
+
+                # If it's an API request, return a JSON response
+                if request.path.startswith("/api/"):
+                    return jsonify({"error": "Turnstile verification required"}), 403
+                # For regular requests, redirect to verification page
+                return redirect(url_for("turnstile_page", redirect_url=redirect_url))
+            else:
+                # Check if verification has expired (default: 24 hours)
+                verification_timeout = (
+                    int(os.getenv("TURNSTILE_TIMEOUT_HOURS", "24")) * 3600
+                )  # Convert hours to seconds
+                verified_at = session.get("turnstile_verified_at", 0)
+                current_time = datetime.utcnow().timestamp()
+
+                if current_time - verified_at > verification_timeout:
+                    # Verification expired, clear status and redirect to verification page
+                    session.pop("turnstile_verified", None)
+                    session.pop("turnstile_verified_at", None)
+
+                    redirect_url = request.url
+                    # Force HTTPS in HuggingFace Spaces
+                    if IS_SPACES and redirect_url.startswith("http://"):
+                        redirect_url = redirect_url.replace("http://", "https://", 1)
+
+                    if request.path.startswith("/api/"):
+                        return jsonify({"error": "Turnstile verification expired"}), 403
+                    return redirect(
+                        url_for("turnstile_page", redirect_url=redirect_url)
+                    )
+
+
+@app.route("/turnstile", methods=["GET"])
+def turnstile_page():
+    """Display Cloudflare Turnstile verification page"""
+    redirect_url = request.args.get("redirect_url", url_for("arena", _external=True))
+
+    # Force HTTPS in HuggingFace Spaces
+    if IS_SPACES and redirect_url.startswith("http://"):
+        redirect_url = redirect_url.replace("http://", "https://", 1)
+
+    return render_template(
+        "turnstile.html",
+        turnstile_site_key=app.config["TURNSTILE_SITE_KEY"],
+        redirect_url=redirect_url,
+    )
+
+
+@app.route("/verify-turnstile", methods=["POST"])
+def verify_turnstile():
+    """Verify Cloudflare Turnstile token"""
+    token = request.form.get("cf-turnstile-response")
+    redirect_url = request.form.get("redirect_url", url_for("arena", _external=True))
+
+    # Force HTTPS in HuggingFace Spaces
+    if IS_SPACES and redirect_url.startswith("http://"):
+        redirect_url = redirect_url.replace("http://", "https://", 1)
+
+    if not token:
+        # If AJAX request, return JSON error
+        if request.headers.get("X-Requested-With") == "XMLHttpRequest":
+            return (
+                jsonify({"success": False, "error": "Missing verification token"}),
+                400,
+            )
+        # Otherwise redirect back to turnstile page
+        return redirect(url_for("turnstile_page", redirect_url=redirect_url))
+
+    # Verify token with Cloudflare
+    data = {
+        "secret": app.config["TURNSTILE_SECRET_KEY"],
+        "response": token,
+        "remoteip": request.remote_addr,
+    }
+
+    try:
+        response = requests.post(app.config["TURNSTILE_VERIFY_URL"], data=data)
+        result = response.json()
+
+        if result.get("success"):
+            # Set verification status in session
+            session["turnstile_verified"] = True
+            session["turnstile_verified_at"] = datetime.utcnow().timestamp()
+
+            # Determine response type based on request
+            is_xhr = request.headers.get("X-Requested-With") == "XMLHttpRequest"
+            accepts_json = "application/json" in request.headers.get("Accept", "")
+
+            # If AJAX or JSON request, return success JSON
+            if is_xhr or accepts_json:
+                return jsonify({"success": True, "redirect": redirect_url})
+
+            # For regular form submissions, redirect to the target URL
+            return redirect(redirect_url)
+        else:
+            # Verification failed
+            app.logger.warning(f"Turnstile verification failed: {result}")
+
+            # If AJAX request, return JSON error
+            if request.headers.get("X-Requested-With") == "XMLHttpRequest":
+                return jsonify({"success": False, "error": "Verification failed"}), 403
+
+            # Otherwise redirect back to turnstile page
+            return redirect(url_for("turnstile_page", redirect_url=redirect_url))
+
+    except Exception as e:
+        app.logger.error(f"Turnstile verification error: {str(e)}")
+
+        # If AJAX request, return JSON error
+        if request.headers.get("X-Requested-With") == "XMLHttpRequest":
+            return (
+                jsonify(
+                    {"success": False, "error": "Server error during verification"}
+                ),
+                500,
+            )
+
+        # Otherwise redirect back to turnstile page
+        return redirect(url_for("turnstile_page", redirect_url=redirect_url))
+
+# Load sentences from the TTS-AGI/arena-prompts dataset
+print("Loading TTS-AGI/arena-prompts dataset...")
+dataset = load_dataset("TTS-AGI/arena-prompts", split="train")
+# Extract the text column and clean up
+all_harvard_sentences = [item['text'].strip() for item in dataset if item['text'] and item['text'].strip()]
+print(f"Loaded {len(all_harvard_sentences)} sentences from dataset")
+
+# Initialize initial_sentences as empty - will be populated with unconsumed sentences only
+initial_sentences = []
+
+@app.route("/")
+def arena():
+    # Pass a subset of sentences for the random button fallback
+    return render_template("arena.html", harvard_sentences=json.dumps(initial_sentences))
+
+
+@app.route("/leaderboard")
+def leaderboard():
+    tts_leaderboard = get_leaderboard_data(ModelType.TTS)
+    conversational_leaderboard = get_leaderboard_data(ModelType.CONVERSATIONAL)
+    top_voters = get_top_voters(10)  # Get top 10 voters
+
+    # Initialize personal leaderboard data
+    tts_personal_leaderboard = None
+    conversational_personal_leaderboard = None
+    user_leaderboard_visibility = None
+
+    # If user is logged in, get their personal leaderboard and visibility setting
+    if current_user.is_authenticated:
+        tts_personal_leaderboard = get_user_leaderboard(current_user.id, ModelType.TTS)
+        conversational_personal_leaderboard = get_user_leaderboard(
+            current_user.id, ModelType.CONVERSATIONAL
+        )
+        user_leaderboard_visibility = current_user.show_in_leaderboard
+
+    # Get key dates for the timeline
+    tts_key_dates = get_key_historical_dates(ModelType.TTS)
+    conversational_key_dates = get_key_historical_dates(ModelType.CONVERSATIONAL)
+
+    # Format dates for display in the dropdown
+    formatted_tts_dates = [date.strftime("%B %Y") for date in tts_key_dates]
+    formatted_conversational_dates = [
+        date.strftime("%B %Y") for date in conversational_key_dates
+    ]
+
+    return render_template(
+        "leaderboard.html",
+        tts_leaderboard=tts_leaderboard,
+        conversational_leaderboard=conversational_leaderboard,
+        tts_personal_leaderboard=tts_personal_leaderboard,
+        conversational_personal_leaderboard=conversational_personal_leaderboard,
+        tts_key_dates=tts_key_dates,
+        conversational_key_dates=conversational_key_dates,
+        formatted_tts_dates=formatted_tts_dates,
+        formatted_conversational_dates=formatted_conversational_dates,
+        top_voters=top_voters,
+        user_leaderboard_visibility=user_leaderboard_visibility
+    )
+
+
+@app.route("/api/historical-leaderboard/<model_type>")
+def historical_leaderboard(model_type):
+    """Get historical leaderboard data for a specific date"""
+    if model_type not in [ModelType.TTS, ModelType.CONVERSATIONAL]:
+        return jsonify({"error": "Invalid model type"}), 400
+
+    # Get date from query parameter
+    date_str = request.args.get("date")
+    if not date_str:
+        return jsonify({"error": "Date parameter is required"}), 400
+
+    try:
+        # Parse date from URL parameter (format: YYYY-MM-DD)
+        target_date = datetime.strptime(date_str, "%Y-%m-%d")
+
+        # Get historical leaderboard data
+        leaderboard_data = get_historical_leaderboard_data(model_type, target_date)
+
+        return jsonify(
+            {"date": target_date.strftime("%B %d, %Y"), "leaderboard": leaderboard_data}
+        )
+    except ValueError:
+        return jsonify({"error": "Invalid date format. Use YYYY-MM-DD"}), 400
+
+
+@app.route("/about")
+def about():
+    return render_template("about.html")
+
+
+# --- TTS Caching Functions ---
+
+def generate_and_save_tts(text, model_id, output_dir):
+    """Generates TTS and saves it to a specific directory, returning the full path."""
+    temp_audio_path = None # Initialize to None
+    try:
+        app.logger.debug(f"[TTS Gen {model_id}] Starting generation for: '{text[:30]}...'")
+        # If predict_tts saves file itself and returns path:
+        temp_audio_path = predict_tts(text, model_id)
+        app.logger.debug(f"[TTS Gen {model_id}] predict_tts returned: {temp_audio_path}")
+
+        if not temp_audio_path or not os.path.exists(temp_audio_path):
+            app.logger.warning(f"[TTS Gen {model_id}] predict_tts failed or returned invalid path: {temp_audio_path}")
+            raise ValueError("predict_tts did not return a valid path or file does not exist")
+
+        file_uuid = str(uuid.uuid4())
+        dest_path = os.path.join(output_dir, f"{file_uuid}.wav")
+        app.logger.debug(f"[TTS Gen {model_id}] Moving {temp_audio_path} to {dest_path}")
+        # Move the file generated by predict_tts to the target cache directory
+        shutil.move(temp_audio_path, dest_path)
+        app.logger.debug(f"[TTS Gen {model_id}] Move successful. Returning {dest_path}")
+        return dest_path
+
+    except Exception as e:
+        app.logger.error(f"Error generating/saving TTS for model {model_id} and text '{text[:30]}...': {str(e)}")
+        # Ensure temporary file from predict_tts (if any) is cleaned up
+        if temp_audio_path and os.path.exists(temp_audio_path):
+            try:
+                app.logger.debug(f"[TTS Gen {model_id}] Cleaning up temporary file {temp_audio_path} after error.")
+                os.remove(temp_audio_path)
+            except OSError:
+                pass # Ignore error if file couldn't be removed
+        return None
+
+
+def _generate_cache_entry_task(sentence):
+    """Task function to generate audio for a sentence and add to cache."""
+    # Wrap the entire task in an application context
+    with app.app_context():
+        if not sentence:
+            # Select a new sentence if not provided (for replacement)
+            with tts_cache_lock:
+                cached_keys = set(tts_cache.keys())
+            # Get unconsumed sentences that are also not already cached
+            unconsumed_sentences = get_unconsumed_sentences(all_harvard_sentences)
+            available_sentences = [s for s in unconsumed_sentences if s not in cached_keys]
+            if not available_sentences:
+                app.logger.warning("No more unconsumed sentences available for caching. All sentences have been consumed.")
+                return
+            sentence = random.choice(available_sentences)
+
+        # app.logger.info removed duplicate log
+        print(f"[Cache Task] Querying models for: '{sentence[:50]}...'")
+        available_models = Model.query.filter_by(
+            model_type=ModelType.TTS, is_active=True
+        ).all()
+
+        if len(available_models) < 2:
+            app.logger.error("Not enough active TTS models to generate cache entry.")
+            return
+
+        try:
+            models = get_weighted_random_models(available_models, 2, ModelType.TTS)
+            model_a_id = models[0].id
+            model_b_id = models[1].id
+
+            # Generate audio concurrently using a local executor for clarity within the task
+            with ThreadPoolExecutor(max_workers=2, thread_name_prefix='AudioGen') as audio_executor:
+                future_a = audio_executor.submit(generate_and_save_tts, sentence, model_a_id, CACHE_AUDIO_DIR)
+                future_b = audio_executor.submit(generate_and_save_tts, sentence, model_b_id, CACHE_AUDIO_DIR)
+
+                timeout_seconds = 120
+                audio_a_path = future_a.result(timeout=timeout_seconds)
+                audio_b_path = future_b.result(timeout=timeout_seconds)
+
+            if audio_a_path and audio_b_path:
+                with tts_cache_lock:
+                    # Only add if the sentence isn't already back in the cache
+                    # And ensure cache size doesn't exceed limit
+                    if sentence not in tts_cache and len(tts_cache) < TTS_CACHE_SIZE:
+                        tts_cache[sentence] = {
+                            "model_a": model_a_id,
+                            "model_b": model_b_id,
+                            "audio_a": audio_a_path,
+                            "audio_b": audio_b_path,
+                            "created_at": datetime.utcnow(),
+                        }
+                        # Mark sentence as consumed for cache usage
+                        mark_sentence_consumed(sentence, usage_type='cache')
+                        app.logger.info(f"Successfully cached entry for: '{sentence[:50]}...'")
+                    elif sentence in tts_cache:
+                         app.logger.warning(f"Sentence '{sentence[:50]}...' already re-cached. Discarding new generation.")
+                         # Clean up the newly generated files if not added
+                         if os.path.exists(audio_a_path): os.remove(audio_a_path)
+                         if os.path.exists(audio_b_path): os.remove(audio_b_path)
+                    else: # Cache is full
+                        app.logger.warning(f"Cache is full ({len(tts_cache)} entries). Discarding new generation for '{sentence[:50]}...'.")
+                        # Clean up the newly generated files if not added
+                        if os.path.exists(audio_a_path): os.remove(audio_a_path)
+                        if os.path.exists(audio_b_path): os.remove(audio_b_path)
+
+            else:
+                app.logger.error(f"Failed to generate one or both audio files for cache: '{sentence[:50]}...'")
+                # Clean up whichever file might have been created
+                if audio_a_path and os.path.exists(audio_a_path): os.remove(audio_a_path)
+                if audio_b_path and os.path.exists(audio_b_path): os.remove(audio_b_path)
+
+        except Exception as e:
+            # Log the exception within the app context
+            app.logger.error(f"Exception in _generate_cache_entry_task for '{sentence[:50]}...': {str(e)}", exc_info=True)
+
+
+def update_initial_sentences():
+    """Update initial sentences to only include unconsumed ones."""
+    global initial_sentences
+    try:
+        unconsumed_for_initial = get_unconsumed_sentences(all_harvard_sentences)
+        if unconsumed_for_initial:
+            initial_sentences = random.sample(unconsumed_for_initial, min(len(unconsumed_for_initial), 500))
+            print(f"Updated initial sentences with {len(initial_sentences)} unconsumed sentences")
+        else:
+            print("Warning: No unconsumed sentences available for initial selection, disabling fallback")
+            initial_sentences = []  # No fallback to consumed sentences
+    except Exception as e:
+        print(f"Error updating initial sentences: {e}, disabling fallback for security")
+        initial_sentences = []  # No fallback to consumed sentences
+
+
+def initialize_tts_cache():
+    print("Initializing TTS cache")
+    """Selects initial sentences and starts generation tasks."""
+    with app.app_context(): # Ensure access to models
+        if not all_harvard_sentences:
+            app.logger.error("Harvard sentences not loaded. Cannot initialize cache.")
+            return
+
+        # Update initial sentences with unconsumed ones
+        update_initial_sentences()
+
+        # Only use unconsumed sentences for initial cache population
+        unconsumed_sentences = get_unconsumed_sentences(all_harvard_sentences)
+        if not unconsumed_sentences:
+            app.logger.error("No unconsumed sentences available for cache initialization. Cache will remain empty.")
+            app.logger.warning("WARNING: All sentences from the dataset have been consumed. No new TTS generations will be possible.")
+            return
+        initial_selection = random.sample(unconsumed_sentences, min(len(unconsumed_sentences), TTS_CACHE_SIZE))
+        app.logger.info(f"Initializing TTS cache with {len(initial_selection)} sentences...")
+
+        for sentence in initial_selection:
+            # Use the main cache_executor for initial population too
+            cache_executor.submit(_generate_cache_entry_task, sentence)
+        app.logger.info("Submitted initial cache generation tasks.")
+
+# --- End TTS Caching Functions ---
+
+
+@app.route("/api/tts/generate", methods=["POST"])
+@limiter.limit("10 per minute") # Keep limit, cached responses are still requests
+def generate_tts():
+    # If verification not setup, handle it first
+    if app.config["TURNSTILE_ENABLED"] and not session.get("turnstile_verified"):
+        return jsonify({"error": "Turnstile verification required"}), 403
+
+    # Require user to be logged in to generate audio
+    if not current_user.is_authenticated:
+        return jsonify({"error": "You must be logged in to generate audio"}), 401
+
+    data = request.json
+    text = data.get("text", "").strip() # Ensure text is stripped
+
+    if not text or len(text) > 1000:
+        return jsonify({"error": "Invalid or too long text"}), 400
+    
+    # Check if text is in English
+    if not is_english_text(text):
+        return jsonify({"error": "Only English language text is supported for now. Please provide text in English. A multilingual Arena is coming soon!"}), 400
+    
+    # Check if sentence has already been consumed
+    if is_sentence_consumed(text):
+        remaining_count = len(get_unconsumed_sentences(all_harvard_sentences))
+        if remaining_count == 0:
+            return jsonify({"error": "This sentence has already been used and no unconsumed sentences remain. All sentences from the dataset have been consumed."}), 400
+        else:
+            return jsonify({"error": f"This sentence has already been used. Please select a different sentence. {remaining_count} sentences remain available."}), 400
+
+    # --- Cache Check ---
+    cache_hit = False
+    session_data_from_cache = None
+    with tts_cache_lock:
+        if text in tts_cache:
+            cache_hit = True
+            cached_entry = tts_cache.pop(text) # Remove from cache immediately
+            app.logger.info(f"TTS Cache HIT for: '{text[:50]}...'")
+
+            # Prepare session data using cached info
+            session_id = str(uuid.uuid4())
+            session_data_from_cache = {
+                "model_a": cached_entry["model_a"],
+                "model_b": cached_entry["model_b"],
+                "audio_a": cached_entry["audio_a"], # Paths are now from cache_dir
+                "audio_b": cached_entry["audio_b"],
+                "text": text,
+                "created_at": datetime.utcnow(),
+                "expires_at": datetime.utcnow() + timedelta(minutes=30),
+                "voted": False,
+                "cache_hit": True,
+            }
+            app.tts_sessions[session_id] = session_data_from_cache
+            
+            # Note: Sentence was already marked as consumed when it was cached
+            # No need to mark it again here
+
+            # --- Trigger background tasks to refill the cache ---
+            # Calculate how many slots need refilling
+            current_cache_size = len(tts_cache) # Size *before* adding potentially new items
+            needed_refills = TTS_CACHE_SIZE - current_cache_size
+            # Limit concurrent refills to 8 or the actual need
+            refills_to_submit = min(needed_refills, 8)
+
+            if refills_to_submit > 0:
+                app.logger.info(f"Cache hit: Submitting {refills_to_submit} background task(s) to refill cache (current size: {current_cache_size}, target: {TTS_CACHE_SIZE}).")
+                for _ in range(refills_to_submit):
+                     # Pass None to signal replacement selection within the task
+                    cache_executor.submit(_generate_cache_entry_task, None)
+            else:
+                app.logger.info(f"Cache hit: Cache is already full or at target size ({current_cache_size}/{TTS_CACHE_SIZE}). No refill tasks submitted.")
+            # --- End Refill Trigger ---
+
+    if cache_hit and session_data_from_cache:
+        # Return response using cached data
+        # Note: The files are now managed by the session lifecycle (cleanup_session)
+        return jsonify(
+            {
+                "session_id": session_id,
+                "audio_a": f"/api/tts/audio/{session_id}/a",
+                "audio_b": f"/api/tts/audio/{session_id}/b",
+                "expires_in": 1800,  # 30 minutes in seconds
+                "cache_hit": True,
+            }
+        )
+    # --- End Cache Check ---
+
+    # --- Cache Miss: Generate on the fly ---
+    app.logger.info(f"TTS Cache MISS for: '{text[:50]}...'. Generating on the fly.")
+    available_models = Model.query.filter_by(
+        model_type=ModelType.TTS, is_active=True
+    ).all()
+    if len(available_models) < 2:
+        return jsonify({"error": "Not enough TTS models available"}), 500
+
+    selected_models = get_weighted_random_models(available_models, 2, ModelType.TTS)
+
+    try:
+        audio_files = []
+        model_ids = []
+
+        # Function to process a single model (generate directly to TEMP_AUDIO_DIR, not cache subdir)
+        def process_model_on_the_fly(model):
+             # Generate and save directly to the main temp dir
+             # Assume predict_tts handles saving temporary files
+             temp_audio_path = predict_tts(text, model.id)
+             if not temp_audio_path or not os.path.exists(temp_audio_path):
+                 raise ValueError(f"predict_tts failed for model {model.id}")
+
+             # Create a unique name in the main TEMP_AUDIO_DIR for the session
+             file_uuid = str(uuid.uuid4())
+             dest_path = os.path.join(TEMP_AUDIO_DIR, f"{file_uuid}.wav")
+             shutil.move(temp_audio_path, dest_path) # Move from predict_tts's temp location
+
+             return {"model_id": model.id, "audio_path": dest_path}
+
+
+        # Use ThreadPoolExecutor to process models concurrently
+        with ThreadPoolExecutor(max_workers=2) as executor:
+            results = list(executor.map(process_model_on_the_fly, selected_models))
+
+        # Extract results
+        for result in results:
+            model_ids.append(result["model_id"])
+            audio_files.append(result["audio_path"])
+
+        # Create session
+        session_id = str(uuid.uuid4())
+        app.tts_sessions[session_id] = {
+            "model_a": model_ids[0],
+            "model_b": model_ids[1],
+            "audio_a": audio_files[0], # Paths are now from TEMP_AUDIO_DIR directly
+            "audio_b": audio_files[1],
+            "text": text,
+            "created_at": datetime.utcnow(),
+            "expires_at": datetime.utcnow() + timedelta(minutes=30),
+            "voted": False,
+            "cache_hit": False,
+        }
+        
+        # Don't mark as consumed yet - wait until vote is submitted to maintain security
+        # while allowing legitimate votes to count for ELO
+
+        # Return audio file paths and session
+        return jsonify(
+            {
+                "session_id": session_id,
+                "audio_a": f"/api/tts/audio/{session_id}/a",
+                "audio_b": f"/api/tts/audio/{session_id}/b",
+                "expires_in": 1800,
+                "cache_hit": False,
+            }
+        )
+
+    except Exception as e:
+        app.logger.error(f"TTS on-the-fly generation error: {str(e)}", exc_info=True)
+        # Cleanup any files potentially created during the failed attempt
+        if 'results' in locals():
+             for res in results:
+                 if 'audio_path' in res and os.path.exists(res['audio_path']):
+                     try:
+                         os.remove(res['audio_path'])
+                     except OSError:
+                         pass
+        return jsonify({"error": "Failed to generate TTS"}), 500
+    # --- End Cache Miss ---
+
+
+@app.route("/api/tts/audio/<session_id>/<model_key>")
+def get_audio(session_id, model_key):
+    # If verification not setup, handle it first
+    if app.config["TURNSTILE_ENABLED"] and not session.get("turnstile_verified"):
+        return jsonify({"error": "Turnstile verification required"}), 403
+
+    if session_id not in app.tts_sessions:
+        return jsonify({"error": "Invalid or expired session"}), 404
+
+    session_data = app.tts_sessions[session_id]
+
+    # Check if session expired
+    if datetime.utcnow() > session_data["expires_at"]:
+        cleanup_session(session_id)
+        return jsonify({"error": "Session expired"}), 410
+
+    if model_key == "a":
+        audio_path = session_data["audio_a"]
+    elif model_key == "b":
+        audio_path = session_data["audio_b"]
+    else:
+        return jsonify({"error": "Invalid model key"}), 400
+
+    # Check if file exists
+    if not os.path.exists(audio_path):
+        return jsonify({"error": "Audio file not found"}), 404
+
+    return send_file(audio_path, mimetype="audio/wav")
+
+
+@app.route("/api/tts/vote", methods=["POST"])
+@limiter.limit("30 per minute")
+def submit_vote():
+    # If verification not setup, handle it first
+    if app.config["TURNSTILE_ENABLED"] and not session.get("turnstile_verified"):
+        return jsonify({"error": "Turnstile verification required"}), 403
+
+    # Require user to be logged in to vote
+    if not current_user.is_authenticated:
+        return jsonify({"error": "You must be logged in to vote"}), 401
+
+    # Security checks for vote manipulation prevention
+    client_ip = get_client_ip()
+    vote_allowed, security_reason, security_score = is_vote_allowed(current_user.id, client_ip)
+    
+    if not vote_allowed:
+        app.logger.warning(f"Vote blocked for user {current_user.username} (ID: {current_user.id}): {security_reason} (Score: {security_score})")
+        return jsonify({"error": f"Vote not allowed: {security_reason}"}), 403
+
+    data = request.json
+    session_id = data.get("session_id")
+    chosen_model_key = data.get("chosen_model")  # "a" or "b"
+
+    if not session_id or session_id not in app.tts_sessions:
+        return jsonify({"error": "Invalid or expired session"}), 404
+
+    if not chosen_model_key or chosen_model_key not in ["a", "b"]:
+        return jsonify({"error": "Invalid chosen model"}), 400
+
+    session_data = app.tts_sessions[session_id]
+
+    # Check if session expired
+    if datetime.utcnow() > session_data["expires_at"]:
+        cleanup_session(session_id)
+        return jsonify({"error": "Session expired"}), 410
+
+    # Check if already voted
+    if session_data["voted"]:
+        return jsonify({"error": "Vote already submitted for this session"}), 400
+
+    # Get model IDs and audio paths
+    chosen_id = (
+        session_data["model_a"] if chosen_model_key == "a" else session_data["model_b"]
+    )
+    rejected_id = (
+        session_data["model_b"] if chosen_model_key == "a" else session_data["model_a"]
+    )
+    chosen_audio_path = (
+        session_data["audio_a"] if chosen_model_key == "a" else session_data["audio_b"]
+    )
+    rejected_audio_path = (
+        session_data["audio_b"] if chosen_model_key == "a" else session_data["audio_a"]
+    )
+
+    # Calculate session duration and gather analytics data
+    vote_time = datetime.utcnow()
+    session_duration = (vote_time - session_data["created_at"]).total_seconds()
+    client_ip = get_client_ip()
+    user_agent = request.headers.get('User-Agent')
+    cache_hit = session_data.get("cache_hit", False)
+
+    # Record vote in database with analytics data
+    vote, error = record_vote(
+        current_user.id, 
+        session_data["text"], 
+        chosen_id, 
+        rejected_id, 
+        ModelType.TTS,
+        session_duration=session_duration,
+        ip_address=client_ip,
+        user_agent=user_agent,
+        generation_date=session_data["created_at"],
+        cache_hit=cache_hit,
+        all_dataset_sentences=all_harvard_sentences
+    )
+
+    if error:
+        return jsonify({"error": error}), 500
+
+    # Sentence consumption is now handled within record_vote function
+
+    # --- Save preference data ---
+    try:
+        vote_uuid = str(uuid.uuid4())
+        vote_dir = os.path.join("./votes", vote_uuid)
+        os.makedirs(vote_dir, exist_ok=True)
+
+        # Copy audio files
+        shutil.copy(chosen_audio_path, os.path.join(vote_dir, "chosen.wav"))
+        shutil.copy(rejected_audio_path, os.path.join(vote_dir, "rejected.wav"))
+
+        # Create metadata
+        chosen_model_obj = Model.query.get(chosen_id)
+        rejected_model_obj = Model.query.get(rejected_id)
+        metadata = {
+            "text": session_data["text"],
+            "chosen_model": chosen_model_obj.name if chosen_model_obj else "Unknown",
+            "chosen_model_id": chosen_model_obj.id if chosen_model_obj else "Unknown",
+            "rejected_model": rejected_model_obj.name if rejected_model_obj else "Unknown",
+            "rejected_model_id": rejected_model_obj.id if rejected_model_obj else "Unknown",
+            "session_id": session_id,
+            "timestamp": datetime.utcnow().isoformat(),
+            "username": current_user.username,
+            "model_type": "TTS"
+        }
+        with open(os.path.join(vote_dir, "metadata.json"), "w") as f:
+            json.dump(metadata, f, indent=2)
+
+    except Exception as e:
+        app.logger.error(f"Error saving preference data for vote {session_id}: {str(e)}")
+        # Continue even if saving preference data fails, vote is already recorded
+
+    # Mark session as voted
+    session_data["voted"] = True
+
+    # Check for coordinated voting campaigns (async to not slow down response)
+    try:
+        from threading import Thread
+        campaign_check_thread = Thread(target=check_for_coordinated_campaigns)
+        campaign_check_thread.daemon = True
+        campaign_check_thread.start()
+    except Exception as e:
+        app.logger.error(f"Error starting coordinated campaign check thread: {str(e)}")
+
+    # Return updated models (use previously fetched objects)
+    return jsonify(
+        {
+            "success": True,
+            "chosen_model": {"id": chosen_id, "name": chosen_model_obj.name if chosen_model_obj else "Unknown"},
+            "rejected_model": {
+                "id": rejected_id,
+                "name": rejected_model_obj.name if rejected_model_obj else "Unknown",
+            },
+            "names": {
+                "a": (
+                    chosen_model_obj.name if chosen_model_key == "a" else rejected_model_obj.name
+                    if chosen_model_obj and rejected_model_obj else "Unknown"
+                ),
+                "b": (
+                    rejected_model_obj.name if chosen_model_key == "a" else chosen_model_obj.name
+                    if chosen_model_obj and rejected_model_obj else "Unknown"
+                ),
+            },
+        }
+    )
+
+
+def cleanup_session(session_id):
+    """Remove session and its audio files"""
+    if session_id in app.tts_sessions:
+        session = app.tts_sessions[session_id]
+
+        # Remove audio files
+        for audio_file in [session["audio_a"], session["audio_b"]]:
+            if os.path.exists(audio_file):
+                try:
+                    os.remove(audio_file)
+                except Exception as e:
+                    app.logger.error(f"Error removing audio file: {str(e)}")
+
+        # Remove session
+        del app.tts_sessions[session_id]
+
+
+@app.route("/api/conversational/generate", methods=["POST"])
+@limiter.limit("5 per minute")
+def generate_podcast():
+    # If verification not setup, handle it first
+    if app.config["TURNSTILE_ENABLED"] and not session.get("turnstile_verified"):
+        return jsonify({"error": "Turnstile verification required"}), 403
+
+    # Require user to be logged in to generate audio
+    if not current_user.is_authenticated:
+        return jsonify({"error": "You must be logged in to generate audio"}), 401
+
+    data = request.json
+    script = data.get("script")
+
+    if not script or not isinstance(script, list) or len(script) < 2:
+        return jsonify({"error": "Invalid script format or too short"}), 400
+
+    # Validate script format
+    for line in script:
+        if not isinstance(line, dict) or "text" not in line or "speaker_id" not in line:
+            return (
+                jsonify(
+                    {
+                        "error": "Invalid script line format. Each line must have text and speaker_id"
+                    }
+                ),
+                400,
+            )
+        if (
+            not line["text"]
+            or not isinstance(line["speaker_id"], int)
+            or line["speaker_id"] not in [0, 1]
+        ):
+            return (
+                jsonify({"error": "Invalid script content. Speaker ID must be 0 or 1"}),
+                400,
+            )
+
+    # Get two conversational models (currently only CSM and PlayDialog)
+    available_models = Model.query.filter_by(
+        model_type=ModelType.CONVERSATIONAL, is_active=True
+    ).all()
+
+    if len(available_models) < 2:
+        return jsonify({"error": "Not enough conversational models available"}), 500
+
+    selected_models = get_weighted_random_models(available_models, 2, ModelType.CONVERSATIONAL)
+
+    try:
+        # Generate audio for both models concurrently
+        audio_files = []
+        model_ids = []
+
+        # Function to process a single model
+        def process_model(model):
+            # Call conversational TTS service
+            audio_content = predict_tts(script, model.id)
+
+            # Save to temp file with unique name
+            file_uuid = str(uuid.uuid4())
+            dest_path = os.path.join(TEMP_AUDIO_DIR, f"{file_uuid}.wav")
+
+            with open(dest_path, "wb") as f:
+                f.write(audio_content)
+
+            return {"model_id": model.id, "audio_path": dest_path}
+
+        # Use ThreadPoolExecutor to process models concurrently
+        with ThreadPoolExecutor(max_workers=2) as executor:
+            results = list(executor.map(process_model, selected_models))
+
+        # Extract results
+        for result in results:
+            model_ids.append(result["model_id"])
+            audio_files.append(result["audio_path"])
+
+        # Create session
+        session_id = str(uuid.uuid4())
+        script_text = " ".join([line["text"] for line in script])
+        app.conversational_sessions[session_id] = {
+            "model_a": model_ids[0],
+            "model_b": model_ids[1],
+            "audio_a": audio_files[0],
+            "audio_b": audio_files[1],
+            "text": script_text[:1000],  # Limit text length
+            "created_at": datetime.utcnow(),
+            "expires_at": datetime.utcnow() + timedelta(minutes=30),
+            "voted": False,
+            "script": script,
+            "cache_hit": False,  # Conversational is always generated on-demand
+        }
+
+        # Return audio file paths and session
+        return jsonify(
+            {
+                "session_id": session_id,
+                "audio_a": f"/api/conversational/audio/{session_id}/a",
+                "audio_b": f"/api/conversational/audio/{session_id}/b",
+                "expires_in": 1800,  # 30 minutes in seconds
+            }
+        )
+
+    except Exception as e:
+        app.logger.error(f"Conversational generation error: {str(e)}")
+        return jsonify({"error": f"Failed to generate podcast: {str(e)}"}), 500
+
+
+@app.route("/api/conversational/audio/<session_id>/<model_key>")
+def get_podcast_audio(session_id, model_key):
+    # If verification not setup, handle it first
+    if app.config["TURNSTILE_ENABLED"] and not session.get("turnstile_verified"):
+        return jsonify({"error": "Turnstile verification required"}), 403
+
+    if session_id not in app.conversational_sessions:
+        return jsonify({"error": "Invalid or expired session"}), 404
+
+    session_data = app.conversational_sessions[session_id]
+
+    # Check if session expired
+    if datetime.utcnow() > session_data["expires_at"]:
+        cleanup_conversational_session(session_id)
+        return jsonify({"error": "Session expired"}), 410
+
+    if model_key == "a":
+        audio_path = session_data["audio_a"]
+    elif model_key == "b":
+        audio_path = session_data["audio_b"]
+    else:
+        return jsonify({"error": "Invalid model key"}), 400
+
+    # Check if file exists
+    if not os.path.exists(audio_path):
+        return jsonify({"error": "Audio file not found"}), 404
+
+    return send_file(audio_path, mimetype="audio/wav")
+
+
+@app.route("/api/conversational/vote", methods=["POST"])
+@limiter.limit("30 per minute")
+def submit_podcast_vote():
+    # If verification not setup, handle it first
+    if app.config["TURNSTILE_ENABLED"] and not session.get("turnstile_verified"):
+        return jsonify({"error": "Turnstile verification required"}), 403
+
+    # Require user to be logged in to vote
+    if not current_user.is_authenticated:
+        return jsonify({"error": "You must be logged in to vote"}), 401
+
+    # Security checks for vote manipulation prevention
+    client_ip = get_client_ip()
+    vote_allowed, security_reason, security_score = is_vote_allowed(current_user.id, client_ip)
+    
+    if not vote_allowed:
+        app.logger.warning(f"Conversational vote blocked for user {current_user.username} (ID: {current_user.id}): {security_reason} (Score: {security_score})")
+        return jsonify({"error": f"Vote not allowed: {security_reason}"}), 403
+
+    data = request.json
+    session_id = data.get("session_id")
+    chosen_model_key = data.get("chosen_model")  # "a" or "b"
+
+    if not session_id or session_id not in app.conversational_sessions:
+        return jsonify({"error": "Invalid or expired session"}), 404
+
+    if not chosen_model_key or chosen_model_key not in ["a", "b"]:
+        return jsonify({"error": "Invalid chosen model"}), 400
+
+    session_data = app.conversational_sessions[session_id]
+
+    # Check if session expired
+    if datetime.utcnow() > session_data["expires_at"]:
+        cleanup_conversational_session(session_id)
+        return jsonify({"error": "Session expired"}), 410
+
+    # Check if already voted
+    if session_data["voted"]:
+        return jsonify({"error": "Vote already submitted for this session"}), 400
+
+    # Get model IDs and audio paths
+    chosen_id = (
+        session_data["model_a"] if chosen_model_key == "a" else session_data["model_b"]
+    )
+    rejected_id = (
+        session_data["model_b"] if chosen_model_key == "a" else session_data["model_a"]
+    )
+    chosen_audio_path = (
+        session_data["audio_a"] if chosen_model_key == "a" else session_data["audio_b"]
+    )
+    rejected_audio_path = (
+        session_data["audio_b"] if chosen_model_key == "a" else session_data["audio_a"]
+    )
+
+    # Calculate session duration and gather analytics data
+    vote_time = datetime.utcnow()
+    session_duration = (vote_time - session_data["created_at"]).total_seconds()
+    client_ip = get_client_ip()
+    user_agent = request.headers.get('User-Agent')
+    cache_hit = session_data.get("cache_hit", False)
+
+    # Record vote in database with analytics data
+    vote, error = record_vote(
+        current_user.id, 
+        session_data["text"], 
+        chosen_id, 
+        rejected_id, 
+        ModelType.CONVERSATIONAL,
+        session_duration=session_duration,
+        ip_address=client_ip,
+        user_agent=user_agent,
+        generation_date=session_data["created_at"],
+        cache_hit=cache_hit,
+        all_dataset_sentences=all_harvard_sentences  # Note: conversational uses scripts, not sentences
+    )
+
+    if error:
+        return jsonify({"error": error}), 500
+
+    # Sentence consumption is now handled within record_vote function
+
+    # --- Save preference data ---\
+    try:
+        vote_uuid = str(uuid.uuid4())
+        vote_dir = os.path.join("./votes", vote_uuid)
+        os.makedirs(vote_dir, exist_ok=True)
+
+        # Copy audio files
+        shutil.copy(chosen_audio_path, os.path.join(vote_dir, "chosen.wav"))
+        shutil.copy(rejected_audio_path, os.path.join(vote_dir, "rejected.wav"))
+
+        # Create metadata
+        chosen_model_obj = Model.query.get(chosen_id)
+        rejected_model_obj = Model.query.get(rejected_id)
+        metadata = {
+            "script": session_data["script"], # Save the full script
+            "chosen_model": chosen_model_obj.name if chosen_model_obj else "Unknown",
+            "chosen_model_id": chosen_model_obj.id if chosen_model_obj else "Unknown",
+            "rejected_model": rejected_model_obj.name if rejected_model_obj else "Unknown",
+            "rejected_model_id": rejected_model_obj.id if rejected_model_obj else "Unknown",
+            "session_id": session_id,
+            "timestamp": datetime.utcnow().isoformat(),
+            "username": current_user.username,
+            "model_type": "CONVERSATIONAL"
+        }
+        with open(os.path.join(vote_dir, "metadata.json"), "w") as f:
+            json.dump(metadata, f, indent=2)
+
+    except Exception as e:
+        app.logger.error(f"Error saving preference data for conversational vote {session_id}: {str(e)}")
+        # Continue even if saving preference data fails, vote is already recorded
+
+    # Mark session as voted
+    session_data["voted"] = True
+
+    # Check for coordinated voting campaigns (async to not slow down response)
+    try:
+        from threading import Thread
+        campaign_check_thread = Thread(target=check_for_coordinated_campaigns)
+        campaign_check_thread.daemon = True
+        campaign_check_thread.start()
+    except Exception as e:
+        app.logger.error(f"Error starting coordinated campaign check thread: {str(e)}")
+
+    # Return updated models (use previously fetched objects)
+    return jsonify(
+        {
+            "success": True,
+            "chosen_model": {"id": chosen_id, "name": chosen_model_obj.name if chosen_model_obj else "Unknown"},
+            "rejected_model": {
+                "id": rejected_id,
+                "name": rejected_model_obj.name if rejected_model_obj else "Unknown",
+            },
+            "names": {
+                "a": Model.query.get(session_data["model_a"]).name,
+                "b": Model.query.get(session_data["model_b"]).name,
+            },
+        }
+    )
+
+
+def cleanup_conversational_session(session_id):
+    """Remove conversational session and its audio files"""
+    if session_id in app.conversational_sessions:
+        session = app.conversational_sessions[session_id]
+
+        # Remove audio files
+        for audio_file in [session["audio_a"], session["audio_b"]]:
+            if os.path.exists(audio_file):
+                try:
+                    os.remove(audio_file)
+                except Exception as e:
+                    app.logger.error(
+                        f"Error removing conversational audio file: {str(e)}"
+                    )
+
+        # Remove session
+        del app.conversational_sessions[session_id]
+
+
+# Schedule periodic cleanup
+def setup_cleanup():
+    def cleanup_expired_sessions():
+        with app.app_context(): # Ensure app context for logging
+            current_time = datetime.utcnow()
+            # Cleanup TTS sessions
+            expired_tts_sessions = [
+                sid
+                for sid, session_data in app.tts_sessions.items()
+                if current_time > session_data["expires_at"]
+            ]
+            for sid in expired_tts_sessions:
+                cleanup_session(sid)
+
+            # Cleanup conversational sessions
+            expired_conv_sessions = [
+                sid
+                for sid, session_data in app.conversational_sessions.items()
+                if current_time > session_data["expires_at"]
+            ]
+            for sid in expired_conv_sessions:
+                cleanup_conversational_session(sid)
+            app.logger.info(f"Cleaned up {len(expired_tts_sessions)} TTS and {len(expired_conv_sessions)} conversational sessions.")
+
+    # Also cleanup potentially expired cache entries (e.g., > 1 hour old)
+    # This prevents stale cache entries if generation is slow or failing
+    # cleanup_stale_cache_entries()
+
+    # Run cleanup every 15 minutes
+    scheduler = BackgroundScheduler(daemon=True) # Run scheduler as daemon thread
+    scheduler.add_job(cleanup_expired_sessions, "interval", minutes=15)
+    scheduler.start()
+    print("Cleanup scheduler started") # Use print for startup messages
+
+
+# Schedule periodic tasks (database sync and preference upload)
+def setup_periodic_tasks():
+    """Setup periodic database synchronization and preference data upload for Spaces"""
+    if not IS_SPACES:
+        return
+
+    db_path = app.config["SQLALCHEMY_DATABASE_URI"].replace("sqlite:///", "instance/") # Get relative path
+    preferences_repo_id = "TTS-AGI/arena-v2-preferences"
+    database_repo_id = "TTS-AGI/database-arena-v2"
+    votes_dir = "./votes"
+
+    def sync_database():
+        """Uploads the database to HF dataset"""
+        with app.app_context(): # Ensure app context for logging
+            try:
+                if not os.path.exists(db_path):
+                    app.logger.warning(f"Database file not found at {db_path}, skipping sync.")
+                    return
+
+                api = HfApi(token=os.getenv("HF_TOKEN"))
+                api.upload_file(
+                    path_or_fileobj=db_path,
+                    path_in_repo="tts_arena.db",
+                    repo_id=database_repo_id,
+                    repo_type="dataset",
+                )
+                app.logger.info(f"Database uploaded to {database_repo_id} at {datetime.utcnow()}")
+            except Exception as e:
+                app.logger.error(f"Error uploading database to {database_repo_id}: {str(e)}")
+
+    def sync_preferences_data():
+        """Zips and uploads preference data folders in batches to HF dataset"""
+        with app.app_context(): # Ensure app context for logging
+            if not os.path.isdir(votes_dir):
+                return # Don't log every 5 mins if dir doesn't exist yet
+
+            temp_batch_dir = None # Initialize to manage cleanup
+            temp_individual_zip_dir = None # Initialize for individual zips
+            local_batch_zip_path = None # Initialize for batch zip path
+
+            try:
+                api = HfApi(token=os.getenv("HF_TOKEN"))
+                vote_uuids = [d for d in os.listdir(votes_dir) if os.path.isdir(os.path.join(votes_dir, d))]
+
+                if not vote_uuids:
+                    return # No data to process
+
+                app.logger.info(f"Found {len(vote_uuids)} vote directories to process.")
+
+                # Create temporary directories
+                temp_batch_dir = tempfile.mkdtemp(prefix="hf_batch_")
+                temp_individual_zip_dir = tempfile.mkdtemp(prefix="hf_indiv_zips_")
+                app.logger.debug(f"Created temp directories: {temp_batch_dir}, {temp_individual_zip_dir}")
+
+                processed_vote_dirs = []
+                individual_zips_in_batch = []
+
+                # 1. Create individual zips and move them to the batch directory
+                for vote_uuid in vote_uuids:
+                    dir_path = os.path.join(votes_dir, vote_uuid)
+                    individual_zip_base_path = os.path.join(temp_individual_zip_dir, vote_uuid)
+                    individual_zip_path = f"{individual_zip_base_path}.zip"
+
+                    try:
+                        shutil.make_archive(individual_zip_base_path, 'zip', dir_path)
+                        app.logger.debug(f"Created individual zip: {individual_zip_path}")
+
+                        # Move the created zip into the batch directory
+                        final_individual_zip_path = os.path.join(temp_batch_dir, f"{vote_uuid}.zip")
+                        shutil.move(individual_zip_path, final_individual_zip_path)
+                        app.logger.debug(f"Moved individual zip to batch dir: {final_individual_zip_path}")
+
+                        processed_vote_dirs.append(dir_path) # Mark original dir for later cleanup
+                        individual_zips_in_batch.append(final_individual_zip_path)
+
+                    except Exception as zip_err:
+                        app.logger.error(f"Error creating or moving zip for {vote_uuid}: {str(zip_err)}")
+                        # Clean up partial zip if it exists
+                        if os.path.exists(individual_zip_path):
+                            try:
+                                os.remove(individual_zip_path)
+                            except OSError:
+                                pass
+                        # Continue processing other votes
+
+                # Clean up the temporary dir used for creating individual zips
+                shutil.rmtree(temp_individual_zip_dir)
+                temp_individual_zip_dir = None # Mark as cleaned
+                app.logger.debug("Cleaned up temporary individual zip directory.")
+
+                if not individual_zips_in_batch:
+                    app.logger.warning("No individual zips were successfully created for batching.")
+                    # Clean up batch dir if it's empty or only contains failed attempts
+                    if temp_batch_dir and os.path.exists(temp_batch_dir):
+                         shutil.rmtree(temp_batch_dir)
+                         temp_batch_dir = None
+                    return
+
+                # 2. Create the batch zip file
+                batch_timestamp = datetime.utcnow().strftime("%Y%m%d_%H%M%S")
+                batch_uuid_short = str(uuid.uuid4())[:8]
+                batch_zip_filename = f"{batch_timestamp}_batch_{batch_uuid_short}.zip"
+                # Create batch zip in a standard temp location first
+                local_batch_zip_base = os.path.join(tempfile.gettempdir(), batch_zip_filename.replace('.zip', ''))
+                local_batch_zip_path = f"{local_batch_zip_base}.zip"
+
+                app.logger.info(f"Creating batch zip: {local_batch_zip_path} with {len(individual_zips_in_batch)} individual zips.")
+                shutil.make_archive(local_batch_zip_base, 'zip', temp_batch_dir)
+                app.logger.info(f"Batch zip created successfully: {local_batch_zip_path}")
+
+                # 3. Upload the batch zip file
+                hf_repo_path = f"votes/{year}/{month}/{batch_zip_filename}"
+                app.logger.info(f"Uploading batch zip to HF Hub: {preferences_repo_id}/{hf_repo_path}")
+
+                api.upload_file(
+                    path_or_fileobj=local_batch_zip_path,
+                    path_in_repo=hf_repo_path,
+                    repo_id=preferences_repo_id,
+                    repo_type="dataset",
+                    commit_message=f"Add batch preference data {batch_zip_filename} ({len(individual_zips_in_batch)} votes)"
+                )
+                app.logger.info(f"Successfully uploaded batch {batch_zip_filename} to {preferences_repo_id}")
+
+                # 4. Cleanup after successful upload
+                app.logger.info("Cleaning up local files after successful upload.")
+                # Remove original vote directories that were successfully zipped and uploaded
+                for dir_path in processed_vote_dirs:
+                    try:
+                        shutil.rmtree(dir_path)
+                        app.logger.debug(f"Removed original vote directory: {dir_path}")
+                    except OSError as e:
+                        app.logger.error(f"Error removing processed vote directory {dir_path}: {str(e)}")
+
+                # Remove the temporary batch directory (containing the individual zips)
+                shutil.rmtree(temp_batch_dir)
+                temp_batch_dir = None
+                app.logger.debug("Removed temporary batch directory.")
+
+                # Remove the local batch zip file
+                os.remove(local_batch_zip_path)
+                local_batch_zip_path = None
+                app.logger.debug("Removed local batch zip file.")
+
+                app.logger.info(f"Finished preference data sync. Uploaded batch {batch_zip_filename}.")
+
+            except Exception as e:
+                app.logger.error(f"Error during preference data batch sync: {str(e)}", exc_info=True)
+                # If upload failed, the local batch zip might exist, clean it up.
+                if local_batch_zip_path and os.path.exists(local_batch_zip_path):
+                    try:
+                        os.remove(local_batch_zip_path)
+                        app.logger.debug("Cleaned up local batch zip after failed upload.")
+                    except OSError as clean_err:
+                        app.logger.error(f"Error cleaning up batch zip after failed upload: {clean_err}")
+                # Do NOT remove temp_batch_dir if it exists; its contents will be retried next time.
+                # Do NOT remove original vote directories if upload failed.
+
+            finally:
+                # Final cleanup for temporary directories in case of unexpected exits
+                if temp_individual_zip_dir and os.path.exists(temp_individual_zip_dir):
+                    try:
+                        shutil.rmtree(temp_individual_zip_dir)
+                    except Exception as final_clean_err:
+                        app.logger.error(f"Error in final cleanup (indiv zips): {final_clean_err}")
+                # Only clean up batch dir in finally block if it *wasn't* kept intentionally after upload failure
+                if temp_batch_dir and os.path.exists(temp_batch_dir):
+                     # Check if an upload attempt happened and failed
+                     upload_failed = 'e' in locals() and isinstance(e, Exception) # Crude check if exception occurred
+                     if not upload_failed: # If no upload error or upload succeeded, clean up
+                        try:
+                            shutil.rmtree(temp_batch_dir)
+                        except Exception as final_clean_err:
+                            app.logger.error(f"Error in final cleanup (batch dir): {final_clean_err}")
+                     else:
+                         app.logger.warning("Keeping temporary batch directory due to upload failure for next attempt.")
+
+
+    # Schedule periodic tasks
+    scheduler = BackgroundScheduler()
+    # Sync database less frequently if needed, e.g., every 15 minutes
+    scheduler.add_job(sync_database, "interval", minutes=15, id="sync_db_job")
+    # Sync preferences more frequently
+    scheduler.add_job(sync_preferences_data, "interval", minutes=5, id="sync_pref_job")
+    scheduler.start()
+    print("Periodic tasks scheduler started (DB sync and Preferences upload)") # Use print for startup
+
+
+@app.cli.command("init-db")
+def init_db():
+    """Initialize the database."""
+    with app.app_context():
+        db.create_all()
+        print("Database initialized!")
+
+
+@app.route("/api/toggle-leaderboard-visibility", methods=["POST"])
+def toggle_leaderboard_visibility():
+    """Toggle whether the current user appears in the top voters leaderboard"""
+    if not current_user.is_authenticated:
+        return jsonify({"error": "You must be logged in to change this setting"}), 401
+    
+    new_status = toggle_user_leaderboard_visibility(current_user.id)
+    if new_status is None:
+        return jsonify({"error": "User not found"}), 404
+        
+    return jsonify({
+        "success": True, 
+        "visible": new_status,
+        "message": "You are now visible in the voters leaderboard" if new_status else "You are now hidden from the voters leaderboard"
+    })
+
+
+@app.route("/api/tts/cached-sentences")
+def get_cached_sentences():
+    """Returns a list of unconsumed sentences available for random selection."""
+    # Get unconsumed sentences from the full pool (not just cached ones)
+    unconsumed_sentences = get_unconsumed_sentences(all_harvard_sentences)
+    
+    # Limit the response size to avoid overwhelming the frontend
+    max_sentences = 1000
+    if len(unconsumed_sentences) > max_sentences:
+        import random
+        unconsumed_sentences = random.sample(unconsumed_sentences, max_sentences)
+    
+    return jsonify(unconsumed_sentences)
+
+
+@app.route("/api/tts/sentence-stats")
+def get_sentence_stats():
+    """Returns statistics about sentence consumption."""
+    total_sentences = len(all_harvard_sentences)
+    consumed_count = get_consumed_sentences_count()
+    remaining_count = total_sentences - consumed_count
+    
+    return jsonify({
+        "total_sentences": total_sentences,
+        "consumed_sentences": consumed_count,
+        "remaining_sentences": remaining_count,
+        "consumption_percentage": round((consumed_count / total_sentences) * 100, 2) if total_sentences > 0 else 0
+    })
+
+
+@app.route("/api/tts/random-sentence")
+def get_random_sentence():
+    """Returns a random unconsumed sentence."""
+    random_sentence = get_random_unconsumed_sentence(all_harvard_sentences)
+    if random_sentence:
+        return jsonify({"sentence": random_sentence})
+    else:
+        total_sentences = len(all_harvard_sentences)
+        consumed_count = get_consumed_sentences_count()
+        return jsonify({
+            "error": "No unconsumed sentences available", 
+            "details": f"All {total_sentences} sentences have been consumed ({consumed_count} total consumed)"
+        }), 404
+
+
+def get_weighted_random_models(
+    applicable_models: list[Model], num_to_select: int, model_type: ModelType
+) -> list[Model]:
+    """
+    Selects a specified number of models randomly from a list of applicable_models,
+    weighting models with fewer votes higher. A smoothing factor is used to ensure
+    the preference is slight and to prevent models with zero votes from being
+    overwhelmingly favored. Models are selected without replacement.
+
+    Assumes len(applicable_models) >= num_to_select, which should be checked by the caller.
+    """
+    model_votes_counts = {}
+    for model in applicable_models:
+        votes = (
+            Vote.query.filter(Vote.model_type == model_type)
+            .filter(or_(Vote.model_chosen == model.id, Vote.model_rejected == model.id))
+            .count()
+        )
+        model_votes_counts[model.id] = votes
+
+    weights = [
+        1.0 / (model_votes_counts[model.id] + SMOOTHING_FACTOR_MODEL_SELECTION)
+        for model in applicable_models
+    ]
+
+    selected_models_list = []
+    # Create copies to modify during selection process
+    current_candidates = list(applicable_models)
+    current_weights = list(weights)
+
+    # Assumes num_to_select is positive and less than or equal to len(current_candidates)
+    # Callers should ensure this (e.g., len(available_models) >= 2).
+    for _ in range(num_to_select):
+        if not current_candidates: # Safety break
+            app.logger.warning("Not enough candidates left for weighted selection.")
+            break
+        
+        chosen_model = random.choices(current_candidates, weights=current_weights, k=1)[0]
+        selected_models_list.append(chosen_model)
+
+        try:
+            idx_to_remove = current_candidates.index(chosen_model)
+            current_candidates.pop(idx_to_remove)
+            current_weights.pop(idx_to_remove)
+        except ValueError:
+            # This should ideally not happen if chosen_model came from current_candidates.
+            app.logger.error(f"Error removing model {chosen_model.id} from weighted selection candidates.")
+            break # Avoid potential issues
+
+    return selected_models_list
+
+
+def check_for_coordinated_campaigns():
+    """Check all active models for potential coordinated voting campaigns"""
+    try:
+        from security import detect_coordinated_voting
+        from models import Model, ModelType
+        
+        # Check TTS models
+        tts_models = Model.query.filter_by(model_type=ModelType.TTS, is_active=True).all()
+        for model in tts_models:
+            try:
+                detect_coordinated_voting(model.id)
+            except Exception as e:
+                app.logger.error(f"Error checking coordinated voting for TTS model {model.id}: {str(e)}")
+        
+        # Check conversational models
+        conv_models = Model.query.filter_by(model_type=ModelType.CONVERSATIONAL, is_active=True).all()
+        for model in conv_models:
+            try:
+                detect_coordinated_voting(model.id)
+            except Exception as e:
+                app.logger.error(f"Error checking coordinated voting for conversational model {model.id}: {str(e)}")
+                
+    except Exception as e:
+        app.logger.error(f"Error in coordinated campaign check: {str(e)}")
+
+
+if __name__ == "__main__":
+    with app.app_context():
+        # Ensure ./instance and ./votes directories exist
+        os.makedirs("instance", exist_ok=True)
+        os.makedirs("./votes", exist_ok=True) # Create votes directory if it doesn't exist
+        os.makedirs(CACHE_AUDIO_DIR, exist_ok=True) # Ensure cache audio dir exists
+
+        # Clean up old cache audio files on startup
+        try:
+            app.logger.info(f"Clearing old cache audio files from {CACHE_AUDIO_DIR}")
+            for filename in os.listdir(CACHE_AUDIO_DIR):
+                file_path = os.path.join(CACHE_AUDIO_DIR, filename)
+                try:
+                    if os.path.isfile(file_path) or os.path.islink(file_path):
+                        os.unlink(file_path)
+                    elif os.path.isdir(file_path):
+                        shutil.rmtree(file_path)
+                except Exception as e:
+                    app.logger.error(f'Failed to delete {file_path}. Reason: {e}')
+        except Exception as e:
+             app.logger.error(f"Error clearing cache directory {CACHE_AUDIO_DIR}: {e}")
+
+
+        # Download database if it doesn't exist (only on initial space start)
+        if IS_SPACES and not os.path.exists(app.config["SQLALCHEMY_DATABASE_URI"].replace("sqlite:///", "")):
+             try:
+                print("Database not found, downloading from HF dataset...")
+                hf_hub_download(
+                    repo_id="TTS-AGI/database-arena-v2",
+                    filename="tts_arena.db",
+                    repo_type="dataset",
+                    local_dir="instance", # download to instance/
+                    token=os.getenv("HF_TOKEN"),
+                )
+                print("Database downloaded successfully ✅")
+             except Exception as e:
+                 print(f"Error downloading database from HF dataset: {str(e)} ⚠️")
+
+
+        db.create_all()  # Create tables if they don't exist
+        insert_initial_models()
+        # Setup background tasks
+        initialize_tts_cache() # Start populating the cache
+        setup_cleanup()
+        setup_periodic_tasks() # Renamed function call
+
+    # Configure Flask to recognize HTTPS when behind a reverse proxy
+    from werkzeug.middleware.proxy_fix import ProxyFix
+
+    # Apply ProxyFix middleware to handle reverse proxy headers
+    # This ensures Flask generates correct URLs with https scheme
+    # X-Forwarded-Proto header will be used to detect the original protocol
+    app.wsgi_app = ProxyFix(app.wsgi_app, x_proto=1, x_host=1)
+
+    # Force Flask to prefer HTTPS for generated URLs
+    app.config["PREFERRED_URL_SCHEME"] = "https"
+
+    from waitress import serve
+
+    # Configuration for 2 vCPUs:
+    # - threads: typically 4-8 threads per CPU core is a good balance
+    # - connection_limit: maximum concurrent connections
+    # - channel_timeout: prevent hanging connections
+    threads = 12  # 6 threads per vCPU is a good balance for mixed IO/CPU workloads
+
+    if IS_SPACES:
+        serve(
+            app,
+            host="0.0.0.0",
+            port=int(os.environ.get("PORT", 7860)),
+            threads=threads,
+            connection_limit=100,
+            channel_timeout=30,
+            url_scheme='https'
+        )
+    else:
+        print(f"Starting Waitress server with {threads} threads")
+        serve(
+            app,
+            host="0.0.0.0",
+            port=5000,
+            threads=threads,
+            connection_limit=100,
+            channel_timeout=30,
+            url_scheme='https' # Keep https for local dev if using proxy/tunnel
+        )

apps/docs/.gitignore

@@ -1,26 +0,0 @@
-# deps
-/node_modules
-
-# generated content
-.source
-
-# test & build
-/coverage
-/.next/
-/out/
-/build
-*.tsbuildinfo
-
-# misc
-.DS_Store
-*.pem
-/.pnp
-.pnp.js
-npm-debug.log*
-yarn-debug.log*
-yarn-error.log*
-
-# others
-.env*.local
-.vercel
-next-env.d.ts

apps/docs/app/[[...slug]]/page.tsx

@@ -1,67 +0,0 @@
-import { getPageImage, getPageMarkdownUrl, source } from "@/lib/source";
-import {
-  DocsBody,
-  DocsDescription,
-  DocsPage,
-  DocsTitle,
-  MarkdownCopyButton,
-  ViewOptionsPopover,
-} from "fumadocs-ui/layouts/docs/page";
-import { notFound } from "next/navigation";
-import { getMDXComponents } from "@/components/mdx";
-import type { Metadata } from "next";
-import { createRelativeLink } from "fumadocs-ui/mdx";
-import { gitConfig } from "@/lib/shared";
-
-export default async function Page(props: PageProps<"/[[...slug]]">) {
-  const params = await props.params;
-  const page = source.getPage(params.slug);
-  if (!page) notFound();
-
-  const MDX = page.data.body;
-  const markdownUrl = getPageMarkdownUrl(page).url;
-
-  return (
-    <DocsPage toc={page.data.toc} full={page.data.full}>
-      <DocsTitle>{page.data.title}</DocsTitle>
-      <DocsDescription className="mb-0">
-        {page.data.description}
-      </DocsDescription>
-      <div className="flex flex-row items-center gap-2 border-b pb-6">
-        <MarkdownCopyButton markdownUrl={markdownUrl} />
-        <ViewOptionsPopover
-          markdownUrl={markdownUrl}
-          githubUrl={`https://github.com/${gitConfig.user}/${gitConfig.repo}/blob/${gitConfig.branch}/content/docs/${page.path}`}
-        />
-      </div>
-      <DocsBody>
-        <MDX
-          components={getMDXComponents({
-            // this allows you to link to other pages with relative file paths
-            a: createRelativeLink(source, page),
-          })}
-        />
-      </DocsBody>
-    </DocsPage>
-  );
-}
-
-export async function generateStaticParams() {
-  return source.generateParams();
-}
-
-export async function generateMetadata(
-  props: PageProps<"/[[...slug]]">,
-): Promise<Metadata> {
-  const params = await props.params;
-  const page = source.getPage(params.slug);
-  if (!page) notFound();
-
-  return {
-    title: page.data.title,
-    description: page.data.description,
-    openGraph: {
-      images: getPageImage(page).url,
-    },
-  };
-}

apps/docs/app/api/search/route.ts

@@ -1,7 +0,0 @@
-import { source } from "@/lib/source";
-import { createFromSource } from "fumadocs-core/search/server";
-
-export const { GET } = createFromSource(source, {
-  // https://docs.orama.com/docs/orama-js/supported-languages
-  language: "english",
-});

apps/docs/app/global.css

@@ -1,12 +0,0 @@
-@import "tailwindcss";
-@import "fumadocs-ui/css/neutral.css";
-@import "fumadocs-ui/css/preset.css";
-
-html {
-  scrollbar-gutter: stable;
-}
-
-html > body[data-scroll-locked] {
-  margin-right: 0px !important;
-  --removed-body-scroll-bar-size: 0px !important;
-}

apps/docs/app/layout.tsx

@@ -1,37 +0,0 @@
-import type { Metadata } from "next";
-import { RootProvider } from "fumadocs-ui/provider/next";
-import { DocsLayout } from "fumadocs-ui/layouts/docs";
-import "./global.css";
-import { Inter } from "next/font/google";
-import { source } from "@/lib/source";
-import { baseOptions } from "@/lib/layout.shared";
-
-const inter = Inter({
-  subsets: ["latin"],
-});
-
-export const metadata: Metadata = {
-  metadataBase: new URL("https://docs.ttsarena.org"),
-  title: {
-    default: "TTS Arena Docs",
-    template: "%s · TTS Arena Docs",
-  },
-  description:
-    "Documentation for TTS Arena — the crowdsourced text-to-speech benchmark.",
-};
-
-export default function Layout({ children }: LayoutProps<"/">) {
-  return (
-    <html lang="en" className={inter.className} suppressHydrationWarning>
-      <body className="flex min-h-screen flex-col">
-        <RootProvider>
-          {/* Docs are the whole site — the DocsLayout (sidebar + nav) wraps
-              everything at the root; there is no separate homepage. */}
-          <DocsLayout tree={source.getPageTree()} {...baseOptions()}>
-            {children}
-          </DocsLayout>
-        </RootProvider>
-      </body>
-    </html>
-  );
-}

apps/docs/app/llms-full.txt/route.ts

@@ -1,10 +0,0 @@
-import { getLLMText, source } from "@/lib/source";
-
-export const revalidate = false;
-
-export async function GET() {
-  const scan = source.getPages().map(getLLMText);
-  const scanned = await Promise.all(scan);
-
-  return new Response(scanned.join("\n\n"));
-}

apps/docs/app/llms.mdx/docs/[[...slug]]/route.ts

@@ -1,26 +0,0 @@
-import { getLLMText, getPageMarkdownUrl, source } from "@/lib/source";
-import { notFound } from "next/navigation";
-
-export const revalidate = false;
-
-export async function GET(
-  _req: Request,
-  { params }: RouteContext<"/llms.mdx/docs/[[...slug]]">,
-) {
-  const { slug } = await params;
-  const page = source.getPage(slug?.slice(0, -1));
-  if (!page) notFound();
-
-  return new Response(await getLLMText(page), {
-    headers: {
-      "Content-Type": "text/markdown",
-    },
-  });
-}
-
-export function generateStaticParams() {
-  return source.getPages().map((page) => ({
-    lang: page.locale,
-    slug: getPageMarkdownUrl(page).segments,
-  }));
-}

apps/docs/app/llms.txt/route.ts

@@ -1,8 +0,0 @@
-import { source } from "@/lib/source";
-import { llms } from "fumadocs-core/source";
-
-export const revalidate = false;
-
-export function GET() {
-  return new Response(llms(source).index());
-}

apps/docs/app/og/docs/[...slug]/route.tsx

@@ -1,35 +0,0 @@
-import { getPageImage, source } from "@/lib/source";
-import { notFound } from "next/navigation";
-import { ImageResponse } from "next/og";
-import { generate as DefaultImage } from "fumadocs-ui/og";
-import { appName } from "@/lib/shared";
-
-export const revalidate = false;
-
-export async function GET(
-  _req: Request,
-  { params }: RouteContext<"/og/docs/[...slug]">,
-) {
-  const { slug } = await params;
-  const page = source.getPage(slug.slice(0, -1));
-  if (!page) notFound();
-
-  return new ImageResponse(
-    <DefaultImage
-      title={page.data.title}
-      description={page.data.description}
-      site={appName}
-    />,
-    {
-      width: 1200,
-      height: 630,
-    },
-  );
-}
-
-export function generateStaticParams() {
-  return source.getPages().map((page) => ({
-    lang: page.locale,
-    slug: getPageImage(page).segments,
-  }));
-}

apps/docs/components/mdx.tsx

@@ -1,15 +0,0 @@
-import defaultMdxComponents from "fumadocs-ui/mdx";
-import type { MDXComponents } from "mdx/types";
-
-export function getMDXComponents(components?: MDXComponents) {
-  return {
-    ...defaultMdxComponents,
-    ...components,
-  } satisfies MDXComponents;
-}
-
-export const useMDXComponents = getMDXComponents;
-
-declare global {
-  type MDXProvidedComponents = ReturnType<typeof getMDXComponents>;
-}

apps/docs/content/docs/api.mdx

@@ -1,53 +0,0 @@
----
-title: Provider API
-description: The contract your TTS endpoint needs to join the arena.
----
-
-The arena talks to your model through a small HTTP contract. Our router calls
-your endpoint server-side, downloads the audio, and proxies it to the client -
-so the response never reaches the browser directly and your keys stay private.
-
-## The request
-
-We send a line of text and (optionally) a voice id. Your endpoint synthesizes it
-and returns audio. A typical shape:
-
-```http
-POST https://your-api.example.com/tts
-Authorization: Bearer <key>
-Content-Type: application/json
-
-{
-  "text": "The quick brown fox jumps over the lazy dog.",
-  "voice_id": "one-of-your-voice-ids"
-}
-```
-
-The exact field names are flexible - we adapt a small provider adapter per
-model. What matters is that, given text, you return speech.
-
-## The response
-
-Either is fine:
-
-- **Raw audio bytes** (`audio/mpeg`, `audio/wav`, …) returned directly, or
-- **JSON** containing base64 audio or a public URL we can download.
-
-Common formats (mp3, wav, ogg, flac, opus) all work; we normalize on our side.
-
-## Voices
-
-The arena cycles a **fixed pool of voices** rather than cloning. Provide a list
-of voice ids and we rotate through them across battles, so a model is judged
-across its range rather than a single voice.
-
-## Reliability
-
-- Aim to respond within ~15-30s for a sentence-length prompt.
-- Return a non-2xx (or an error payload) on failure - we record it, retry with
-  another model, and surface failing models in our admin tooling.
-
-<Callout type="info">
-  Latency and success rate are tracked per model. A model that fails frequently
-  can be temporarily timed out so it doesn't disrupt battles.
-</Callout>

apps/docs/content/docs/development.mdx

@@ -1,97 +0,0 @@
----
-title: Development
-description: Run TTS Arena locally and find your way around the codebase.
----
-
-TTS Arena is a [Bun](https://bun.sh) monorepo. The web app is Next.js; the
-router is a separate Hono service that talks to providers.
-
-## Prerequisites
-
-- [Bun](https://bun.sh) 1.1.42
-- A Postgres database
-- A Hugging Face OAuth app for sign-in
-  ([create one](https://huggingface.co/settings/applications/new))
-
-## Setup
-
-```bash
-git clone https://github.com/TTS-AGI/TTS-Arena
-cd TTS-Arena
-bun install
-```
-
-Point `DATABASE_URL` at your Postgres instance, then create the schema and seed
-a starter set of models:
-
-```bash
-cd apps/web
-bun run db:migrate
-bun run db:seed
-```
-
-## Configuration
-
-Set these in the environment (e.g. an `.env` the web app can read):
-
-| Variable                 | Required | Notes                                                                     |
-| ------------------------ | -------- | ------------------------------------------------------------------------- |
-| `DATABASE_URL`           | yes      | Postgres connection string. Add `?sslmode=require` for a TLS-only server. |
-| `HF_OAUTH_CLIENT_ID`     | yes      | From your Hugging Face OAuth app.                                         |
-| `HF_OAUTH_CLIENT_SECRET` | yes      | Same app.                                                                 |
-| `SESSION_SECRET`         | yes      | Any long random string.                                                   |
-| `ADMIN_USERS`            | no       | Comma-separated HF usernames with admin access.                           |
-| `ROUTER_URL`             | no       | Router base URL. Defaults to `http://localhost:8080`.                     |
-| `APP_URL`                | no       | Public app URL. Defaults to `http://localhost:3000`.                      |
-| `SECURITY_DISABLED`      | no       | Set to `1` to turn off the anti-fraud gate in local dev.                  |
-
-Provider API keys are read by the router from the environment too - add them as
-you wire up providers.
-
-## Running
-
-```bash
-bun run dev          # web app on :3000
-bun run dev:router   # router on :8080
-```
-
-## Useful scripts
-
-Run from the repo root:
-
-```bash
-bun run build        # build every workspace
-bun run lint         # lint every workspace
-bun run typecheck    # type-check every workspace
-bun test             # run tests
-bun run format       # prettier --write
-```
-
-And from `apps/web` for database work:
-
-```bash
-bun run db:generate    # generate a migration from schema changes
-bun run db:migrate     # apply migrations
-bun run db:seed        # seed models from the provider packages
-bun run db:recompute   # replay clean votes and rebuild ratings
-```
-
-## Layout
-
-```
-apps/web        Next.js app - arena, leaderboard, admin
-apps/router     Hono service that calls TTS providers
-apps/docs       this documentation site (Fumadocs)
-packages/shared        shared types + the rating math
-packages/provider-sdk  provider interface + registry
-packages/providers/*   individual public providers
-```
-
-The rating logic lives in `packages/shared` - `bradley-terry.ts` and
-`glicko.ts` - with tests alongside. See [Ranking](/ranking) for how it's used.
-
-## Contributing
-
-Issues and pull requests are welcome on
-[GitHub](https://github.com/TTS-AGI/TTS-Arena). The project is licensed under
-[Apache 2.0](https://github.com/TTS-AGI/TTS-Arena/blob/main/LICENSE).

apps/docs/content/docs/index.mdx

@@ -1,46 +0,0 @@
----
-title: Introduction
-description: A crowdsourced, blind benchmark for text-to-speech.
----
-
-**TTS Arena** ranks text-to-speech models by ear. You type a line, two anonymous
-models read it back, and you pick the one that sounds more human. Each vote
-feeds the leaderboard.
-
-The models stay hidden until you've voted, so the choice is about the audio, not
-the name attached to it.
-
-[**Open the arena and vote →**](https://huggingface.co/spaces/TTS-AGI/TTS-Arena-V2)
-
-## Why
-
-There hasn't been a good way to measure how natural a synthetic voice sounds.
-Word error rate tells you whether speech is intelligible, not whether it sounds
-alive. Mean opinion scores rely on a small panel in a lab. TTS Arena uses
-large-scale human preference instead - anyone can listen, compare, and vote, and
-the resulting leaderboard is open.
-
-## Start here
-
-<Cards>
-  <Card title="Voting" href="/voting">
-    How to vote and the rules that keep the board fair.
-  </Card>
-  <Card title="Ranking" href="/ranking">
-    How votes become a leaderboard.
-  </Card>
-  <Card title="Submit a model" href="/submit-a-model">
-    Add your model, publicly or under a codename.
-  </Card>
-  <Card title="Provider API" href="/api">
-    The HTTP contract your TTS endpoint needs to meet.
-  </Card>
-</Cards>
-
-## Quick facts
-
-- Sign in with Hugging Face to vote; accounts must be at least 30 days old.
-- Prompts are English-only for now, capped at 1,000 characters.
-- Models are revealed only after you vote.
-- TTS Arena is open source under Apache 2.0 -
-  [source on GitHub](https://github.com/TTS-AGI/TTS-Arena).

apps/docs/content/docs/meta.json

@@ -1,11 +0,0 @@
-{
-  "title": "Docs",
-  "pages": [
-    "index",
-    "voting",
-    "ranking",
-    "submit-a-model",
-    "api",
-    "development"
-  ]
-}

apps/docs/content/docs/ranking.mdx

@@ -1,56 +0,0 @@
----
-title: Ranking
-description: How votes become a leaderboard.
----
-
-Each counting vote is one head-to-head result: model A beat model B on a
-controlled prompt from the Random pool. The leaderboard is what falls out when
-you fit all of those results together.
-
-## The rating
-
-We rank models with a [Bradley–Terry](https://en.wikipedia.org/wiki/Bradley%E2%80%93Terry_model)
-model - a standard way to turn pairwise wins and losses into a single strength
-score per competitor. It's fit over the entire vote history at once, so a
-model's rating reflects every matchup it has been in, not just its recent ones.
-The result doesn't depend on the order votes arrived in.
-
-Ratings are centered around 1500, so the numbers read like familiar Elo scores.
-The fit is cached and refreshed as votes come in.
-
-## Rank by the lower bound
-
-A model's rating comes with a confidence interval - wide when there's little
-data, narrow once it has played a lot. We show the rating but **sort by the
-bottom of that interval**.
-
-The effect: a model can't shoot to the top off a handful of lucky wins. It has
-to be both good and well-tested to rank highly. Each row shows a `±` next to its
-rating so you can see how settled it is.
-
-## New models
-
-- A model needs **100 votes** to appear on the board. Below that the rating
-  swings too much to mean anything.
-- Under **300 votes** it's marked **Preliminary** - ranked normally, but still
-  moving.
-- Brand-new models with only a few votes are hidden by default. Tick **Show new
-  models with few votes** on the leaderboard to see them, with wide error bars.
-
-To keep tiny samples from producing absurd numbers (a model that has only ever
-won would otherwise rate infinitely high), the fit is lightly regularized toward
-the average. The nudge fades as real votes accumulate and is gone within a few
-hundred.
-
-## Why blind and pairwise
-
-Knowing a model's name changes how people hear it, so identities stay hidden
-until after the vote. And "which of these two is better?" is a far easier and
-more reliable judgment than scoring a single clip out of context - it's how
-listening tests have always been run.
-
-<Callout type="info">
-  Only clean votes on first-use Random prompts count. Typed custom prompts,
-  votes flagged by the anti-fraud system, and votes from quarantined accounts
-  are left out of the fit. See [Voting](/voting).
-</Callout>

apps/docs/content/docs/submit-a-model.mdx

@@ -1,38 +0,0 @@
----
-title: Submit a model
-description: Add your TTS model for evaluation - public or anonymous.
----
-
-Want your model on the board? Open an issue on [GitHub](https://github.com/TTS-AGI/TTS-Arena), join our [Discord](https://discord.gg/HB8fMR6GTr), or [email us](mailto:me@mrfake.name) and include an
-API endpoint and key (see the [Provider API](/api)).
-
-## What we need
-
-- An HTTP endpoint that synthesizes a line of text and returns audio.
-- A pool of voices to rotate through (we don't do zero-shot cloning in the
-  arena - we cycle a fixed set).
-- A display name for the leaderboard.
-
-## Anonymous pre-release
-
-You can run under a codename before your model is public - a way to get honest,
-blind feedback ahead of launch. Two rules keep this fair:
-
-- Anonymity is **time/exposure-bounded, not performance-bounded.** A codenamed
-  entry is revealed after a set period or vote count regardless of how it does -
-  you can withdraw it before then, but you can't sit on the board indefinitely
-  or reveal it _only because it won_.
-- **Permanent anonymity is for genuinely unreleased models.** A model that's
-  already publicly available runs under its real name (a codename for a fixed
-  window is fine).
-
-<Callout type="warn">
-  To keep comparisons fair, we don't evaluate multiple versions of the same
-  model simultaneously.
-</Callout>
-
-## Stealth models
-
-Anonymous entries appear on the leaderboard under their codename with a neutral
-mark. Clicking one explains it's a stealth model in evaluation - its identity
-stays hidden until it's revealed.

apps/docs/content/docs/voting.mdx

@@ -1,45 +0,0 @@
----
-title: Voting
-description: What makes a vote count, and the rules that keep the board fair.
----
-
-## Casting a vote
-
-1. Type a line, or hit **Random** for one from the prompt pool.
-2. Two anonymous models - **A** and **B** - synthesize it.
-3. Listen to both, then pick the one that sounds more human. One choice, no
-   skips.
-4. The identities are revealed. If the line came unchanged from **Random**, the
-   public ratings update.
-
-You need to listen to enough of each clip before voting unlocks - this keeps
-votes grounded in the audio rather than reflexive clicks.
-
-## Requirements
-
-- **Sign in with Hugging Face.** Voting is tied to your account so each vote
-  counts once. Accounts must be at least **30 days old**.
-- **English only**, for now - it's the language all models support. Multilingual
-  is on the roadmap.
-- Prompts are capped at **1,000 characters**.
-- Only clean votes on first-use **Random** prompts move the public leaderboard.
-  Typed custom prompts are still useful for side-by-side listening, but they do
-  not affect ratings.
-
-## Keeping it fair
-
-Votes run through an anti-abuse system so the board reflects real preferences:
-
-- **Behavioral signals** score each vote for risk (timing, patterns, device and
-  network signals). High-risk votes are recorded but **shadow-excluded** - they
-  never move the public ratings.
-- A lightweight **proof-of-work captcha** appears once per session, and again if
-  risk rises.
-- A background sweep looks for coordinated rings (many accounts sharing an IP or
-  fingerprint piling onto one model) and per-account bias, retroactively
-  excluding suspicious votes and recomputing the board from the clean set.
-
-<Callout>
-  None of this affects honest voting - it's invisible unless your activity looks
-  automated or coordinated.
-</Callout>

apps/docs/lib/cn.ts

@@ -1 +0,0 @@
-export { twMerge as cn } from "tailwind-merge";

apps/docs/lib/layout.shared.tsx

@@ -1,24 +0,0 @@
-import type { BaseLayoutProps } from "fumadocs-ui/layouts/shared";
-import { AudioLines } from "lucide-react";
-import { appName, arenaUrl, gitConfig } from "./shared";
-
-export function baseOptions(): BaseLayoutProps {
-  return {
-    nav: {
-      title: (
-        <>
-          <AudioLines className="text-fd-primary size-5" />
-          <span className="font-semibold">{appName}</span>
-        </>
-      ),
-    },
-    links: [
-      {
-        text: "Open the Arena",
-        url: arenaUrl,
-        external: true,
-      },
-    ],
-    githubUrl: `https://github.com/${gitConfig.user}/${gitConfig.repo}`,
-  };
-}

apps/docs/lib/shared.ts

@@ -1,14 +0,0 @@
-export const appName = "TTS Arena Docs";
-// Docs are served at the root — there's no separate homepage.
-export const docsRoute = "/";
-export const docsImageRoute = "/og/docs";
-export const docsContentRoute = "/llms.mdx/docs";
-
-/** The main arena, linked from the docs nav. */
-export const arenaUrl = "https://huggingface.co/spaces/TTS-AGI/TTS-Arena-V2";
-
-export const gitConfig = {
-  user: "TTS-AGI",
-  repo: "TTS-Arena",
-  branch: "main",
-};

apps/docs/lib/source.ts

@@ -1,37 +0,0 @@
-import { docs } from "collections/server";
-import { loader } from "fumadocs-core/source";
-import { lucideIconsPlugin } from "fumadocs-core/source/lucide-icons";
-import { docsContentRoute, docsImageRoute, docsRoute } from "./shared";
-
-// See https://fumadocs.dev/docs/headless/source-api for more info
-export const source = loader({
-  baseUrl: docsRoute,
-  source: docs.toFumadocsSource(),
-  plugins: [lucideIconsPlugin()],
-});
-
-export function getPageImage(page: (typeof source)["$inferPage"]) {
-  const segments = [...page.slugs, "image.png"];
-
-  return {
-    segments,
-    url: `${docsImageRoute}/${segments.join("/")}`,
-  };
-}
-
-export function getPageMarkdownUrl(page: (typeof source)["$inferPage"]) {
-  const segments = [...page.slugs, "content.md"];
-
-  return {
-    segments,
-    url: `${docsContentRoute}/${segments.join("/")}`,
-  };
-}
-
-export async function getLLMText(page: (typeof source)["$inferPage"]) {
-  const processed = await page.data.getText("processed");
-
-  return `# ${page.data.title} (${page.url})
-
-${processed}`;
-}

apps/docs/next.config.mjs

@@ -1,25 +0,0 @@
-import { createMDX } from "fumadocs-mdx/next";
-
-const withMDX = createMDX();
-
-/** @type {import('next').NextConfig} */
-const config = {
-  reactStrictMode: true,
-  // Self-contained server bundle for the Docker/HF Space deploy. Built in
-  // isolation in Docker (only apps/docs present, no parent workspace), so Next
-  // traces from the app dir and server.js lands at the standalone root. No
-  // explicit tracing root — that's only needed for monorepo builds, and a wrong
-  // value trips Turbopack's workspace-root inference.
-  output: "standalone",
-  typescript: {
-    // The page uses fumadocs' generated MDX page-data fields (body/toc/getText)
-    // whose types are injected by the MDX plugin at build time and aren't
-    // visible to a plain tsc pass — it's the template's own pattern. The MDX
-    // still compiles and renders fine; don't fail the build on this gap. (The
-    // docs app is content + template boilerplate, so there's little else to
-    // type-check here anyway.)
-    ignoreBuildErrors: true,
-  },
-};
-
-export default withMDX(config);

apps/docs/package.json

@@ -1,33 +0,0 @@
-{
-  "name": "@ttsa/docs",
-  "version": "0.1.0",
-  "private": true,
-  "type": "module",
-  "scripts": {
-    "build": "fumadocs-mdx && next build --webpack",
-    "dev": "fumadocs-mdx && next dev",
-    "start": "next start",
-    "typecheck": "echo 'docs: typecheck handled by next build (fumadocs MDX types are build-time)'",
-    "lint": "echo 'no lint for docs'"
-  },
-  "dependencies": {
-    "fumadocs-core": "16.9.3",
-    "fumadocs-mdx": "15.0.11",
-    "fumadocs-ui": "16.9.3",
-    "lucide-react": "^1.17.0",
-    "next": "16.2.7",
-    "react": "^19.2.0",
-    "react-dom": "^19.2.0",
-    "tailwind-merge": "^3.6.0"
-  },
-  "devDependencies": {
-    "@tailwindcss/postcss": "^4.3.0",
-    "@types/mdx": "^2.0.13",
-    "@types/node": "^25.9.1",
-    "@types/react": "^19.2.0",
-    "@types/react-dom": "^19.2.0",
-    "postcss": "^8.5.15",
-    "tailwindcss": "^4.3.0",
-    "typescript": "^6.0.3"
-  }
-}

apps/docs/postcss.config.mjs

@@ -1,7 +0,0 @@
-const config = {
-  plugins: {
-    "@tailwindcss/postcss": {},
-  },
-};
-
-export default config;

apps/docs/proxy.ts

@@ -1,29 +0,0 @@
-import { NextRequest, NextResponse } from "next/server";
-import { isMarkdownPreferred, rewritePath } from "fumadocs-core/negotiation";
-import { docsContentRoute, docsRoute } from "@/lib/shared";
-
-const { rewrite: rewriteDocs } = rewritePath(
-  `${docsRoute}{/*path}`,
-  `${docsContentRoute}{/*path}/content.md`,
-);
-const { rewrite: rewriteSuffix } = rewritePath(
-  `${docsRoute}{/*path}.md`,
-  `${docsContentRoute}{/*path}/content.md`,
-);
-
-export default function proxy(request: NextRequest) {
-  const result = rewriteSuffix(request.nextUrl.pathname);
-  if (result) {
-    return NextResponse.rewrite(new URL(result, request.nextUrl));
-  }
-
-  if (isMarkdownPreferred(request)) {
-    const result = rewriteDocs(request.nextUrl.pathname);
-
-    if (result) {
-      return NextResponse.rewrite(new URL(result, request.nextUrl));
-    }
-  }
-
-  return NextResponse.next();
-}

apps/docs/public/.gitkeep

@@ -1 +0,0 @@
-# Static assets for the docs site.

apps/docs/source.config.ts

@@ -1,23 +0,0 @@
-import { defineConfig, defineDocs } from "fumadocs-mdx/config";
-import { metaSchema, pageSchema } from "fumadocs-core/source/schema";
-
-// You can customize Zod schemas for frontmatter and `meta.json` here
-// see https://fumadocs.dev/docs/mdx/collections
-export const docs = defineDocs({
-  dir: "content/docs",
-  docs: {
-    schema: pageSchema,
-    postprocess: {
-      includeProcessedMarkdown: true,
-    },
-  },
-  meta: {
-    schema: metaSchema,
-  },
-});
-
-export default defineConfig({
-  mdxOptions: {
-    // MDX options
-  },
-});

apps/docs/tsconfig.json

@@ -1,35 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ESNext",
-    "lib": ["dom", "dom.iterable", "esnext"],
-    "allowJs": true,
-    "skipLibCheck": true,
-    "strict": true,
-    "forceConsistentCasingInFileNames": true,
-    "noEmit": true,
-    "esModuleInterop": true,
-    "module": "esnext",
-    "moduleResolution": "bundler",
-    "resolveJsonModule": true,
-    "isolatedModules": true,
-    "jsx": "react-jsx",
-    "incremental": true,
-    "paths": {
-      "@/*": ["./*"],
-      "collections/*": ["./.source/*"]
-    },
-    "plugins": [
-      {
-        "name": "next"
-      }
-    ]
-  },
-  "include": [
-    "next-env.d.ts",
-    "**/*.ts",
-    "**/*.tsx",
-    ".next/types/**/*.ts",
-    ".next/dev/types/**/*.ts"
-  ],
-  "exclude": ["node_modules"]
-}