init

.gitignore

@@ -0,0 +1,63 @@
+# Dependencies
+node_modules/
+yarn.lock
+package-lock.json
+pnpm-lock.yaml
+
+# Environment variables
+.env
+.env.local
+.env.*.local
+
+# Build artifacts
+dist/
+build/
+*.tsbuildinfo
+.next/
+out/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+.DS_Store
+
+# Testing
+coverage/
+.nyc_output/
+
+# Logs
+logs/
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+lerna-debug.log*
+
+# Docker
+.dockerignore
+docker-compose.override.yml
+
+# Cache
+.cache/
+.eslintcache
+
+# OS
+Thumbs.db
+.DS_Store
+
+# Optional npm cache directory
+.npm
+
+# Optional eslint cache
+.eslintcache
+
+# Temporary files
+tmp/
+temp/
+*.tmp
+
+# Redis data (if running locally)
+dump.rdb

DEPLOYMENT.md

@@ -0,0 +1,222 @@
+# WagerKit - Hugging Face Spaces Deployment Guide
+
+## Quick Start
+
+### Option 1: Hugging Face Spaces (Recommended for Demo)
+
+1. **Create a new Docker Space on Hugging Face**
+   - Go to https://huggingface.co/new-space
+   - Choose "Docker" as the SDK
+   - Name your space (e.g., `wagerkit-demo`)
+
+2. **Clone this repository and push to your Space**
+   ```bash
+   git clone <your-repo-url>
+   cd wagerkit
+   git remote add space https://huggingface.co/spaces/<your-username>/<space-name>
+   git push space main
+   ```
+
+3. **Configure Space Settings**
+   - In your Space settings, set:
+     - **Hardware**: CPU Basic (free tier)
+     - **Visibility**: Public
+   - Add secrets (optional):
+     - `DOME_API_KEY`: Your DOME API key
+
+4. **The Space will automatically build and deploy**
+   - Build time: ~5-10 minutes
+   - Access URL: `https://<your-username>-<space-name>.hf.space`
+
+### Option 2: Local Development with Docker Compose
+
+```bash
+# Start all services
+docker-compose up -d
+
+# View logs
+docker-compose logs -f
+
+# Stop services
+docker-compose down
+```
+
+Access the app at:
+- Frontend: http://localhost:3000
+- Backend API: http://localhost:3001/api
+
+### Option 3: Local Development (Without Docker)
+
+**Terminal 1 - Backend:**
+```bash
+cd backend
+npm install
+npm run start:dev
+```
+
+**Terminal 2 - Frontend:**
+```bash
+cd frontend
+npm install
+npm run dev
+```
+
+**Terminal 3 - Redis:**
+```bash
+docker run -d --name wagerkit-redis -p 6379:6379 redis:7-alpine
+```
+
+## Architecture
+
+```
+┌─────────────────────────────────────────────┐
+│           Hugging Face Spaces               │
+│                                             │
+│  ┌──────────────────────────────────────┐  │
+│  │         Docker Container              │  │
+│  │                                       │  │
+│  │  ┌──────────┐    ┌─────────────┐    │  │
+│  │  │  Redis   │◄───┤   Backend   │    │  │
+│  │  │  :6379   │    │  NestJS API │    │  │
+│  │  └──────────┘    │   :3001     │    │  │
+│  │                  └──────▲──────┘    │  │
+│  │                         │            │  │
+│  │                  ┌──────┴──────┐    │  │
+│  │                  │  Frontend   │    │  │
+│  │                  │  Next.js    │    │  │
+│  │                  │   :7860     │    │  │
+│  │                  └─────────────┘    │  │
+│  │                                       │  │
+│  └──────────────────────────────────────┘  │
+│                                             │
+└─────────────────────────────────────────────┘
+```
+
+## Project Structure
+
+```
+wagerkit/
+├── backend/                 # NestJS backend
+│   ├── src/
+│   │   ├── markets/        # Markets module (BullMQ workers)
+│   │   ├── auth/           # Auth module (unused in demo)
+│   │   └── main.ts
+│   ├── Dockerfile          # Backend Docker image
+│   └── package.json
+├── frontend/               # Next.js frontend
+│   ├── src/
+│   │   ├── app/           # App router pages
+│   │   ├── components/    # Reusable components
+│   │   └── lib/           # API client
+│   ├── Dockerfile         # Frontend Docker image
+│   └── package.json
+├── Dockerfile             # Multi-stage build (HF Spaces)
+├── docker-compose.yml     # Local development
+└── README.md
+```
+
+## Environment Variables
+
+### Backend (.env)
+```env
+NODE_ENV=production
+PORT=3001
+REDIS_HOST=localhost
+REDIS_PORT=6379
+DOME_API_KEY=your_dome_api_key_here
+```
+
+### Frontend (.env.local)
+```env
+NEXT_PUBLIC_API_URL=http://localhost:3001/api
+```
+
+## Features
+
+✅ **Background Processing with BullMQ**
+- Markets are pre-processed on startup
+- Dashboard loads instantly with cached data
+- Redis-backed job queue
+
+✅ **Integrity Score Calculation**
+- Market Clarity (40% weight)
+- Liquidity Depth (30% weight)
+- Cross-Source Agreement (20% weight)
+- Volatility Sanity (10% weight)
+
+✅ **Data Visualization**
+- Real-time odds history charts (Chart.js)
+- Multi-source comparison (Polymarket, Kalshi, PredictIt, WagerKit)
+- Dark theme UI with Tailwind CSS
+
+✅ **Export Functionality**
+- PDF dossier generation (jsPDF)
+- Odds history CSV export
+- Integrity metrics JSON export
+
+## Troubleshooting
+
+### Hugging Face Spaces Build Failing
+
+1. **Check build logs in Space settings**
+2. **Verify Dockerfile syntax**:
+   ```bash
+   docker build -t wagerkit-test -f Dockerfile .
+   ```
+3. **Ensure all dependencies are specified in package.json**
+
+### Redis Connection Issues
+
+If you see "ECONNREFUSED 127.0.0.1:6379":
+- Ensure Redis is running in the container
+- Check `REDIS_HOST` environment variable
+- Verify Redis is starting before the backend
+
+### Port Conflicts (Local Development)
+
+```bash
+# Kill processes on ports 3000, 3001, 6379
+npx kill-port 3000 3001 6379
+```
+
+### Frontend API Connection
+
+If frontend can't reach backend:
+- Check `NEXT_PUBLIC_API_URL` in `.env.local`
+- Verify backend is running on expected port
+- Check browser console for CORS errors
+
+## Production Deployment Best Practices
+
+1. **Use environment-specific API URLs**
+   ```javascript
+   const API_URL = process.env.NEXT_PUBLIC_API_URL || 'https://your-backend-url.com/api';
+   ```
+
+2. **Enable Redis persistence**
+   ```bash
+   redis-server --appendonly yes
+   ```
+
+3. **Set up health checks**
+   - Backend: `GET /health`
+   - Frontend: `GET /api/health`
+
+4. **Configure resource limits** (docker-compose.yml)
+   ```yaml
+   deploy:
+     resources:
+       limits:
+         cpus: '1.0'
+         memory: 1G
+   ```
+
+## Support
+
+For issues or questions:
+- GitHub Issues: [Your Repo URL]
+- Documentation: [Your Docs URL]
+
+## License
+
+[Your License]

Dockerfile

@@ -0,0 +1,97 @@
+# Multi-stage Dockerfile for WagerKit (Hugging Face Spaces Compatible)
+
+# Stage 1: Build Backend
+FROM node:20-alpine AS backend-build
+
+WORKDIR /app/backend
+
+# Copy backend package files
+COPY backend/package*.json ./
+RUN npm ci --only=production
+
+# Copy backend source and build
+COPY backend ./
+RUN npm run build
+
+# Stage 2: Build Frontend
+FROM node:20-alpine AS frontend-build
+
+WORKDIR /app/frontend
+
+# Copy frontend package files
+COPY frontend/package*.json ./
+RUN npm ci
+
+# Copy frontend source
+COPY frontend ./
+
+# Build Next.js frontend (standalone mode)
+ENV NEXT_PUBLIC_API_URL=/api
+RUN npm run build
+
+# Stage 3: Production Runtime
+FROM node:20-alpine
+
+WORKDIR /app
+
+# Install dependencies for Redis and process management
+RUN apk add --no-cache redis bash
+
+# Copy backend production files
+COPY --from=backend-build /app/backend/dist ./backend/dist
+COPY --from=backend-build /app/backend/node_modules ./backend/node_modules
+COPY --from=backend-build /app/backend/package.json ./backend/
+
+# Copy backend .env (if exists)
+COPY backend/.env ./backend/.env 2>/dev/null || true
+
+# Copy frontend production files (standalone build)
+COPY --from=frontend-build /app/frontend/.next/standalone ./frontend/
+COPY --from=frontend-build /app/frontend/.next/static ./frontend/.next/static
+COPY --from=frontend-build /app/frontend/public ./frontend/public
+COPY --from=frontend-build /app/frontend/package.json ./frontend/
+
+# Environment variables for Hugging Face Spaces
+ENV NODE_ENV=production
+ENV PORT=7860
+ENV REDIS_HOST=127.0.0.1
+ENV REDIS_PORT=6379
+ENV NEXT_PUBLIC_API_URL=/api
+
+# Expose Hugging Face Spaces default port
+EXPOSE 7860
+
+# Create comprehensive startup script
+RUN cat > /app/start.sh << 'EOF'
+#!/bin/bash
+set -e
+
+echo "🚀 Starting WagerKit on Hugging Face Spaces..."
+
+# Start Redis in background
+echo "📦 Starting Redis..."
+redis-server --daemonize yes --bind 127.0.0.1 --port 6379 --loglevel warning
+sleep 2
+
+# Verify Redis is running
+redis-cli ping > /dev/null
+echo "✅ Redis is ready"
+
+# Start Backend in background
+echo "🔧 Starting NestJS backend..."
+cd /app/backend
+PORT=3001 node dist/main.js &
+BACKEND_PID=$!
+sleep 3
+echo "✅ Backend started (PID: $BACKEND_PID)"
+
+# Start Frontend (foreground - keeps container alive)
+echo "🌐 Starting Next.js frontend on port 7860..."
+cd /app/frontend
+PORT=7860 node server.js
+
+EOF
+
+RUN chmod +x /app/start.sh
+
+CMD ["/app/start.sh"]

HUGGINGFACE_SETUP.md

@@ -0,0 +1,173 @@
+# 🚀 Hugging Face Spaces Deployment Guide
+
+## Step-by-Step Instructions
+
+### 1. Create a New Space
+
+1. Go to https://huggingface.co/new-space
+2. Fill in the details:
+   - **Name**: `wagerkit` (or your preferred name)
+   - **License**: MIT
+   - **SDK**: Select **Docker**
+   - **Hardware**: CPU Basic (free tier is sufficient)
+   - **Visibility**: Public (or Private if you prefer)
+3. Click **Create Space**
+
+### 2. Push Your Code to the Space
+
+```bash
+# Navigate to your project directory
+cd c:\demo
+
+# Initialize git (if not already)
+git init
+git add .
+git commit -m "Initial commit: WagerKit prediction market analysis"
+
+# Add your Hugging Face Space as a remote
+git remote add space https://huggingface.co/spaces/<your-username>/<space-name>
+
+# Push to the Space
+git push space main
+```
+
+### 3. Wait for Build
+
+- The Space will automatically start building
+- Build time: ~5-10 minutes
+- You can watch the build logs in the Space's "Logs" tab
+
+### 4. Access Your Deployed App
+
+Once the build completes, your app will be available at:
+```
+https://<your-username>-<space-name>.hf.space
+```
+
+Example: `https://johndoe-wagerkit.hf.space`
+
+## 🔧 Configuration
+
+### Optional: Add Secrets
+
+If you want to use a real DOME API key:
+
+1. In your Space settings, go to **Variables and secrets**
+2. Add a new secret:
+   - **Name**: `DOME_API_KEY`
+   - **Value**: Your actual DOME API key
+
+### Port Configuration
+
+The Dockerfile is pre-configured for Hugging Face Spaces:
+- Uses port **7860** (HF Spaces default)
+- Backend runs on internal port 3001
+- Frontend (port 7860) proxies API requests to backend
+
+## 🐛 Troubleshooting
+
+### Build Fails
+
+**Check the build logs:**
+1. Go to your Space
+2. Click the "Logs" tab
+3. Look for error messages
+
+**Common issues:**
+- Missing dependencies: Ensure `package.json` is complete
+- Build timeout: The free tier has build time limits
+- Memory issues: Try optimizing your build process
+
+### App Not Responding
+
+**Check the runtime logs:**
+1. Go to your Space
+2. Click the "Logs" tab (after build)
+3. Look for runtime errors
+
+**Common issues:**
+- Redis not starting: Check the startup script logs
+- Backend crash: Check for missing environment variables
+- Port conflicts: Ensure using port 7860
+
+### Slow Performance
+
+Free tier CPU Basic has limited resources. Consider:
+- Upgrading to CPU Medium (paid)
+- Optimizing your code
+- Adding caching
+
+## 📊 Monitoring
+
+### Health Checks
+
+Your app includes automatic health monitoring:
+- Redis health: Checked on startup
+- Backend health: Automatic restart if crashes
+- Frontend health: Next.js handles gracefully
+
+### Logs
+
+View real-time logs in your Space:
+```
+Settings → Logs
+```
+
+Look for:
+- `✅ Redis is ready` - Confirms Redis started
+- `✅ Backend started` - Confirms backend is running
+- `🌐 Starting Next.js frontend` - Confirms frontend is starting
+
+## 🔄 Updates
+
+To update your deployed app:
+
+```bash
+# Make your changes
+git add .
+git commit -m "Description of changes"
+
+# Push to Space
+git push space main
+```
+
+The Space will automatically rebuild and redeploy.
+
+## 💰 Cost
+
+**Free Tier (CPU Basic):**
+- ✅ Sufficient for demo/development
+- ✅ Auto-sleeps after inactivity
+- ✅ No credit card required
+
+**Paid Tiers:**
+- CPU Medium: Better performance
+- GPU: Not needed for this app
+
+## 🎓 Next Steps
+
+1. **Test your deployment**: Visit your Space URL
+2. **Share**: Your Space is now public (if you chose public visibility)
+3. **Monitor**: Check logs for any issues
+4. **Optimize**: Add caching, optimize queries
+5. **Extend**: Add more markets, features
+
+## 📚 Resources
+
+- [Hugging Face Spaces Documentation](https://huggingface.co/docs/hub/spaces)
+- [Docker Spaces Guide](https://huggingface.co/docs/hub/spaces-sdks-docker)
+- [WagerKit Deployment Guide](./DEPLOYMENT.md)
+
+## ✨ Success Criteria
+
+Your deployment is successful when:
+- ✅ Space shows "Running" status
+- ✅ You can access the URL
+- ✅ Dashboard shows 3 markets
+- ✅ Clicking a card opens the detail page
+- ✅ Charts render correctly
+- ✅ Export buttons work
+
+---
+
+**Questions?** Check the [DEPLOYMENT.md](./DEPLOYMENT.md) for more details or open an issue on GitHub.

README.md

@@ -0,0 +1,263 @@
+---
+title: WagerKit
+emoji: 📊
+colorFrom: purple
+colorTo: blue
+sdk: docker
+pinned: false
+license: mit
+---
+
+# WagerKit 🎯
+
+**Real-time prediction market analysis with integrity scoring**
+
+WagerKit aggregates data from multiple prediction market sources (Polymarket, Kalshi, PredictIt) and provides comprehensive integrity analysis for each market.
+
+## ✨ Features
+
+- 📈 **Multi-Source Aggregation**: Compare odds across leading prediction markets
+- 🎯 **Integrity Scoring**: 4-component analysis (Clarity, Liquidity, Agreement, Volatility)
+- 📊 **Visual Analytics**: Real-time odds history charts with Chart.js
+- 📥 **Export Tools**: PDF dossiers, CSV data exports, JSON metadata
+- ⚡ **Background Processing**: BullMQ-powered workers for instant dashboard loads
+- 🎨 **Modern UI**: Dark theme, responsive design with Tailwind CSS
+
+## 🏗️ Architecture
+
+```
+┌─────────────────────────────────────┐
+│      Docker Container (HF Space)    │
+│                                     │
+│  Redis ──► NestJS Backend (BullMQ) │
+│              ↓                      │
+│         Next.js Frontend            │
+│           (Port 7860)               │
+└─────────────────────────────────────┘
+```
+
+## 🚀 Quick Start
+
+### On Hugging Face Spaces
+
+Simply clone this Space or visit the live demo!
+
+### Local Development
+
+```bash
+# Clone the repository
+git clone <your-repo-url>
+cd wagerkit
+
+# Start with Docker Compose
+docker-compose up
+
+# Or run individually:
+# Terminal 1: Redis
+docker run -d -p 6379:6379 redis:7-alpine
+
+# Terminal 2: Backend
+cd backend && npm install && npm run start:dev
+
+# Terminal 3: Frontend
+cd frontend && npm install && npm run dev
+```
+
+Access at: http://localhost:3000
+
+## 📊 Integrity Score Formula
+
+**Overall Score** = 100 × (0.40×C + 0.30×L + 0.20×A + 0.10×V)
+
+- **C** (Market Clarity): Resolution criteria quality, source coverage
+- **L** (Liquidity Depth): Trading volume, update frequency
+- **A** (Cross-Source Agreement): RMSE between sources
+- **V** (Volatility Sanity): Price stability, spike detection
+
+## 🛠️ Tech Stack
+
+**Backend:**
+- NestJS 10 (TypeScript)
+- BullMQ (background jobs)
+- Redis (job queue & cache)
+
+**Frontend:**
+- Next.js 14 (App Router)
+- React 18
+- Chart.js (visualization)
+- Tailwind CSS (styling)
+- jsPDF (PDF export)
+
+## 📦 Deployment
+
+See [DEPLOYMENT.md](./DEPLOYMENT.md) for detailed instructions on:
+- Hugging Face Spaces setup
+- Docker configuration
+- Environment variables
+- Local development
+
+## 🎮 Usage
+
+1. **Dashboard**: View all markets with processing status badges
+2. **Click any card**: Navigate to detailed market analysis
+3. **View Charts**: Compare historical odds across 4 sources
+4. **Export Data**: Download PDF dossiers, CSV odds history, or JSON metadata
+
+## 📁 Project Structure
+
+```
+wagerkit/
+├── backend/                 # NestJS backend
+│   ├── src/
+│   │   ├── markets/        # Markets module (BullMQ workers)
+│   │   ├── auth/           # Auth module (unused in demo)
+│   │   └── main.ts
+│   ├── Dockerfile          # Backend Docker image
+│   └── package.json
+├── frontend/               # Next.js frontend
+│   ├── src/
+│   │   ├── app/           # App router pages
+│   │   ├── components/    # Reusable components
+│   │   └── lib/           # API client
+│   ├── Dockerfile         # Frontend Docker image
+│   └── package.json
+├── Dockerfile             # Multi-stage build (HF Spaces)
+├── docker-compose.yml     # Local development
+├── DEPLOYMENT.md          # Detailed deployment guide
+└── README.md
+```
+
+## 🤝 Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## 📄 License
+
+MIT License
+
+## 🙏 Acknowledgments
+
+Built with data from leading prediction markets. This is a demonstration project showcasing real-time data aggregation and integrity analysis techniques.
+
+---
+
+**Documentation**: [DEPLOYMENT.md](./DEPLOYMENT.md)
+Each market includes:
+- **Integrity Score** (0-100) with 4 sub-components:
+  - Market Clarity (40% weight)
+  - Liquidity Depth (30% weight)
+  - Cross-Source Agreement (20% weight)
+  - Volatility Sanity (10% weight)
+- **Odds History Chart** - 24-hour price trends from 3 sources
+- **Data Sources** - Polymarket, Kalshi, PredictIt
+- **Export Options**:
+  - ✅ Download Dossier (PDF)
+  - ✅ Download Dossier (JSON)
+  - ✅ Export Odds CSV
+  - ✅ Export Integrity CSV
+
+## 📊 Integrity Score Formula
+
+```
+Score = 100 × (0.40×C + 0.30×L + 0.20×A + 0.10×V)
+```
+
+Where:
+- **C** = Market Clarity
+- **L** = Liquidity Depth
+- **A** = Cross-Source Agreement (RMSE-based)
+- **V** = Volatility Sanity (includes spike detection)
+
+## 🔧 Tech Stack
+
+### Backend
+- NestJS 10
+- TypeScript
+- JWT Authentication (ready but disabled)
+- Express.js
+
+### Frontend
+- Next.js 14
+- React 18
+- TypeScript
+- TailwindCSS
+- Chart.js (for odds visualization)
+- jsPDF (for PDF exports)
+
+## 📝 API Endpoints
+
+### Markets
+- `GET /api/markets` - List all markets
+- `GET /api/markets/:slug` - Get market detail with integrity scores
+- `GET /api/markets/:slug/export/odds-csv` - Export odds history CSV
+- `GET /api/markets/:slug/export/integrity-csv` - Export integrity scores CSV
+- `GET /api/markets/:slug/export/dossier-json` - Export full dossier JSON
+
+### Authentication (Optional)
+- `POST /api/auth/login` - Login endpoint (not required for demo)
+
+## 🔑 Environment Variables
+
+### Backend (`backend/.env`)
+```env
+JWT_SECRET=wagerkit-jwt-secret-key-2024
+DOME_API_KEY=your-dome-api-key-here
+PORT=3001
+```
+
+### Frontend (`frontend/.env.local`)
+```env
+NEXT_PUBLIC_API_URL=http://localhost:3001/api
+```
+
+## 🎨 Design Theme
+- Dark purple/blue gradient background
+- Card-based UI with `#12121e` background
+- Purple (`#6b21a8`) and blue (`#3b82f6`) accent colors
+- Responsive design with Tailwind CSS
+
+## 🔮 DOME API Integration (Future)
+
+The app is designed to integrate with the DOME API. To enable real data:
+
+1. **Install SDK**:
+   ```bash
+   cd backend
+   npm install @dome-api/sdk
+   ```
+
+2. **Add API Key** to `backend/.env`:
+   ```env
+   DOME_API_KEY=your-actual-api-key
+   ```
+
+3. **Update Service** in `backend/src/markets/markets.service.ts`:
+   - Uncomment the DOME SDK import
+   - Replace simulated data methods with real API calls
+
+Currently uses simulated data with realistic patterns for demo purposes.
+
+## 🚢 Deployment
+
+### Build Production
+```bash
+# Backend
+cd backend
+npm run build
+npm run start:prod
+
+# Frontend
+cd frontend
+npm run build
+npm start
+```
+
+## 📋 Notes
+- Authentication is **disabled** for easy demo access
+- Data is **simulated** but follows real market patterns
+- All export features are **fully functional**
+- Runs entirely locally - no external dependencies required
+
+---
+
+**Built for client demo - February 2026**

backend/.env.example

@@ -0,0 +1,34 @@
+# Backend Environment Variables
+
+# Node Environment
+NODE_ENV=production
+
+# Server Port
+PORT=3001
+
+# Redis Configuration
+REDIS_HOST=localhost
+REDIS_PORT=6379
+
+# Optional: Redis Authentication (if using hosted Redis)
+# REDIS_PASSWORD=your_password_here
+
+# Optional: Redis TLS (set to 'true' for hosted Redis with TLS)
+# REDIS_TLS=false
+
+# Optional: DOME API Key (if integrating real data)
+DOME_API_KEY=your_dome_api_key_here
+
+# Database Configuration (if you extend to use PostgreSQL/ClickHouse)
+# DB_HOST=localhost
+# DB_PORT=5432
+# DB_USER=postgres
+# DB_PASSWORD=postgres
+# DB_NAME=wagerkit
+# DB_SSL=false
+
+# ClickHouse Configuration (if using ClickHouse for tick data)
+# CLICKHOUSE_HOST=http://localhost:8123
+# CLICKHOUSE_USER=default
+# CLICKHOUSE_PASSWORD=
+# CLICKHOUSE_DB=default

backend/Dockerfile

@@ -0,0 +1,22 @@
+# Backend Dockerfile
+FROM node:20-alpine
+
+WORKDIR /app
+
+# Copy package files
+COPY package*.json ./
+
+# Install dependencies
+RUN npm ci --only=production
+
+# Copy source
+COPY . .
+
+# Build application
+RUN npm run build
+
+# Expose port
+EXPOSE 3001
+
+# Start application
+CMD ["node", "dist/main.js"]

backend/nest-cli.json

@@ -0,0 +1,8 @@
+{
+  "$schema": "https://json.schemastore.org/nest-cli",
+  "collection": "@nestjs/schematics",
+  "sourceRoot": "src",
+  "compilerOptions": {
+    "deleteOutDir": true
+  }
+}

backend/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "wagerkit-backend",
+  "version": "1.0.0",
+  "description": "WagerKit API Backend",
+  "scripts": {
+    "build": "nest build",
+    "start": "nest start",
+    "start:dev": "nest start --watch",
+    "start:prod": "node dist/main"
+  },
+  "dependencies": {
+    "@nestjs/bullmq": "^11.0.4",
+    "@nestjs/common": "^10.3.0",
+    "@nestjs/config": "^3.2.0",
+    "@nestjs/core": "^10.3.0",
+    "@nestjs/jwt": "^10.2.0",
+    "@nestjs/passport": "^10.0.3",
+    "@nestjs/platform-express": "^10.3.0",
+    "bullmq": "^5.69.3",
+    "class-transformer": "^0.5.1",
+    "class-validator": "^0.14.1",
+    "ioredis": "^5.9.3",
+    "passport": "^0.7.0",
+    "passport-jwt": "^4.0.1",
+    "reflect-metadata": "^0.2.1",
+    "rxjs": "^7.8.1"
+  },
+  "devDependencies": {
+    "@nestjs/cli": "^10.3.0",
+    "@nestjs/schematics": "^10.1.0",
+    "@types/express": "^4.17.21",
+    "@types/node": "^20.11.0",
+    "@types/passport-jwt": "^4.0.1",
+    "ts-loader": "^9.5.1",
+    "ts-node": "^10.9.2",
+    "tsconfig-paths": "^4.2.0",
+    "typescript": "^5.3.3"
+  }
+}

backend/src/app.module.ts

@@ -0,0 +1,21 @@
+import { Module } from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config';
+import { BullModule } from '@nestjs/bullmq';
+import { AuthModule } from './auth/auth.module';
+import { MarketsModule } from './markets/markets.module';
+
+@Module({
+  imports: [
+    ConfigModule.forRoot({ isGlobal: true }),
+    BullModule.forRoot({
+      connection: {
+        host: process.env.REDIS_HOST || '127.0.0.1',
+        port: parseInt(process.env.REDIS_PORT || '6379'),
+        maxRetriesPerRequest: null,
+      },
+    }),
+    AuthModule,
+    MarketsModule,
+  ],
+})
+export class AppModule {}

backend/src/auth/auth.controller.ts

@@ -0,0 +1,12 @@
+import { Controller, Post, Body } from '@nestjs/common';
+import { AuthService } from './auth.service';
+
+@Controller('auth')
+export class AuthController {
+  constructor(private readonly authService: AuthService) {}
+
+  @Post('login')
+  async login(@Body() body: { username: string; password: string }) {
+    return this.authService.login(body.username, body.password);
+  }
+}

backend/src/auth/auth.module.ts

@@ -0,0 +1,25 @@
+import { Module } from '@nestjs/common';
+import { JwtModule } from '@nestjs/jwt';
+import { PassportModule } from '@nestjs/passport';
+import { ConfigModule, ConfigService } from '@nestjs/config';
+import { AuthService } from './auth.service';
+import { AuthController } from './auth.controller';
+import { JwtStrategy } from './jwt.strategy';
+
+@Module({
+  imports: [
+    PassportModule.register({ defaultStrategy: 'jwt' }),
+    JwtModule.registerAsync({
+      imports: [ConfigModule],
+      inject: [ConfigService],
+      useFactory: (config: ConfigService) => ({
+        secret: config.get<string>('JWT_SECRET', 'wagerkit-jwt-secret-key-2024'),
+        signOptions: { expiresIn: '24h' },
+      }),
+    }),
+  ],
+  controllers: [AuthController],
+  providers: [AuthService, JwtStrategy],
+  exports: [AuthService, JwtModule],
+})
+export class AuthModule {}

backend/src/auth/auth.service.ts

@@ -0,0 +1,42 @@
+import { Injectable, UnauthorizedException } from '@nestjs/common';
+import { JwtService } from '@nestjs/jwt';
+
+interface User {
+  id: number;
+  username: string;
+  password: string;
+  name: string;
+}
+
+@Injectable()
+export class AuthService {
+  private readonly users: User[] = [
+    { id: 1, username: 'demo', password: 'wagerkit2024', name: 'Demo User' },
+    { id: 2, username: 'admin', password: 'admin123', name: 'Admin' },
+  ];
+
+  constructor(private readonly jwtService: JwtService) {}
+
+  async validateUser(username: string, password: string): Promise<Omit<User, 'password'> | null> {
+    const user = this.users.find(
+      (u) => u.username === username && u.password === password,
+    );
+    if (user) {
+      const { password: _, ...result } = user;
+      return result;
+    }
+    return null;
+  }
+
+  async login(username: string, password: string) {
+    const user = await this.validateUser(username, password);
+    if (!user) {
+      throw new UnauthorizedException('Invalid credentials');
+    }
+    const payload = { sub: user.id, username: user.username, name: user.name };
+    return {
+      access_token: this.jwtService.sign(payload),
+      user: { id: user.id, username: user.username, name: user.name },
+    };
+  }
+}

backend/src/auth/jwt-auth.guard.ts

@@ -0,0 +1,5 @@
+import { Injectable } from '@nestjs/common';
+import { AuthGuard } from '@nestjs/passport';
+
+@Injectable()
+export class JwtAuthGuard extends AuthGuard('jwt') {}

backend/src/auth/jwt.strategy.ts

@@ -0,0 +1,19 @@
+import { Injectable } from '@nestjs/common';
+import { PassportStrategy } from '@nestjs/passport';
+import { ExtractJwt, Strategy } from 'passport-jwt';
+import { ConfigService } from '@nestjs/config';
+
+@Injectable()
+export class JwtStrategy extends PassportStrategy(Strategy) {
+  constructor(private configService: ConfigService) {
+    super({
+      jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
+      ignoreExpiration: false,
+      secretOrKey: configService.get<string>('JWT_SECRET', 'wagerkit-jwt-secret-key-2024'),
+    });
+  }
+
+  async validate(payload: any) {
+    return { id: payload.sub, username: payload.username, name: payload.name };
+  }
+}

backend/src/main.ts

@@ -0,0 +1,14 @@
+import { NestFactory } from '@nestjs/core';
+import { AppModule } from './app.module';
+
+async function bootstrap() {
+  const app = await NestFactory.create(AppModule);
+  app.enableCors({
+    origin: 'http://localhost:3000',
+    credentials: true,
+  });
+  app.setGlobalPrefix('api');
+  await app.listen(3001);
+  console.log('WagerKit API running on http://localhost:3001');
+}
+bootstrap();

backend/src/markets/market-cache.service.ts

@@ -0,0 +1,40 @@
+import { Injectable, Logger } from '@nestjs/common';
+
+export interface CachedMarketData {
+  slug: string;
+  status: 'pending' | 'processing' | 'ready' | 'error';
+  data?: any;
+  updatedAt?: string;
+  error?: string;
+}
+
+@Injectable()
+export class MarketCacheService {
+  private readonly logger = new Logger(MarketCacheService.name);
+  private cache = new Map<string, CachedMarketData>();
+
+  setStatus(slug: string, status: CachedMarketData['status'], data?: any, error?: string) {
+    const entry: CachedMarketData = {
+      slug,
+      status,
+      data: data || this.cache.get(slug)?.data,
+      updatedAt: new Date().toISOString(),
+      error,
+    };
+    this.cache.set(slug, entry);
+    this.logger.log(`Cache [${slug}] → ${status}`);
+  }
+
+  get(slug: string): CachedMarketData | undefined {
+    return this.cache.get(slug);
+  }
+
+  getAll(): CachedMarketData[] {
+    return Array.from(this.cache.values());
+  }
+
+  isReady(slug: string): boolean {
+    const entry = this.cache.get(slug);
+    return entry?.status === 'ready';
+  }
+}

backend/src/markets/market.processor.ts

@@ -0,0 +1,61 @@
+import { Processor, WorkerHost } from '@nestjs/bullmq';
+import { Logger } from '@nestjs/common';
+import { Job } from 'bullmq';
+import { MarketsService } from './markets.service';
+import { MarketCacheService } from './market-cache.service';
+
+@Processor('market-processing')
+export class MarketProcessor extends WorkerHost {
+  private readonly logger = new Logger(MarketProcessor.name);
+
+  constructor(
+    private readonly marketsService: MarketsService,
+    private readonly cacheService: MarketCacheService,
+  ) {
+    super();
+  }
+
+  async process(job: Job<{ slug: string }>): Promise<any> {
+    const { slug } = job.data;
+    this.logger.log(`Processing market: ${slug} (Job ${job.id})`);
+
+    try {
+      this.cacheService.setStatus(slug, 'processing');
+
+      // Simulate heavy data fetching & integrity calculation
+      // In production this would call real APIs
+      await this.simulateWork(300);
+
+      // Generate market detail (this does the heavy computation)
+      const detail = this.marketsService.getMarketDetail(slug);
+
+      if (!detail) {
+        throw new Error(`Market ${slug} not found`);
+      }
+
+      // Calculate integrity score from the generated data
+      const computedScore = this.marketsService.calculateIntegrityScore(detail, detail.oddsHistory);
+
+      const enrichedDetail = {
+        ...detail,
+        integrityScore: computedScore,
+        processedAt: new Date().toISOString(),
+        jobId: job.id,
+      };
+
+      this.cacheService.setStatus(slug, 'ready', enrichedDetail);
+      this.logger.log(`✓ Market ${slug} processed successfully (Score: ${computedScore.overall})`);
+
+      return enrichedDetail;
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : 'Unknown error';
+      this.cacheService.setStatus(slug, 'error', undefined, msg);
+      this.logger.error(`✗ Market ${slug} processing failed: ${msg}`);
+      throw error;
+    }
+  }
+
+  private simulateWork(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+}

backend/src/markets/markets.controller.ts

@@ -0,0 +1,131 @@
+import {
+  Controller,
+  Get,
+  Post,
+  Param,
+  Res,
+  NotFoundException,
+} from '@nestjs/common';
+import { InjectQueue } from '@nestjs/bullmq';
+import { Queue } from 'bullmq';
+import { Response } from 'express';
+import { MarketsService } from './markets.service';
+import { MarketCacheService } from './market-cache.service';
+
+@Controller('markets')
+export class MarketsController {
+  constructor(
+    private readonly marketsService: MarketsService,
+    private readonly cacheService: MarketCacheService,
+    @InjectQueue('market-processing') private readonly marketQueue: Queue,
+  ) {}
+
+  @Get()
+  getMarkets() {
+    const markets = this.marketsService.getMarkets();
+    // Enrich with processing status
+    return markets.map((m) => {
+      const cached = this.cacheService.get(m.slug);
+      return {
+        ...m,
+        processingStatus: cached?.status || 'unknown',
+      };
+    });
+  }
+
+  @Get('jobs/status')
+  getJobsStatus() {
+    const all = this.cacheService.getAll();
+    return {
+      markets: all.map((c) => ({
+        slug: c.slug,
+        status: c.status,
+        updatedAt: c.updatedAt,
+        error: c.error,
+      })),
+      summary: {
+        total: all.length,
+        ready: all.filter((c) => c.status === 'ready').length,
+        processing: all.filter((c) => c.status === 'processing').length,
+        pending: all.filter((c) => c.status === 'pending').length,
+        error: all.filter((c) => c.status === 'error').length,
+      },
+    };
+  }
+
+  @Post(':slug/refresh')
+  async refreshMarket(@Param('slug') slug: string) {
+    const market = this.marketsService.getMarkets().find((m) => m.slug === slug);
+    if (!market) {
+      throw new NotFoundException('Market not found');
+    }
+    this.cacheService.setStatus(slug, 'pending');
+    await this.marketQueue.add(
+      'process-market',
+      { slug },
+      { removeOnComplete: 100, removeOnFail: 50 },
+    );
+    return { message: 'Market refresh queued', slug, status: 'pending' };
+  }
+
+  @Get(':slug')
+  getMarketDetail(@Param('slug') slug: string) {
+    // Return cached data if available (processed by BullMQ worker)
+    const cached = this.cacheService.get(slug);
+    if (cached?.status === 'ready' && cached.data) {
+      return {
+        ...cached.data,
+        fromCache: true,
+        processingStatus: 'ready',
+      };
+    }
+
+    // Fallback to on-demand generation if not yet cached
+    const market = this.marketsService.getMarketDetail(slug);
+    if (!market) {
+      throw new NotFoundException('Market not found');
+    }
+    return {
+      ...market,
+      fromCache: false,
+      processingStatus: cached?.status || 'not-queued',
+    };
+  }
+
+  @Get(':slug/export/odds-csv')
+  exportOddsCsv(@Param('slug') slug: string, @Res() res: Response) {
+    const csv = this.marketsService.getOddsHistoryCsv(slug);
+    if (!csv) {
+      throw new NotFoundException('Market not found');
+    }
+    res.setHeader('Content-Type', 'text/csv');
+    res.setHeader(
+      'Content-Disposition',
+      `attachment; filename=odds_history_${slug}.csv`,
+    );
+    res.send(csv);
+  }
+
+  @Get(':slug/export/integrity-csv')
+  exportIntegrityCsv(@Param('slug') slug: string, @Res() res: Response) {
+    const csv = this.marketsService.getIntegrityCsv(slug);
+    if (!csv) {
+      throw new NotFoundException('Market not found');
+    }
+    res.setHeader('Content-Type', 'text/csv');
+    res.setHeader(
+      'Content-Disposition',
+      `attachment; filename=integrity_${slug}.csv`,
+    );
+    res.send(csv);
+  }
+
+  @Get(':slug/export/dossier-json')
+  exportDossierJson(@Param('slug') slug: string) {
+    const dossier = this.marketsService.getDossierJson(slug);
+    if (!dossier) {
+      throw new NotFoundException('Market not found');
+    }
+    return dossier;
+  }
+}

backend/src/markets/markets.module.ts

@@ -0,0 +1,43 @@
+import { Module, OnModuleInit } from '@nestjs/common';
+import { BullModule, InjectQueue } from '@nestjs/bullmq';
+import { Queue } from 'bullmq';
+import { MarketsService } from './markets.service';
+import { MarketsController } from './markets.controller';
+import { MarketProcessor } from './market.processor';
+import { MarketCacheService } from './market-cache.service';
+
+@Module({
+  imports: [
+    BullModule.registerQueue({
+      name: 'market-processing',
+    }),
+  ],
+  controllers: [MarketsController],
+  providers: [MarketsService, MarketProcessor, MarketCacheService],
+})
+export class MarketsModule implements OnModuleInit {
+  constructor(
+    @InjectQueue('market-processing') private readonly marketQueue: Queue,
+    private readonly marketsService: MarketsService,
+    private readonly cacheService: MarketCacheService,
+  ) {}
+
+  async onModuleInit() {
+    // Pre-process all markets on startup so dashboard loads instantly
+    const markets = this.marketsService.getMarkets();
+    for (const market of markets) {
+      this.cacheService.setStatus(market.slug, 'pending');
+      await this.marketQueue.add(
+        'process-market',
+        { slug: market.slug },
+        {
+          removeOnComplete: 100,
+          removeOnFail: 50,
+          attempts: 3,
+          backoff: { type: 'exponential', delay: 1000 },
+        },
+      );
+    }
+    console.log(`[WagerKit] Queued ${markets.length} markets for background processing`);
+  }
+}

backend/src/markets/markets.service.ts

@@ -0,0 +1,396 @@
+import { Injectable } from '@nestjs/common';
+
+// WagerKit internal data aggregation service
+
+export interface MarketSource {
+  name: string;
+  type: 'regulated' | 'onchain';
+}
+
+export interface IntegrityScore {
+  overall: number;
+  marketClarity: number;
+  liquidityDepth: number;
+  crossSourceAgreement: number;
+  volatilitySanity: number;
+}
+
+export interface OddsDataPoint {
+  timestamp: string;
+  polymarket: number;
+  kalshi: number;
+  predictit: number;
+  wagerkit: number;
+}
+
+export interface MarketSummary {
+  slug: string;
+  title: string;
+  tag: string;
+  closesAt: string;
+}
+
+export interface SimulatedMetrics {
+  /** Simulated raw tick frequency (production: from ClickHouse odds_tick) */
+  ticksPerHour: number;
+  /** Simulated 24-h trading volume in $K (production: sum(volume) from odds_tick) */
+  dailyVolumeK: number;
+  /** Metadata quality / data-completeness factor 0-1 (production: DB metadata checks) */
+  dataCompleteness: number;
+}
+
+export interface MarketDetail extends MarketSummary {
+  description: string;
+  sources: MarketSource[];
+  integrityScore: IntegrityScore;
+  oddsHistory: OddsDataPoint[];
+  notes: string[];
+  resolutionCriteriaUrl: string;
+  question: string;
+  simulatedMetrics: SimulatedMetrics;
+}
+
+@Injectable()
+export class MarketsService {
+  private readonly marketsData: MarketDetail[] = [
+    {
+      slug: 'us_election_2024_winner',
+      title: 'US 2024 Presidential Election - Winner',
+      tag: 'election',
+      closesAt: '11/6/2024',
+      description: 'Who will win the 2024 United States presidential election? This market resolves to the candidate who wins the Electoral College majority.',
+      question: 'Who will win the 2024 United States presidential election?',
+      resolutionCriteriaUrl: 'https://wagerkit.xyz/resolution/us-election-2024',
+      sources: [
+        { name: 'PredictIt', type: 'regulated' },
+        { name: 'Kalshi', type: 'regulated' },
+        { name: 'Polymarket', type: 'onchain' },
+        { name: 'WagerKit', type: 'onchain' },
+      ],
+      integrityScore: {
+        overall: 84.0,
+        marketClarity: 88,
+        liquidityDepth: 82,
+        crossSourceAgreement: 85,
+        volatilitySanity: 81,
+      },
+      notes: ['Post-election convergence', 'Historical resolved market'],
+      simulatedMetrics: { ticksPerHour: 52, dailyVolumeK: 1958, dataCompleteness: 0.949 },
+      oddsHistory: [],
+    },
+    {
+      slug: 'btc_halving_2024',
+      title: 'BTC Halving 2024 - Price impact probability',
+      tag: 'crypto',
+      closesAt: '5/20/2024',
+      description: 'Will Bitcoin price exceed $80,000 within 90 days of the April 2024 halving event?',
+      question: 'Will Bitcoin price exceed $80,000 within 90 days of the April 2024 halving event?',
+      resolutionCriteriaUrl: 'https://wagerkit.xyz/resolution/btc-halving-2024',
+      sources: [
+        { name: 'PredictIt', type: 'regulated' },
+        { name: 'Kalshi', type: 'regulated' },
+        { name: 'Polymarket', type: 'onchain' },
+        { name: 'WagerKit', type: 'onchain' },
+      ],
+      integrityScore: {
+        overall: 90.0,
+        marketClarity: 92,
+        liquidityDepth: 88,
+        crossSourceAgreement: 91,
+        volatilitySanity: 89,
+      },
+      notes: ['Post-halving stability', 'Historical resolved market'],
+      simulatedMetrics: { ticksPerHour: 55, dailyVolumeK: 2200, dataCompleteness: 0.919 },
+      oddsHistory: [],
+    },
+    {
+      slug: 'us_cpi_yoy_nov_2025',
+      title: 'US CPI YoY - Nov 2025 print',
+      tag: 'macro',
+      closesAt: '12/18/2025',
+      description: 'Will the US CPI Year-over-Year figure for November 2025 come in above 3.0%?',
+      question: 'Will the US CPI Year-over-Year figure for November 2025 come in above 3.0%?',
+      resolutionCriteriaUrl: 'https://wagerkit.xyz/resolution/us-cpi-nov-2025',
+      sources: [
+        { name: 'PredictIt', type: 'regulated' },
+        { name: 'Kalshi', type: 'regulated' },
+        { name: 'Polymarket', type: 'onchain' },
+        { name: 'WagerKit', type: 'onchain' },
+      ],
+      integrityScore: {
+        overall: 73.0,
+        marketClarity: 76,
+        liquidityDepth: 71,
+        crossSourceAgreement: 74,
+        volatilitySanity: 71,
+      },
+      notes: ['Post-release convergence', 'Historical resolved market'],
+      simulatedMetrics: { ticksPerHour: 38, dailyVolumeK: 1855, dataCompleteness: 0.770 },
+      oddsHistory: [],
+    },
+  ];
+
+  /**
+   * Integrity Score Formula (mirrors production IntegrityWorker):
+   * Score = 100 × (0.40×C + 0.30×L + 0.20×A + 0.10×V)
+   *
+   * C = Market Clarity:  min(1, base × dataCompleteness)
+   *     base = 0.5*(hasUrl) + graduated_source_score + graduated_question_score
+   * L = Liquidity Depth:  0.40×frequencyScore + 0.40×volumeScore + 0.20×sourceScore
+   * A = Cross-Source Agreement: max(0, 1 − min(1, avgPairwiseRMSE / θ)),  θ = 0.10
+   * V = Volatility Sanity:  0.70×(1 − avgNormStdDev) + 0.30×spikeScore
+   */
+  calculateIntegrityScore(market: MarketDetail, oddsHistory: OddsDataPoint[]): IntegrityScore {
+    const metrics = market.simulatedMetrics;
+
+    // ── C: Market Clarity ──────────────────────────────────────────────
+    // Production: calculateClarity(market, sourceCount)
+    //   = min(1, 0.5*(hasUrl) + graduated_source + graduated_question) × dataCompleteness
+    let clarityBase = 0;
+    if (market.resolutionCriteriaUrl) clarityBase += 0.5;
+    // Graduated source score: 1→0 … 4+→0.30
+    clarityBase += Math.min(0.3, ((Math.min(market.sources.length, 4) - 1) / 3) * 0.3);
+    // Question specificity: graduated by length (20→0, 80+→0.20)
+    const qLen = market.question?.length || 0;
+    clarityBase += Math.min(0.2, Math.max(0, (qLen - 20) / 300));
+    // dataCompleteness from per-market simulated metrics (production: DB metadata quality)
+    const clarity = Math.min(1, clarityBase * metrics.dataCompleteness);
+
+    // ── L: Liquidity Depth ─────────────────────────────────────────────
+    // Production: 0.4×freq + 0.4×vol + 0.2×src  (real tick data from ClickHouse odds_tick)
+    // Uses per-market simulated tick metrics instead of chart-point density.
+    const frequencyScore = Math.min(1, metrics.ticksPerHour / 60);
+    const volumeScore = Math.min(1, metrics.dailyVolumeK / 2500);
+    const sourceScore = Math.min(1, market.sources.length / 5);
+    const liquidity = Math.max(0.1, Math.min(1,
+      0.4 * frequencyScore + 0.4 * volumeScore + 0.2 * sourceScore,
+    ));
+
+    // ── A: Cross-Source Agreement ──────────────────────────────────────
+    // Production: max(0, 1 − min(1, RMSE / θ)),  θ = 0.10
+    // Average pairwise RMSE across all source combinations.
+    const sourceKeys = ['polymarket', 'kalshi', 'predictit', 'wagerkit'] as const;
+    let agreement = 0.5;
+    if (oddsHistory.length > 0 && market.sources.length >= 2) {
+      let totalRmse = 0;
+      let pairCount = 0;
+      for (let i = 0; i < sourceKeys.length; i++) {
+        for (let j = i + 1; j < sourceKeys.length; j++) {
+          let sumSqDiff = 0;
+          for (const point of oddsHistory) {
+            sumSqDiff += Math.pow(point[sourceKeys[i]] - point[sourceKeys[j]], 2);
+          }
+          totalRmse += Math.sqrt(sumSqDiff / oddsHistory.length);
+          pairCount++;
+        }
+      }
+      const avgRmse = totalRmse / pairCount;
+      const theta = 0.1;
+      agreement = Math.max(0, 1 - Math.min(1, avgRmse / theta));
+    }
+
+    // ── V: Volatility Sanity ──────────────────────────────────────────
+    // Production: 0.70×(1 − normStdDev) + 0.30×spikeScore
+    // Per-source analysis (matching production per-mapping pattern).
+    let volatility = 0.5;
+    if (oddsHistory.length > 1) {
+      let totalNormStdDev = 0;
+      let totalSpikes = 0;
+      let totalTicks = 0;
+
+      for (const key of sourceKeys) {
+        const prices = oddsHistory.map((p) => p[key]);
+        const mean = prices.reduce((a, b) => a + b, 0) / prices.length;
+        const stdDev = Math.sqrt(
+          prices.reduce((sum, p) => sum + Math.pow(p - mean, 2), 0) / prices.length,
+        );
+        totalNormStdDev += Math.min(1, stdDev / 0.1);
+
+        // Spike detection: >10 % relative change between consecutive ticks
+        for (let i = 1; i < prices.length; i++) {
+          const relChange = Math.abs((prices[i] - prices[i - 1]) / prices[i - 1]);
+          if (relChange > 0.1) totalSpikes++;
+          totalTicks++;
+        }
+      }
+
+      const avgNormStdDev = totalNormStdDev / sourceKeys.length;
+      const spikeRate = totalTicks > 0 ? totalSpikes / totalTicks : 0;
+      const spikeScore = Math.max(0, 1 - spikeRate * 2);
+
+      volatility = 0.7 * (1 - avgNormStdDev) + 0.3 * spikeScore;
+      volatility = Math.max(0.1, Math.min(1, volatility));
+    }
+
+    // ── Overall: 100 × (0.40×C + 0.30×L + 0.20×A + 0.10×V) ──────────
+    const overall = 100 * (0.4 * clarity + 0.3 * liquidity + 0.2 * agreement + 0.1 * volatility);
+
+    return {
+      overall: Math.round(overall * 10) / 10,
+      marketClarity: Math.round(clarity * 100),
+      liquidityDepth: Math.round(liquidity * 100),
+      crossSourceAgreement: Math.round(agreement * 100),
+      volatilitySanity: Math.round(volatility * 100),
+    };
+  }
+
+  private generateOddsHistory(slug: string): OddsDataPoint[] {
+    const points: OddsDataPoint[] = [];
+    const now = new Date();
+
+    // Per-market odds config — trend/cosAmp control wave amplitude,
+    // vol controls random noise, offsets control per-source spread.
+    // Tighter params for resolved/post-event markets mirror production convergence.
+    const seeds: Record<string, {
+      base: number; trend: number; cosAmp: number;
+      vol: number; offsets: [number, number, number, number];
+    }> = {
+      us_election_2024_winner: {
+        base: 0.55, trend: 0.035, cosAmp: 0.017, vol: 0.008,
+        offsets: [0, 0.014, -0.011, 0.007],
+      },
+      btc_halving_2024: {
+        base: 0.72, trend: 0.02, cosAmp: 0.01, vol: 0.004,
+        offsets: [0, 0.009, -0.007, 0.004],
+      },
+      us_cpi_yoy_nov_2025: {
+        base: 0.62, trend: 0.055, cosAmp: 0.028, vol: 0.011,
+        offsets: [0, 0.024, -0.019, 0.014],
+      },
+    };
+
+    const config = seeds[slug] || {
+      base: 0.5, trend: 0.05, cosAmp: 0.02, vol: 0.008,
+      offsets: [0, 0.005, -0.003, 0.002] as [number, number, number, number],
+    };
+
+    // Deterministic pseudo-random based on slug hash
+    const hashCode = (s: string) => {
+      let h = 0;
+      for (let i = 0; i < s.length; i++) {
+        h = (Math.imul(31, h) + s.charCodeAt(i)) | 0;
+      }
+      return h;
+    };
+    let seed = Math.abs(hashCode(slug));
+    const pseudoRandom = () => {
+      seed = (seed * 16807 + 0) % 2147483647;
+      return (seed & 0xfffffff) / 0x10000000;
+    };
+
+    for (let i = 0; i < 96; i++) {
+      const time = new Date(now.getTime() - (95 - i) * 15 * 60 * 1000);
+      const t = i / 96;
+
+      // Base trend with wave patterns (cosAmp now per-market)
+      const base =
+        config.base +
+        config.trend * Math.sin(t * Math.PI * 2.5) +
+        config.cosAmp * Math.cos(t * Math.PI * 5);
+
+      // Per-source variation using configured offsets & noise
+      const polymarket = Math.max(0.01, Math.min(0.99,
+        base + config.offsets[0] + (pseudoRandom() - 0.5) * config.vol * 2,
+      ));
+      const kalshi = Math.max(0.01, Math.min(0.99,
+        base + config.offsets[1] + (pseudoRandom() - 0.5) * config.vol * 2,
+      ));
+      const predictit = Math.max(0.01, Math.min(0.99,
+        base + config.offsets[2] + (pseudoRandom() - 0.5) * config.vol * 2,
+      ));
+      const wk = Math.max(0.01, Math.min(0.99,
+        base + config.offsets[3] + (pseudoRandom() - 0.5) * config.vol * 2,
+      ));
+
+      points.push({
+        timestamp: time.toISOString(),
+        polymarket: Math.round(polymarket * 10000) / 10000,
+        kalshi: Math.round(kalshi * 10000) / 10000,
+        predictit: Math.round(predictit * 10000) / 10000,
+        wagerkit: Math.round(wk * 10000) / 10000,
+      });
+    }
+
+    return points;
+  }
+
+  getMarkets(): MarketSummary[] {
+    return this.marketsData.map(({ slug, title, tag, closesAt }) => ({
+      slug,
+      title,
+      tag,
+      closesAt,
+    }));
+  }
+
+  getMarketDetail(slug: string): MarketDetail | null {
+    const market = this.marketsData.find((m) => m.slug === slug);
+    if (!market) return null;
+
+    const oddsHistory = this.generateOddsHistory(slug);
+
+    // Use pre-configured scores for demo consistency
+    // In production, these would be calculated from real DOME API data:
+    // const computedScore = this.calculateIntegrityScore(market, oddsHistory);
+
+    return {
+      ...market,
+      oddsHistory,
+    };
+  }
+
+  getOddsHistoryCsv(slug: string): string | null {
+    const market = this.marketsData.find((m) => m.slug === slug);
+    if (!market) return null;
+
+    const oddsHistory = this.generateOddsHistory(slug);
+    const header = 'Timestamp,Polymarket,Kalshi,PredictIt,WagerKit\n';
+    const rows = oddsHistory
+      .map(
+        (p) =>
+          `${p.timestamp},${p.polymarket},${p.kalshi},${p.predictit},${p.wagerkit}`,
+      )
+      .join('\n');
+
+    return header + rows;
+  }
+
+  getIntegrityCsv(slug: string): string | null {
+    const market = this.marketsData.find((m) => m.slug === slug);
+    if (!market) return null;
+
+    const score = market.integrityScore;
+    const header = 'Metric,Value,Weight\n';
+    const rows = [
+      `Overall Score,${score.overall},100%`,
+      `Market Clarity,${score.marketClarity}%,40%`,
+      `Liquidity Depth,${score.liquidityDepth}%,30%`,
+      `Cross-Source Agreement,${score.crossSourceAgreement}%,20%`,
+      `Volatility Sanity,${score.volatilitySanity}%,10%`,
+    ].join('\n');
+
+    return header + rows;
+  }
+
+  getDossierJson(slug: string): object | null {
+    const detail = this.getMarketDetail(slug);
+    if (!detail) return null;
+
+    return {
+      generatedAt: new Date().toISOString(),
+      platform: 'WagerKit',
+      market: {
+        title: detail.title,
+        slug: detail.slug,
+        description: detail.description,
+        tag: detail.tag,
+        closesAt: detail.closesAt,
+        question: detail.question,
+      },
+      integrityScore: detail.integrityScore,
+      sources: detail.sources,
+      notes: detail.notes,
+      oddsHistory: detail.oddsHistory,
+    };
+  }
+}

backend/tsconfig.build.json

@@ -0,0 +1,4 @@
+{
+  "extends": "./tsconfig.json",
+  "exclude": ["node_modules", "test", "dist", "**/*spec.ts"]
+}

backend/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "declaration": true,
+    "removeComments": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "allowSyntheticDefaultImports": true,
+    "target": "ES2021",
+    "sourceMap": true,
+    "outDir": "./dist",
+    "baseUrl": "./",
+    "incremental": true,
+    "skipLibCheck": true,
+    "strictNullChecks": false,
+    "noImplicitAny": false,
+    "strictBindCallApply": false,
+    "forceConsistentCasingInFileNames": false,
+    "noFallthroughCasesInSwitch": false
+  }
+}

dev.bat

@@ -0,0 +1,20 @@
+@echo off
+echo Starting WagerKit...
+echo.
+echo Starting Backend (NestJS on port 3001)...
+start "WagerKit Backend" cmd /k "cd /d c:\demo\backend && npm run start:dev"
+timeout /t 3 /nobreak >nul
+
+echo Starting Frontend (Next.js on port 3000)...
+start "WagerKit Frontend" cmd /k "cd /d c:\demo\frontend && npm run dev"
+
+echo.
+echo ========================================
+echo WagerKit is starting up!
+echo.
+echo Backend:  http://localhost:3001/api
+echo Frontend: http://localhost:3000
+echo ========================================
+echo.
+echo Press any key to exit this window (servers will continue running)
+pause >nul

docker-compose.yml

@@ -0,0 +1,52 @@
+version: '3.8'
+
+services:
+  redis:
+    image: redis:7-alpine
+    container_name: wagerkit-redis
+    ports:
+      - "6379:6379"
+    volumes:
+      - redis-data:/data
+    command: redis-server --appendonly yes
+    healthcheck:
+      test: ["CMD", "redis-cli", "ping"]
+      interval: 10s
+      timeout: 3s
+      retries: 3
+
+  backend:
+    build:
+      context: ./backend
+      dockerfile: Dockerfile
+    container_name: wagerkit-backend
+    ports:
+      - "3001:3001"
+    environment:
+      - NODE_ENV=production
+      - PORT=3001
+      - REDIS_HOST=redis
+      - REDIS_PORT=6379
+      - DOME_API_KEY=${DOME_API_KEY:-your_api_key_here}
+    depends_on:
+      redis:
+        condition: service_healthy
+    command: node dist/main.js
+    restart: unless-stopped
+
+  frontend:
+    build:
+      context: ./frontend
+      dockerfile: Dockerfile
+    container_name: wagerkit-frontend
+    ports:
+      - "3000:3000"
+    environment:
+      - NODE_ENV=production
+      - NEXT_PUBLIC_API_URL=http://localhost:3001/api
+    depends_on:
+      - backend
+    restart: unless-stopped
+
+volumes:
+  redis-data:

frontend/.env.example

@@ -0,0 +1,6 @@
+# Frontend Environment Variables
+
+# API URL - Backend API endpoint
+# For local development: http://localhost:3001/api
+# For Docker/Production: /api (uses Next.js rewrites)
+NEXT_PUBLIC_API_URL=http://localhost:3001/api

frontend/Dockerfile

@@ -0,0 +1,32 @@
+# Frontend Dockerfile
+FROM node:20-alpine AS builder
+
+WORKDIR /app
+
+# Copy package files
+COPY package*.json ./
+
+# Install dependencies
+RUN npm ci
+
+# Copy source
+COPY . .
+
+# Build Next.js app
+RUN npm run build
+
+# Production runtime
+FROM node:20-alpine
+
+WORKDIR /app
+
+# Copy standalone build
+COPY --from=builder /app/.next/standalone ./
+COPY --from=builder /app/.next/static ./.next/static
+COPY --from=builder /app/public ./public
+
+# Expose port
+EXPOSE 3000
+
+# Start application
+CMD ["node", "server.js"]

frontend/next-env.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="next" />
+/// <reference types="next/image-types/global" />
+
+// NOTE: This file should not be edited
+// see https://nextjs.org/docs/basic-features/typescript for more information.

frontend/next.config.js

@@ -0,0 +1,18 @@
+/** @type {import('next').NextConfig} */
+const nextConfig = {
+  output: 'standalone',
+  async rewrites() {
+    // In production/Docker, proxy /api to backend on port 3001
+    if (process.env.NODE_ENV === 'production') {
+      return [
+        {
+          source: '/api/:path*',
+          destination: 'http://localhost:3001/api/:path*',
+        },
+      ];
+    }
+    return [];
+  },
+};
+
+module.exports = nextConfig;

frontend/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "wagerkit-frontend",
+  "version": "1.0.0",
+  "private": true,
+  "scripts": {
+    "dev": "next dev",
+    "build": "next build",
+    "start": "next start"
+  },
+  "dependencies": {
+    "next": "14.2.3",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "chart.js": "^4.4.1",
+    "react-chartjs-2": "^5.2.0",
+    "jspdf": "^2.5.1",
+    "jspdf-autotable": "^3.8.2"
+  },
+  "devDependencies": {
+    "typescript": "^5.4.0",
+    "@types/react": "^18.3.0",
+    "@types/react-dom": "^18.3.0",
+    "@types/node": "^20.11.0",
+    "tailwindcss": "^3.4.1",
+    "postcss": "^8.4.35",
+    "autoprefixer": "^10.4.17"
+  }
+}

frontend/postcss.config.js

@@ -0,0 +1,6 @@
+module.exports = {
+  plugins: {
+    tailwindcss: {},
+    autoprefixer: {},
+  },
+};

frontend/src/app/dashboard/page.tsx

@@ -0,0 +1,139 @@
+'use client';
+
+import { useEffect, useState } from 'react';
+import { useRouter } from 'next/navigation';
+import Navbar from '@/components/Navbar';
+import { getMarkets } from '@/lib/api';
+
+interface MarketSummary {
+  slug: string;
+  title: string;
+  tag: string;
+  closesAt: string;
+  processingStatus?: 'pending' | 'processing' | 'ready' | 'error' | 'unknown';
+}
+
+export default function DashboardPage() {
+  const router = useRouter();
+  const [markets, setMarkets] = useState<MarketSummary[]>([]);
+  const [loading, setLoading] = useState(true);
+
+  useEffect(() => {
+    getMarkets()
+      .then(setMarkets)
+      .catch(() => {})
+      .finally(() => setLoading(false));
+  }, []);
+
+  return (
+    <div className="page-gradient min-h-screen">
+      <Navbar />
+
+      <main className="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8 py-10">
+        {/* Header */}
+        <div className="mb-10">
+          <h1 className="text-3xl font-bold text-white mb-2">Markets</h1>
+          <p className="text-wk-muted">
+            Monitor prediction market integrity across multiple sources
+          </p>
+        </div>
+
+        {loading ? (
+          <div className="flex items-center justify-center py-20">
+            <svg className="animate-spin h-8 w-8 text-purple-500" viewBox="0 0 24 24">
+              <circle
+                className="opacity-25"
+                cx="12"
+                cy="12"
+                r="10"
+                stroke="currentColor"
+                strokeWidth="4"
+                fill="none"
+              />
+              <path
+                className="opacity-75"
+                fill="currentColor"
+                d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4z"
+              />
+            </svg>
+          </div>
+        ) : (
+          <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-6">
+            {markets.map((market) => (
+              <div
+                key={market.slug}
+                onClick={() => router.push(`/market/${market.slug}`)}
+                className="card hover:border-purple-500/30 transition-all duration-300 flex flex-col cursor-pointer"
+              >
+                {/* Card Header */}
+                <div className="flex items-start justify-between mb-4">
+                  <h3 className="text-lg font-semibold text-white leading-snug pr-4">
+                    {market.title}
+                  </h3>
+                  <div className="flex-shrink-0 w-9 h-9 rounded-lg bg-white/5 border border-wk-border flex items-center justify-center">
+                    <svg
+                      width="16"
+                      height="16"
+                      viewBox="0 0 24 24"
+                      fill="none"
+                      stroke="#9ca3af"
+                      strokeWidth="2"
+                    >
+                      <polyline points="22,7 13.5,15.5 8.5,10.5 2,17" />
+                      <polyline points="16,7 22,7 22,13" />
+                    </svg>
+                  </div>
+                </div>
+
+                {/* Tag + Status */}
+                <div className="mb-4 flex items-center gap-2">
+                  <span className="tag-pill">{market.tag}</span>
+                  {market.processingStatus === 'ready' && (
+                    <span className="inline-flex items-center gap-1 px-2 py-0.5 rounded-full text-xs bg-green-900/40 text-green-400 border border-green-800/50">
+                      <span className="w-1.5 h-1.5 rounded-full bg-green-400"></span>
+                      Ready
+                    </span>
+                  )}
+                  {market.processingStatus === 'processing' && (
+                    <span className="inline-flex items-center gap-1 px-2 py-0.5 rounded-full text-xs bg-blue-900/40 text-blue-400 border border-blue-800/50">
+                      <svg className="animate-spin h-3 w-3" viewBox="0 0 24 24">
+                        <circle className="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" strokeWidth="4" fill="none" />
+                        <path className="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4z" />
+                      </svg>
+                      Processing
+                    </span>
+                  )}
+                  {market.processingStatus === 'pending' && (
+                    <span className="inline-flex items-center gap-1 px-2 py-0.5 rounded-full text-xs bg-yellow-900/40 text-yellow-400 border border-yellow-800/50">
+                      <span className="w-1.5 h-1.5 rounded-full bg-yellow-400 animate-pulse"></span>
+                      Queued
+                    </span>
+                  )}
+                </div>
+
+                {/* Divider */}
+                <div className="border-t border-wk-border my-3" />
+
+                {/* Close Date */}
+                <div className="flex items-center gap-2 text-wk-muted text-sm mb-5">
+                  <svg
+                    width="14"
+                    height="14"
+                    viewBox="0 0 24 24"
+                    fill="none"
+                    stroke="currentColor"
+                    strokeWidth="2"
+                  >
+                    <circle cx="12" cy="12" r="10" />
+                    <polyline points="12,6 12,12 16,14" />
+                  </svg>
+                  Closes: {market.closesAt}
+                </div>
+              </div>
+            ))}
+          </div>
+        )}
+      </main>
+    </div>
+  );
+}

frontend/src/app/globals.css

@@ -0,0 +1,98 @@
+@tailwind base;
+@tailwind components;
+@tailwind utilities;
+
+:root {
+  --bg-primary: #080810;
+  --bg-card: #12121e;
+  --border-color: #1e1e30;
+}
+
+body {
+  background-color: var(--bg-primary);
+  color: #ffffff;
+  min-height: 100vh;
+}
+
+/* Purple/blue gradient glow at top */
+.page-gradient {
+  background:
+    radial-gradient(ellipse at 20% -10%, rgba(107, 33, 168, 0.35) 0%, transparent 50%),
+    radial-gradient(ellipse at 80% -10%, rgba(59, 130, 246, 0.25) 0%, transparent 45%),
+    var(--bg-primary);
+  min-height: 100vh;
+}
+
+.card {
+  background: var(--bg-card);
+  border: 1px solid var(--border-color);
+  border-radius: 12px;
+  padding: 24px;
+}
+
+/* Custom scrollbar */
+::-webkit-scrollbar {
+  width: 6px;
+}
+::-webkit-scrollbar-track {
+  background: var(--bg-primary);
+}
+::-webkit-scrollbar-thumb {
+  background: #2a2a40;
+  border-radius: 3px;
+}
+
+/* Button styles */
+.btn-primary {
+  background: linear-gradient(135deg, #6b21a8, #3b82f6);
+  color: white;
+  padding: 10px 24px;
+  border-radius: 8px;
+  font-weight: 500;
+  transition: opacity 0.2s;
+}
+.btn-primary:hover {
+  opacity: 0.9;
+}
+
+.btn-outline {
+  background: transparent;
+  border: 1px solid var(--border-color);
+  color: #9ca3af;
+  padding: 8px 16px;
+  border-radius: 8px;
+  font-weight: 500;
+  transition: all 0.2s;
+}
+.btn-outline:hover {
+  border-color: #3b82f6;
+  color: white;
+}
+
+/* Tag pills */
+.tag-pill {
+  display: inline-block;
+  padding: 4px 14px;
+  border-radius: 20px;
+  font-size: 13px;
+  border: 1px solid #2a2a40;
+  background: rgba(255, 255, 255, 0.05);
+  color: #d1d5db;
+}
+
+/* Note tags */
+.note-tag {
+  display: inline-block;
+  padding: 6px 14px;
+  border-radius: 6px;
+  font-size: 13px;
+  font-weight: 500;
+}
+.note-tag-green {
+  background: #065f46;
+  color: #6ee7b7;
+}
+.note-tag-blue {
+  background: #1e3a5f;
+  color: #93c5fd;
+}

frontend/src/app/layout.tsx

@@ -0,0 +1,19 @@
+import type { Metadata } from 'next';
+import './globals.css';
+
+export const metadata: Metadata = {
+  title: 'WagerKit - Market Intelligence Platform',
+  description: 'Advanced prediction market analysis and integrity scoring',
+};
+
+export default function RootLayout({
+  children,
+}: {
+  children: React.ReactNode;
+}) {
+  return (
+    <html lang="en">
+      <body className="antialiased">{children}</body>
+    </html>
+  );
+}

frontend/src/app/login/page.tsx

@@ -0,0 +1,19 @@
+'use client';
+
+import { useEffect } from 'react';
+import { useRouter } from 'next/navigation';
+
+export default function LoginPage() {
+  const router = useRouter();
+
+  useEffect(() => {
+    // No authentication needed - redirect to dashboard
+    router.replace('/dashboard');
+  }, [router]);
+
+  return (
+    <div className="page-gradient flex items-center justify-center min-h-screen">
+      <div className="animate-pulse text-wk-muted text-lg">Redirecting...</div>
+    </div>
+  );
+}

frontend/src/app/market/[slug]/page.tsx

@@ -0,0 +1,576 @@
+'use client';
+
+import { useEffect, useState } from 'react';
+import { useParams, useRouter } from 'next/navigation';
+import Navbar from '@/components/Navbar';
+import {
+  getMarketDetail,
+  exportOddsCsv,
+  exportIntegrityCsv,
+  exportDossierJson,
+} from '@/lib/api';
+import {
+  Chart as ChartJS,
+  CategoryScale,
+  LinearScale,
+  PointElement,
+  LineElement,
+  Title,
+  Tooltip,
+  Legend,
+  Filler,
+} from 'chart.js';
+import { Line } from 'react-chartjs-2';
+
+ChartJS.register(
+  CategoryScale,
+  LinearScale,
+  PointElement,
+  LineElement,
+  Title,
+  Tooltip,
+  Legend,
+  Filler
+);
+
+interface MarketDetail {
+  slug: string;
+  title: string;
+  tag: string;
+  closesAt: string;
+  description: string;
+  sources: { name: string; type: string }[];
+  integrityScore: {
+    overall: number;
+    marketClarity: number;
+    liquidityDepth: number;
+    crossSourceAgreement: number;
+    volatilitySanity: number;
+  };
+  oddsHistory: {
+    timestamp: string;
+    polymarket: number;
+    kalshi: number;
+    predictit: number;
+    wagerkit: number;
+  }[];
+  notes: string[];
+}
+
+function downloadFile(content: string, filename: string, type: string) {
+  const blob = new Blob([content], { type });
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement('a');
+  a.href = url;
+  a.download = filename;
+  document.body.appendChild(a);
+  a.click();
+  document.body.removeChild(a);
+  URL.revokeObjectURL(url);
+}
+
+function getScoreColor(score: number): string {
+  if (score >= 80) return 'text-green-400';
+  if (score >= 60) return 'text-blue-400';
+  if (score >= 40) return 'text-yellow-400';
+  if (score >= 20) return 'text-orange-400';
+  return 'text-red-400';
+}
+
+function getScoreLabel(score: number): string {
+  if (score >= 80) return 'Highly Reliable';
+  if (score >= 60) return 'Stable';
+  if (score >= 40) return 'Caution';
+  if (score >= 20) return 'High Risk';
+  return 'Critical';
+}
+
+export default function MarketDetailPage() {
+  const params = useParams();
+  const router = useRouter();
+  const slug = params.slug as string;
+
+  const [market, setMarket] = useState<MarketDetail | null>(null);
+  const [loading, setLoading] = useState(true);
+
+  useEffect(() => {
+    if (slug) {
+      getMarketDetail(slug)
+        .then(setMarket)
+        .catch(() => {})
+        .finally(() => setLoading(false));
+    }
+  }, [slug]);
+
+  const handleExportOddsCsv = async () => {
+    const csv = await exportOddsCsv(slug);
+    downloadFile(csv, `odds_history_${slug}.csv`, 'text/csv');
+  };
+
+  const handleExportIntegrityCsv = async () => {
+    const csv = await exportIntegrityCsv(slug);
+    downloadFile(csv, `integrity_${slug}.csv`, 'text/csv');
+  };
+
+  const handleExportDossierJson = async () => {
+    const json = await exportDossierJson(slug);
+    downloadFile(JSON.stringify(json, null, 2), `dossier_${slug}.json`, 'application/json');
+  };
+
+  const handleExportDossierPdf = async () => {
+    if (!market) return;
+
+    // Dynamic import for jspdf
+    const { default: jsPDF } = await import('jspdf');
+    const autoTableModule = await import('jspdf-autotable');
+
+    const doc = new jsPDF();
+    const pageWidth = doc.internal.pageSize.getWidth();
+
+    // Title
+    doc.setFontSize(24);
+    doc.setTextColor(107, 33, 168);
+    doc.text('WagerKit Dossier', 20, 25);
+
+    // Subtitle
+    doc.setFontSize(10);
+    doc.setTextColor(150, 150, 150);
+    doc.text(`Generated: ${new Date().toLocaleString()}`, 20, 33);
+
+    // Horizontal line
+    doc.setDrawColor(200, 200, 200);
+    doc.line(20, 37, pageWidth - 20, 37);
+
+    // Market Title
+    doc.setFontSize(16);
+    doc.setTextColor(30, 30, 30);
+    doc.text(market.title, 20, 48);
+
+    // Market Info
+    doc.setFontSize(10);
+    doc.setTextColor(100, 100, 100);
+    doc.text(`Tag: ${market.tag}  |  Closes: ${market.closesAt}`, 20, 56);
+    doc.text(`Description: ${market.description}`, 20, 63, { maxWidth: pageWidth - 40 });
+
+    // Integrity Score Section
+    doc.setFontSize(14);
+    doc.setTextColor(30, 30, 30);
+    doc.text('Integrity Score', 20, 80);
+
+    // Overall Score
+    const scoreColor = market.integrityScore.overall >= 80 ? [34, 197, 94] :
+                       market.integrityScore.overall >= 60 ? [59, 130, 246] :
+                       market.integrityScore.overall >= 40 ? [234, 179, 8] : [239, 68, 68];
+    doc.setFontSize(28);
+    doc.setTextColor(scoreColor[0], scoreColor[1], scoreColor[2]);
+    doc.text(`${market.integrityScore.overall}`, pageWidth - 20, 80, { align: 'right' });
+
+    doc.setFontSize(8);
+    doc.setTextColor(150, 150, 150);
+    doc.text(getScoreLabel(market.integrityScore.overall), pageWidth - 20, 86, { align: 'right' });
+
+    // Score Components Table
+    const scoreData = [
+      ['Market Clarity', `${market.integrityScore.marketClarity}%`, '40%'],
+      ['Liquidity Depth', `${market.integrityScore.liquidityDepth}%`, '30%'],
+      ['Cross-Source Agreement', `${market.integrityScore.crossSourceAgreement}%`, '20%'],
+      ['Volatility Sanity', `${market.integrityScore.volatilitySanity}%`, '10%'],
+    ];
+
+    (doc as any).autoTable({
+      startY: 92,
+      head: [['Component', 'Score', 'Weight']],
+      body: scoreData,
+      theme: 'grid',
+      headStyles: { fillColor: [107, 33, 168], textColor: 255, fontSize: 9 },
+      bodyStyles: { fontSize: 9 },
+      margin: { left: 20, right: 20 },
+    });
+
+    // Data Sources
+    const sourcesY = (doc as any).lastAutoTable.finalY + 15;
+    doc.setFontSize(14);
+    doc.setTextColor(30, 30, 30);
+    doc.text('Data Sources', 20, sourcesY);
+
+    const sourcesData = market.sources.map(s => [s.name, s.type]);
+    (doc as any).autoTable({
+      startY: sourcesY + 5,
+      head: [['Source', 'Type']],
+      body: sourcesData,
+      theme: 'grid',
+      headStyles: { fillColor: [107, 33, 168], textColor: 255, fontSize: 9 },
+      bodyStyles: { fontSize: 9 },
+      margin: { left: 20, right: 20 },
+    });
+
+    // Notes
+    const notesY = (doc as any).lastAutoTable.finalY + 15;
+    doc.setFontSize(14);
+    doc.setTextColor(30, 30, 30);
+    doc.text('Notes', 20, notesY);
+    doc.setFontSize(10);
+    doc.setTextColor(100, 100, 100);
+    market.notes.forEach((note, i) => {
+      doc.text(`• ${note}`, 25, notesY + 8 + i * 7);
+    });
+
+    // Footer
+    const footerY = doc.internal.pageSize.getHeight() - 15;
+    doc.setFontSize(8);
+    doc.setTextColor(180, 180, 180);
+    doc.text('WagerKit - Market Intelligence Platform', 20, footerY);
+    doc.text('Confidential', pageWidth - 20, footerY, { align: 'right' });
+
+    doc.save(`dossier_${slug}.pdf`);
+  };
+
+  if (loading) {
+    return (
+      <div className="page-gradient min-h-screen">
+        <Navbar />
+        <div className="flex items-center justify-center py-32">
+          <svg className="animate-spin h-8 w-8 text-purple-500" viewBox="0 0 24 24">
+            <circle className="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" strokeWidth="4" fill="none" />
+            <path className="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4z" />
+          </svg>
+        </div>
+      </div>
+    );
+  }
+
+  if (!market) {
+    return (
+      <div className="page-gradient min-h-screen">
+        <Navbar />
+        <div className="max-w-7xl mx-auto px-4 py-20 text-center">
+          <h2 className="text-2xl font-bold text-white mb-4">Market Not Found</h2>
+          <button onClick={() => router.push('/dashboard')} className="btn-primary">
+            Back to Dashboard
+          </button>
+        </div>
+      </div>
+    );
+  }
+
+  // Chart data
+  const chartLabels = market.oddsHistory.map((p) => {
+    const d = new Date(p.timestamp);
+    return d.toLocaleTimeString('en-US', {
+      hour: 'numeric',
+      minute: '2-digit',
+      hour12: true,
+    });
+  });
+
+  // Only show every 8th label to avoid overcrowding
+  const sparseLabels = chartLabels.map((label, i) => (i % 8 === 0 ? label : ''));
+
+  const chartData = {
+    labels: sparseLabels,
+    datasets: [
+      {
+        label: 'Polymarket',
+        data: market.oddsHistory.map((p) => p.polymarket * 100),
+        borderColor: '#ffffff',
+        backgroundColor: 'rgba(255,255,255,0.05)',
+        borderWidth: 2,
+        pointRadius: 0,
+        pointHoverRadius: 4,
+        tension: 0.3,
+      },
+      {
+        label: 'Kalshi',
+        data: market.oddsHistory.map((p) => p.kalshi * 100),
+        borderColor: '#3b82f6',
+        backgroundColor: 'rgba(59,130,246,0.05)',
+        borderWidth: 2,
+        pointRadius: 0,
+        pointHoverRadius: 4,
+        tension: 0.3,
+      },
+      {
+        label: 'PredictIt',
+        data: market.oddsHistory.map((p) => p.predictit * 100),
+        borderColor: '#22c55e',
+        backgroundColor: 'rgba(34,197,94,0.05)',
+        borderWidth: 2,
+        pointRadius: 0,
+        pointHoverRadius: 4,
+        tension: 0.3,
+      },
+      {
+        label: 'WagerKit',
+        data: market.oddsHistory.map((p) => p.wagerkit * 100),
+        borderColor: '#f59e0b',
+        backgroundColor: 'rgba(245,158,11,0.05)',
+        borderWidth: 2,
+        pointRadius: 0,
+        pointHoverRadius: 4,
+        tension: 0.3,
+      },
+    ],
+  };
+
+  const chartOptions = {
+    responsive: true,
+    maintainAspectRatio: false,
+    interaction: {
+      mode: 'index' as const,
+      intersect: false,
+    },
+    plugins: {
+      legend: {
+        display: true,
+        position: 'bottom' as const,
+        labels: {
+          color: '#9ca3af',
+          usePointStyle: true,
+          pointStyle: 'circle',
+          padding: 20,
+          font: { size: 12 },
+        },
+      },
+      tooltip: {
+        backgroundColor: '#1e1e30',
+        borderColor: '#2a2a40',
+        borderWidth: 1,
+        titleColor: '#fff',
+        bodyColor: '#9ca3af',
+        padding: 12,
+        callbacks: {
+          label: (ctx: any) => `${ctx.dataset.label}: ${ctx.parsed.y.toFixed(2)}%`,
+        },
+      },
+    },
+    scales: {
+      x: {
+        grid: {
+          color: 'rgba(255,255,255,0.05)',
+        },
+        ticks: {
+          color: '#6b7280',
+          font: { size: 10 },
+          maxRotation: 45,
+        },
+      },
+      y: {
+        grid: {
+          color: 'rgba(255,255,255,0.05)',
+        },
+        ticks: {
+          color: '#6b7280',
+          font: { size: 10 },
+          callback: (value: any) => `${value}%`,
+        },
+      },
+    },
+  };
+
+  const score = market.integrityScore;
+
+  return (
+    <div className="page-gradient min-h-screen">
+      <Navbar />
+
+      <main className="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8 py-8">
+        {/* Back Button */}
+        <button
+          onClick={() => router.push('/dashboard')}
+          className="flex items-center gap-2 text-wk-muted hover:text-white transition-colors mb-6"
+        >
+          <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+            <polyline points="15,18 9,12 15,6" />
+          </svg>
+          Back
+        </button>
+
+        {/* Market Title */}
+        <h1 className="text-2xl md:text-3xl font-bold text-white mb-8">
+          {market.title}
+        </h1>
+
+        {/* ============= INTEGRITY SCORE CARD ============= */}
+        <div className="card mb-6">
+          <div className="flex items-start justify-between mb-6">
+            <div>
+              <div className="flex items-center gap-2 mb-1">
+                <span className="text-lg">💎</span>
+                <h2 className="text-xl font-semibold text-white">Integrity Score</h2>
+              </div>
+              <p className="text-sm text-wk-muted">
+                Multi-factor market integrity analysis
+              </p>
+            </div>
+            <div className="text-right">
+              <div className={`text-5xl font-bold ${getScoreColor(score.overall)}`}>
+                {score.overall.toFixed(1)}
+              </div>
+            </div>
+          </div>
+
+          {/* Sub-scores */}
+          <div className="grid grid-cols-2 md:grid-cols-4 gap-6 mb-6">
+            {[
+              { label: 'Market Clarity', value: score.marketClarity },
+              { label: 'Liquidity Depth', value: score.liquidityDepth },
+              { label: 'Cross-Source Agreement', value: score.crossSourceAgreement },
+              { label: 'Volatility Sanity', value: score.volatilitySanity },
+            ].map((item) => (
+              <div key={item.label}>
+                <p className="text-sm text-wk-muted mb-1">{item.label}</p>
+                <p className="text-2xl font-bold text-white">{item.value}%</p>
+              </div>
+            ))}
+          </div>
+
+          {/* Notes */}
+          <div>
+            <h3 className="text-sm font-semibold text-white mb-3">Notes</h3>
+            <div className="flex flex-wrap gap-2">
+              {market.notes.map((note, i) => (
+                <span
+                  key={i}
+                  className={i % 2 === 0 ? 'note-tag note-tag-green' : 'note-tag note-tag-blue'}
+                >
+                  {note}
+                </span>
+              ))}
+            </div>
+          </div>
+        </div>
+
+        {/* ============= ODDS HISTORY CHART ============= */}
+        <div className="card mb-6">
+          <div className="flex items-start justify-between mb-4">
+            <div>
+              <h2 className="text-xl font-semibold text-white mb-1">Odds History</h2>
+              <p className="text-sm text-wk-muted">
+                Historical odds trends over the last 24 hours
+              </p>
+            </div>
+            <button
+              onClick={handleExportOddsCsv}
+              className="btn-outline text-sm flex items-center gap-2"
+            >
+              <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+                <path d="M21 15v4a2 2 0 01-2 2H5a2 2 0 01-2-2v-4" />
+                <polyline points="7,10 12,15 17,10" />
+                <line x1="12" y1="15" x2="12" y2="3" />
+              </svg>
+              Export CSV
+            </button>
+          </div>
+
+          <div className="h-80">
+            <Line data={chartData} options={chartOptions} />
+          </div>
+        </div>
+
+        {/* ============= LATEST ODDS ============= */}
+        <div className="card mb-6">
+          <h2 className="text-xl font-semibold text-white mb-1">Latest Odds</h2>
+          <p className="text-sm text-wk-muted mb-6">
+            Real-time odds from all sources
+          </p>
+
+          <div className="flex flex-col items-center justify-center py-10 text-center">
+            <svg
+              width="40"
+              height="40"
+              viewBox="0 0 24 24"
+              fill="none"
+              stroke="#4b5563"
+              strokeWidth="1.5"
+              className="mb-3"
+            >
+              <circle cx="12" cy="12" r="10" />
+              <polyline points="12,6 12,12 16,14" />
+            </svg>
+            <p className="text-wk-muted font-medium mb-1">No Recent Odds</p>
+            <p className="text-sm text-gray-600">
+              We haven&apos;t received any recent price ticks from the source feeds.
+            </p>
+          </div>
+        </div>
+
+        {/* ============= DATA SOURCES ============= */}
+        <div className="card mb-6" style={{
+          background: 'linear-gradient(180deg, #12121e 0%, #0d0d18 50%, #12121e 100%)',
+        }}>
+          <h2 className="text-xl font-semibold text-white mb-1">Data Sources</h2>
+          <p className="text-sm text-wk-muted mb-6">
+            Sources providing odds for this market
+          </p>
+
+          <div className="grid grid-cols-1 md:grid-cols-2 gap-4">
+            {market.sources.map((source) => (
+              <div
+                key={source.name}
+                className="border border-wk-border rounded-xl p-5 flex items-center justify-between bg-wk-card/50"
+              >
+                <div>
+                  <p className="text-white font-semibold">{source.name}</p>
+                  <p className="text-sm text-wk-muted">{source.type}</p>
+                </div>
+                <span
+                  className={`text-xs px-3 py-1 rounded-full font-medium ${
+                    source.type === 'regulated'
+                      ? 'bg-gray-800 text-gray-300 border border-gray-600'
+                      : 'bg-purple-900/50 text-purple-300 border border-purple-700'
+                  }`}
+                >
+                  {source.type}
+                </span>
+              </div>
+            ))}
+          </div>
+        </div>
+
+        {/* ============= ACTIONS ============= */}
+        <div className="card mb-10">
+          <h2 className="text-xl font-semibold text-white mb-6">Actions</h2>
+
+          <div className="flex flex-wrap gap-4">
+            <button
+              onClick={handleExportDossierPdf}
+              className="btn-outline flex items-center gap-2 px-5 py-3"
+            >
+              <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+                <path d="M21 15v4a2 2 0 01-2 2H5a2 2 0 01-2-2v-4" />
+                <polyline points="7,10 12,15 17,10" />
+                <line x1="12" y1="15" x2="12" y2="3" />
+              </svg>
+              Download Dossier (PDF)
+            </button>
+
+            <button
+              onClick={handleExportDossierJson}
+              className="btn-outline flex items-center gap-2 px-5 py-3"
+            >
+              <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+                <path d="M21 15v4a2 2 0 01-2 2H5a2 2 0 01-2-2v-4" />
+                <polyline points="7,10 12,15 17,10" />
+                <line x1="12" y1="15" x2="12" y2="3" />
+              </svg>
+              Download Dossier (JSON)
+            </button>
+
+            <button
+              onClick={handleExportIntegrityCsv}
+              className="btn-outline flex items-center gap-2 px-5 py-3"
+            >
+              <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+                <rect x="3" y="3" width="18" height="18" rx="2" />
+                <line x1="3" y1="9" x2="21" y2="9" />
+                <line x1="3" y1="15" x2="21" y2="15" />
+                <line x1="9" y1="3" x2="9" y2="21" />
+              </svg>
+              Export Integrity CSV
+            </button>
+          </div>
+        </div>
+      </main>
+    </div>
+  );
+}

frontend/src/app/page.tsx

@@ -0,0 +1,18 @@
+'use client';
+
+import { useEffect } from 'react';
+import { useRouter } from 'next/navigation';
+
+export default function Home() {
+  const router = useRouter();
+
+  useEffect(() => {
+    router.replace('/dashboard');
+  }, [router]);
+
+  return (
+    <div className="page-gradient flex items-center justify-center min-h-screen">
+      <div className="animate-pulse text-wk-muted text-lg">Loading...</div>
+    </div>
+  );
+}

frontend/src/components/Navbar.tsx

@@ -0,0 +1,93 @@
+'use client';
+
+import Link from 'next/link';
+import { usePathname } from 'next/navigation';
+import { useState } from 'react';
+
+export default function Navbar() {
+  const pathname = usePathname();
+  const [user] = useState({ username: 'demo' });
+
+  const navItems = [
+    { label: 'Dashboard', href: '/dashboard' },
+    { label: 'Markets', href: '/dashboard' },
+    { label: 'Alerts', href: '#' },
+    { label: 'Metrics', href: '#' },
+    { label: 'Paper Mode', href: '#' },
+    { label: 'API', href: '#' },
+  ];
+
+  return (
+    <nav className="border-b border-wk-border bg-wk-bg/80 backdrop-blur-md sticky top-0 z-50">
+      <div className="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8">
+        <div className="flex items-center justify-between h-16">
+          {/* Logo */}
+          <Link href="/dashboard" className="flex items-center gap-2">
+            <svg
+              width="28"
+              height="28"
+              viewBox="0 0 32 32"
+              fill="none"
+              className="text-wk-accent"
+            >
+              <path
+                d="M16 2L4 8v16l12 6 12-6V8L16 2z"
+                stroke="currentColor"
+                strokeWidth="2"
+                fill="none"
+              />
+              <path
+                d="M16 10l-6 3v6l6 3 6-3v-6l-6-3z"
+                fill="currentColor"
+                opacity="0.6"
+              />
+            </svg>
+            <span className="text-xl font-bold text-white">WagerKit</span>
+          </Link>
+
+          {/* Nav Items */}
+          <div className="hidden md:flex items-center gap-1">
+            {navItems.map((item) => (
+              <Link
+                key={item.label}
+                href={item.href}
+                className={`px-3 py-2 rounded-lg text-sm transition-colors ${
+                  pathname === item.href
+                    ? 'text-white bg-white/10'
+                    : 'text-wk-muted hover:text-white hover:bg-white/5'
+                }`}
+              >
+                {item.label}
+              </Link>
+            ))}
+          </div>
+
+          {/* User Menu */}
+          <div className="flex items-center gap-3">
+            {user && (
+              <div className="flex items-center gap-2">
+                <div className="w-8 h-8 rounded-full bg-gradient-to-br from-wk-accent to-wk-blue flex items-center justify-center text-sm font-bold text-white">
+                  {user.username?.charAt(0).toUpperCase() || 'U'}
+                </div>
+                <span className="text-sm text-wk-muted hidden sm:block">
+                  {user.username}
+                </span>
+              </div>
+            )}
+            <button
+              onClick={() => {}}
+              className="text-wk-muted hover:text-white transition-colors"
+              title="Settings"
+            >
+              <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+                <circle cx="12" cy="12" r="3" />
+                <path d="M12 1v2M12 21v2M4.22 4.22l1.42 1.42M18.36 18.36l1.42 1.42M1 12h2M21 12h2M4.22 19.78l1.42-1.42M18.36 5.64l1.42-1.42" />
+              </svg>
+            </button>
+
+          </div>
+        </div>
+      </div>
+    </nav>
+  );
+}

frontend/src/lib/api.ts

@@ -0,0 +1,93 @@
+const API_URL = process.env.NEXT_PUBLIC_API_URL || 'http://localhost:3001/api';
+
+function getToken(): string | null {
+  if (typeof window === 'undefined') return null;
+  return localStorage.getItem('wk_token');
+}
+
+async function apiFetch(path: string, options: RequestInit = {}) {
+  const headers: Record<string, string> = {
+    'Content-Type': 'application/json',
+    ...(options.headers as Record<string, string>),
+  };
+
+  const res = await fetch(`${API_URL}${path}`, {
+    ...options,
+    headers,
+  });
+
+  if (!res.ok) {
+    const error = await res.json().catch(() => ({ message: 'Request failed' }));
+    throw new Error(error.message || 'Request failed');
+  }
+
+  return res;
+}
+
+export async function login(username: string, password: string) {
+  const res = await fetch(`${API_URL}/auth/login`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ username, password }),
+  });
+
+  if (!res.ok) {
+    const err = await res.json().catch(() => ({ message: 'Login failed' }));
+    throw new Error(err.message || 'Login failed');
+  }
+
+  const data = await res.json();
+  localStorage.setItem('wk_token', data.access_token);
+  localStorage.setItem('wk_user', JSON.stringify(data.user));
+  // Set cookie for middleware
+  document.cookie = `wk_auth=${data.access_token}; path=/; max-age=86400`;
+  return data;
+}
+
+export function logout() {
+  localStorage.removeItem('wk_token');
+  localStorage.removeItem('wk_user');
+  document.cookie = 'wk_auth=; path=/; max-age=0';
+  window.location.href = '/login';
+}
+
+export function getUser() {
+  if (typeof window === 'undefined') return null;
+  const raw = localStorage.getItem('wk_user');
+  return raw ? JSON.parse(raw) : null;
+}
+
+export async function getMarkets() {
+  const res = await apiFetch('/markets');
+  return res.json();
+}
+
+export async function getMarketDetail(slug: string) {
+  const res = await apiFetch(`/markets/${slug}`);
+  return res.json();
+}
+
+export async function exportOddsCsv(slug: string) {
+  const res = await fetch(`${API_URL}/markets/${slug}/export/odds-csv`);
+  return res.text();
+}
+
+export async function exportIntegrityCsv(slug: string) {
+  const res = await fetch(`${API_URL}/markets/${slug}/export/integrity-csv`);
+  return res.text();
+}
+
+export async function exportDossierJson(slug: string) {
+  const res = await fetch(`${API_URL}/markets/${slug}/export/dossier-json`);
+  return res.json();
+}
+
+export async function refreshMarket(slug: string) {
+  const res = await apiFetch(`/markets/${slug}/refresh`, { method: 'POST' });
+  return res.json();
+}
+
+export async function getJobsStatus() {
+  const res = await apiFetch('/markets/jobs/status');
+  return res.json();
+}

frontend/src/middleware.ts

@@ -0,0 +1,11 @@
+import { NextResponse } from 'next/server';
+import type { NextRequest } from 'next/server';
+
+export function middleware(request: NextRequest) {
+  // No authentication required for demo
+  return NextResponse.next();
+}
+
+export const config = {
+  matcher: ['/dashboard/:path*', '/market/:path*'],
+};

frontend/tailwind.config.ts

@@ -0,0 +1,28 @@
+import type { Config } from 'tailwindcss';
+
+const config: Config = {
+  content: [
+    './src/pages/**/*.{js,ts,jsx,tsx,mdx}',
+    './src/components/**/*.{js,ts,jsx,tsx,mdx}',
+    './src/app/**/*.{js,ts,jsx,tsx,mdx}',
+  ],
+  theme: {
+    extend: {
+      colors: {
+        wk: {
+          bg: '#080810',
+          card: '#12121e',
+          border: '#1e1e30',
+          accent: '#6b21a8',
+          blue: '#3b82f6',
+          green: '#22c55e',
+          text: '#ffffff',
+          muted: '#9ca3af',
+        },
+      },
+    },
+  },
+  plugins: [],
+};
+
+export default config;

frontend/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "es5",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": false,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "preserve",
+    "incremental": true,
+    "plugins": [{ "name": "next" }],
+    "paths": { "@/*": ["./src/*"] }
+  },
+  "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
+  "exclude": ["node_modules"]
+}