From cb2c990d9d0f0978b3188a0adc11b1bd59f27c9b Mon Sep 17 00:00:00 2001
From: POSTI-25 <jahnavisingh512@gmail.com>
Date: Mon, 9 Feb 2026 03:13:47 +0530
Subject: [PATCH 1/9] /assisstant and /memory routes

---
 app/api/assistant/route.ts | 103 ++++++++++++++++++++
 app/api/memory/route.ts    | 195 +++++++++++++++++++++++++++++++++++++
 2 files changed, 298 insertions(+)
 create mode 100644 app/api/assistant/route.ts
 create mode 100644 app/api/memory/route.ts

diff --git a/app/api/assistant/route.ts b/app/api/assistant/route.ts
new file mode 100644
index 0000000..516e204
--- /dev/null
+++ b/app/api/assistant/route.ts
@@ -0,0 +1,103 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { BackboardClient } from 'backboard-sdk';
+
+const bb = new BackboardClient({
+  apiKey: process.env.BACKBOARD_API_KEY!,
+});
+
+// Type for non-streamed message responses
+type BBMessageResponse = {
+  content: string;
+  status: string;
+  toolCalls: Array<{ id: string; function: { name: string; parsed_arguments: any } }> | null;
+  runId?: string;
+  threadId: string;
+  memoryOperationId?: string;
+};
+
+// Mock/Placeholder for database operations
+const mockMatchData = {
+  getMatch: (matchId: string) => ({
+    id: matchId,
+    threadId: null as string | null // Replace with real DB lookup
+  }),
+  updateMatchThread: (matchId: string, threadId: string) => {
+    console.log(`Mock DB: Saved thread ${threadId} for match ${matchId}`);
+  }
+};
+
+export async function POST(req: NextRequest) {
+  try {
+    const body = await req.json();
+    const { matchId, code, language, userId } = body;
+
+    if (!matchId || !code || !language || !userId) {
+      return NextResponse.json({ error: 'Missing required fields' }, { status: 400 });
+    }
+
+    // 1. Get or Create Assistant (Logic simplified)
+    // In production, store ASSISTANT_ID in an env var to avoid re-creating
+    const assistant = await bb.createAssistant({
+      name: "Compile-n-Conquer GM",
+      system_prompt: "You are a competitive coding Game Master. Analyze complexity and efficiency.",
+      tools: [{
+        type: "function",
+        function: {
+          name: "analyze_code_complexity",
+          description: "Analyze Big O complexity",
+          parameters: {
+            type: "object",
+            properties: {
+              complexity: { type: "string" },
+              score: { type: "number" }
+            }
+          }
+        }
+      }]
+    });
+
+    // 2. Thread Management
+    const match = mockMatchData.getMatch(matchId);
+    let threadId: string = match.threadId ?? '';
+
+    if (!threadId) {
+      const thread = await bb.createThread(assistant.assistantId);
+      threadId = thread.threadId;
+      mockMatchData.updateMatchThread(matchId, threadId);
+    }
+
+    // 3. Send Message & Handle Interaction
+    let response = await bb.addMessage(threadId, {
+      content: `User ${userId} submitted ${language} code:\n\`\`\`\n${code}\n\`\`\``,
+      llm_provider: "openai",
+      model_name: "gpt-4o",
+      stream: false
+    }) as BBMessageResponse;
+
+    // 4. Handle Tool Calls (If LLM triggers the analyzer)
+    if (response.status === "REQUIRES_ACTION" && response.toolCalls) {
+      const toolOutputs = response.toolCalls.map((tc) => ({
+        tool_call_id: tc.id,
+        output: JSON.stringify({ complexity: "O(n)", score: 85 }) // Mock analysis logic
+      }));
+
+      const toolResponse = await bb.submitToolOutputs(
+        threadId,
+        response.runId!,
+        toolOutputs,
+        false
+      ) as BBMessageResponse;
+      response = toolResponse;
+    }
+
+    return NextResponse.json({
+      success: true,
+      evaluation: response.content,
+      threadId
+    });
+
+  } catch (error: any) {
+    console.error('API Error:', error);
+    return NextResponse.json({ error: error.message }, { status: 500 });
+  }
+}
\ No newline at end of file
diff --git a/app/api/memory/route.ts b/app/api/memory/route.ts
new file mode 100644
index 0000000..49c5fab
--- /dev/null
+++ b/app/api/memory/route.ts
@@ -0,0 +1,195 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { BackboardClient } from 'backboard-sdk';
+
+// Type for non-streamed message responses
+type BBMessageResponse = {
+  content: string;
+  status: string;
+  threadId: string;
+  memoryOperationId?: string;
+};
+
+// Mock/Placeholder for user database operations (replace with actual Prisma calls later)
+const mockUserData = {
+  getUserProfile: (userId: string) => ({
+    id: userId,
+    username: `user_${userId}`,
+    pastPerformance: "Student at VIT, intermediate competitive programmer",
+    commonErrors: [
+      "Off-by-one errors in array indexing",
+      "Inefficient nested loops leading to O(n²) complexity",
+      "Missing edge case handling for empty inputs"
+    ],
+    preferredAlgorithms: [
+      "Dynamic Programming",
+      "Binary Search",
+      "Two Pointers technique"
+    ],
+    skillLevel: "intermediate",
+    totalMatches: 15,
+    winRate: 0.67,
+    averageComplexity: "O(n log n)",
+    learningGoals: [
+      "Improve graph algorithm understanding",
+      "Master advanced DP patterns",
+      "Reduce time complexity in solutions"
+    ]
+  }),
+  updateUserMemorySession: (userId: string, memoryData: any) => {
+    console.log(`Mock: Updated memory session for user ${userId}`, memoryData);
+    return { success: true, lastUpdated: new Date().toISOString() };
+  }
+};
+
+export async function POST(req: NextRequest) {
+  try {
+    // Parse request body
+    const body = await req.json();
+    const { userId, action, memoryContext } = body;
+
+    // Validate required fields
+    if (!userId || !action) {
+      return NextResponse.json(
+        { error: 'Missing required fields: userId, action' },
+        { status: 400 }
+      );
+    }
+
+    // Validate action type
+    if (!['update', 'initialize', 'retrieve'].includes(action)) {
+      return NextResponse.json(
+        { error: 'Invalid action. Must be: update, initialize, or retrieve' },
+        { status: 400 }
+      );
+    }
+
+    if (!process.env.BACKBOARD_API_KEY) {
+      return NextResponse.json(
+        { error: 'Backboard API key not configured' },
+        { status: 500 }
+      );
+    }
+
+    // Initialize Backboard client
+    const client = new BackboardClient({
+      apiKey: process.env.BACKBOARD_API_KEY
+    });
+
+    // Create or retrieve assistant for memory management
+    const assistant = await client.createAssistant({
+      name: "Compile-n-Conquer Player Profile Manager",
+      system_prompt: `You are the Player Profile Manager for Compile-n-Conquer. 
+      You maintain persistent memory about each player's:
+      - Coding patterns and preferred algorithms
+      - Common mistakes and learning areas
+      - Performance history and skill progression
+      - Personalized coaching recommendations
+      
+      Use this information to provide personalized feedback and adaptive difficulty.
+      Always maintain context about the player's journey and growth areas.`
+    });
+
+    // Mock: Get user profile data (replace with actual Prisma call)
+    const userProfile = mockUserData.getUserProfile(userId);
+
+    let result;
+
+    switch (action) {
+      case 'initialize':
+      case 'update':
+        // Create a thread for memory management
+        const thread = await client.createThread(assistant.assistantId);
+
+        // Prepare memory context
+        const contextToStore = memoryContext || {
+          userProfile,
+          timestamp: new Date().toISOString(),
+          sessionType: 'profile_update'
+        };
+
+        // Build comprehensive memory message
+        const memoryMessage = `
+Player Profile Update for User ${userId}:
+
+**Background:** ${userProfile.pastPerformance}
+
+**Skill Assessment:**
+- Level: ${userProfile.skillLevel}
+- Total Matches: ${userProfile.totalMatches}
+- Win Rate: ${(userProfile.winRate * 100).toFixed(1)}%
+- Average Complexity: ${userProfile.averageComplexity}
+
+**Common Challenges:**
+${userProfile.commonErrors.map(error => `- ${error}`).join('\n')}
+
+**Strengths & Preferences:**
+${userProfile.preferredAlgorithms.map(algo => `- ${algo}`).join('\n')}
+
+**Learning Goals:**
+${userProfile.learningGoals.map(goal => `- ${goal}`).join('\n')}
+
+Remember this context for personalized coaching and adaptive difficulty in future interactions.
+`;
+
+        // Store memory with Backboard's memory feature
+        const memoryResponse = await client.addMessage(thread.threadId, {
+          content: memoryMessage,
+          memory: "Auto", // Enable automatic memory saving
+          stream: false
+        }) as BBMessageResponse;
+
+        // Mock: Update local database with memory session info
+        const updateResult = mockUserData.updateUserMemorySession(userId, {
+          threadId: thread.threadId,
+          memoryOperationId: memoryResponse.memoryOperationId,
+          contextStored: contextToStore
+        });
+
+        result = {
+          action: 'updated',
+          userId,
+          threadId: thread.threadId,
+          memoryOperationId: memoryResponse.memoryOperationId,
+          userProfile,
+          updateResult
+        };
+        break;
+
+      case 'retrieve':
+        // Create a new thread to test memory recall
+        const retrieveThread = await client.createThread(assistant.assistantId);
+        
+        // Query what the assistant remembers about this user
+        const recallResponse = await client.addMessage(retrieveThread.threadId, {
+          content: `What do you remember about user ${userId}? Provide a comprehensive summary of their profile, strengths, weaknesses, and learning journey.`,
+          memory: "Auto", // Search and retrieve saved memories
+          stream: false
+        }) as BBMessageResponse;
+
+        result = {
+          action: 'retrieved',
+          userId,
+          threadId: retrieveThread.threadId,
+          memorizedProfile: recallResponse.content,
+          currentProfile: userProfile
+        };
+        break;
+    }
+
+    return NextResponse.json({
+      success: true,
+      ...result,
+      timestamp: new Date().toISOString()
+    });
+
+  } catch (error) {
+    console.error('Memory API Error:', error);
+    return NextResponse.json(
+      { 
+        error: 'Failed to process memory operation',
+        details: error instanceof Error ? error.message : 'Unknown error'
+      },
+      { status: 500 }
+    );
+  }
+}
\ No newline at end of file

From 0baea99af286c0e16753b3865668806b5de14324 Mon Sep 17 00:00:00 2001
From: POSTI-25 <jahnavisingh512@gmail.com>
Date: Mon, 9 Feb 2026 16:03:46 +0530
Subject: [PATCH 2/9] backboard architecture

---
 ARCHITECTURE.md                   | 316 +++++++++++
 app/arena/page.tsx                |  69 +++
 app/auth/page.tsx                 | 155 ++++++
 app/globals.css                   | 122 ++++-
 app/layout.tsx                    |  41 +-
 app/page.tsx                      |  76 +--
 app/profile/page.tsx              | 186 +++++++
 backbaord/evaluation.ts           | 583 ++++++++++++++++++++
 backbaord/index.ts                |   9 +
 backbaord/memory.ts               | 204 +++++++
 backbaord/mock-test.ts            | 869 ++++++++++++++++++++++++++++++
 backbaord/testing.ts              |  39 ++
 backbaord/tools.ts                | 223 ++++++++
 backbaord/types.ts                | 174 ++++++
 components/arena/code-editor.tsx  | 257 +++++++++
 components/arena/points-panel.tsx | 157 ++++++
 components/arena/progress-bar.tsx | 109 ++++
 components/arena/users-panel.tsx  | 110 ++++
 components/landing/features.tsx   |  81 +++
 components/landing/footer.tsx     |  40 ++
 components/landing/game-modes.tsx | 126 +++++
 components/landing/hero.tsx       | 124 +++++
 components/landing/navbar.tsx     |  95 ++++
 components/theme-provider.tsx     |  11 +
 components/ui/accordion.tsx       |  58 ++
 components/ui/alert-dialog.tsx    | 141 +++++
 components/ui/alert.tsx           |  59 ++
 components/ui/aspect-ratio.tsx    |   7 +
 components/ui/avatar.tsx          |  50 ++
 components/ui/badge.tsx           |  37 ++
 components/ui/breadcrumb.tsx      | 115 ++++
 components/ui/button.tsx          |  57 ++
 components/ui/calendar.tsx        |  66 +++
 components/ui/card.tsx            |  79 +++
 components/ui/carousel.tsx        | 262 +++++++++
 components/ui/chart.tsx           | 365 +++++++++++++
 components/ui/checkbox.tsx        |  30 ++
 components/ui/collapsible.tsx     |  11 +
 components/ui/command.tsx         | 153 ++++++
 components/ui/context-menu.tsx    | 200 +++++++
 components/ui/dialog.tsx          | 122 +++++
 components/ui/drawer.tsx          | 118 ++++
 components/ui/dropdown-menu.tsx   | 200 +++++++
 components/ui/form.tsx            | 178 ++++++
 components/ui/hover-card.tsx      |  29 +
 components/ui/input-otp.tsx       |  71 +++
 components/ui/input.tsx           |  22 +
 components/ui/label.tsx           |  26 +
 components/ui/menubar.tsx         | 236 ++++++++
 components/ui/navigation-menu.tsx | 128 +++++
 components/ui/pagination.tsx      | 117 ++++
 components/ui/popover.tsx         |  31 ++
 components/ui/progress.tsx        |  28 +
 components/ui/radio-group.tsx     |  44 ++
 components/ui/resizable.tsx       |  45 ++
 components/ui/scroll-area.tsx     |  48 ++
 components/ui/select.tsx          | 160 ++++++
 components/ui/separator.tsx       |  31 ++
 components/ui/sheet.tsx           | 141 +++++
 components/ui/sidebar.tsx         | 771 ++++++++++++++++++++++++++
 components/ui/skeleton.tsx        |  15 +
 components/ui/slider.tsx          |  28 +
 components/ui/sonner.tsx          |  31 ++
 components/ui/switch.tsx          |  29 +
 components/ui/table.tsx           | 117 ++++
 components/ui/tabs.tsx            |  55 ++
 components/ui/textarea.tsx        |  22 +
 components/ui/toast.tsx           | 129 +++++
 components/ui/toaster.tsx         |  35 ++
 components/ui/toggle-group.tsx    |  61 +++
 components/ui/toggle.tsx          |  45 ++
 components/ui/tooltip.tsx         |  30 ++
 components/ui/use-mobile.tsx      |  19 +
 components/ui/use-toast.ts        | 191 +++++++
 hooks/use-mobile.tsx              |  19 +
 hooks/use-toast.ts                | 191 +++++++
 lib/utils.ts                      |   6 +
 package-lock.json                 | 227 +++++++-
 package.json                      |   7 +-
 tailwind.config.ts                |  89 +++
 80 files changed, 9640 insertions(+), 118 deletions(-)
 create mode 100644 ARCHITECTURE.md
 create mode 100644 app/arena/page.tsx
 create mode 100644 app/auth/page.tsx
 create mode 100644 app/profile/page.tsx
 create mode 100644 backbaord/evaluation.ts
 create mode 100644 backbaord/index.ts
 create mode 100644 backbaord/memory.ts
 create mode 100644 backbaord/mock-test.ts
 create mode 100644 backbaord/testing.ts
 create mode 100644 backbaord/tools.ts
 create mode 100644 backbaord/types.ts
 create mode 100644 components/arena/code-editor.tsx
 create mode 100644 components/arena/points-panel.tsx
 create mode 100644 components/arena/progress-bar.tsx
 create mode 100644 components/arena/users-panel.tsx
 create mode 100644 components/landing/features.tsx
 create mode 100644 components/landing/footer.tsx
 create mode 100644 components/landing/game-modes.tsx
 create mode 100644 components/landing/hero.tsx
 create mode 100644 components/landing/navbar.tsx
 create mode 100644 components/theme-provider.tsx
 create mode 100644 components/ui/accordion.tsx
 create mode 100644 components/ui/alert-dialog.tsx
 create mode 100644 components/ui/alert.tsx
 create mode 100644 components/ui/aspect-ratio.tsx
 create mode 100644 components/ui/avatar.tsx
 create mode 100644 components/ui/badge.tsx
 create mode 100644 components/ui/breadcrumb.tsx
 create mode 100644 components/ui/button.tsx
 create mode 100644 components/ui/calendar.tsx
 create mode 100644 components/ui/card.tsx
 create mode 100644 components/ui/carousel.tsx
 create mode 100644 components/ui/chart.tsx
 create mode 100644 components/ui/checkbox.tsx
 create mode 100644 components/ui/collapsible.tsx
 create mode 100644 components/ui/command.tsx
 create mode 100644 components/ui/context-menu.tsx
 create mode 100644 components/ui/dialog.tsx
 create mode 100644 components/ui/drawer.tsx
 create mode 100644 components/ui/dropdown-menu.tsx
 create mode 100644 components/ui/form.tsx
 create mode 100644 components/ui/hover-card.tsx
 create mode 100644 components/ui/input-otp.tsx
 create mode 100644 components/ui/input.tsx
 create mode 100644 components/ui/label.tsx
 create mode 100644 components/ui/menubar.tsx
 create mode 100644 components/ui/navigation-menu.tsx
 create mode 100644 components/ui/pagination.tsx
 create mode 100644 components/ui/popover.tsx
 create mode 100644 components/ui/progress.tsx
 create mode 100644 components/ui/radio-group.tsx
 create mode 100644 components/ui/resizable.tsx
 create mode 100644 components/ui/scroll-area.tsx
 create mode 100644 components/ui/select.tsx
 create mode 100644 components/ui/separator.tsx
 create mode 100644 components/ui/sheet.tsx
 create mode 100644 components/ui/sidebar.tsx
 create mode 100644 components/ui/skeleton.tsx
 create mode 100644 components/ui/slider.tsx
 create mode 100644 components/ui/sonner.tsx
 create mode 100644 components/ui/switch.tsx
 create mode 100644 components/ui/table.tsx
 create mode 100644 components/ui/tabs.tsx
 create mode 100644 components/ui/textarea.tsx
 create mode 100644 components/ui/toast.tsx
 create mode 100644 components/ui/toaster.tsx
 create mode 100644 components/ui/toggle-group.tsx
 create mode 100644 components/ui/toggle.tsx
 create mode 100644 components/ui/tooltip.tsx
 create mode 100644 components/ui/use-mobile.tsx
 create mode 100644 components/ui/use-toast.ts
 create mode 100644 hooks/use-mobile.tsx
 create mode 100644 hooks/use-toast.ts
 create mode 100644 lib/utils.ts
 create mode 100644 tailwind.config.ts

diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md
new file mode 100644
index 0000000..0481c87
--- /dev/null
+++ b/ARCHITECTURE.md
@@ -0,0 +1,316 @@
+# Compile-n-Conquer — Evaluation Pipeline Architecture
+
+## Overview
+
+A competitive coding platform where users compete in rounds by solving coding questions. Submissions are evaluated by an LLM pipeline (via Backboard.io) across multiple metrics, scored with configurable weights, and ranked with tiebreaker logic.
+
+---
+
+## Core Concepts
+
+| Term | Definition |
+|---|---|
+| **Round** | A competitive session containing N questions |
+| **Submission** | A single user's code answer to one question |
+| **Evaluation Thread** | A dedicated Backboard.io LLM thread for one scoring metric |
+| **Memory** | Persistent Backboard.io memory tracking user skill level over time |
+
+---
+
+## Input Format
+
+All submissions for a round are batched into a structured payload:
+
+```json
+{
+  "roundId": "round_1",
+  "questions": [
+    { "id": "q1", "title": "Two Sum", "description": "...", "difficulty": "medium" },
+    { "id": "q2", "title": "...", "description": "...", "difficulty": "..." },
+    { "id": "q3", "title": "...", "description": "...", "difficulty": "..." }
+  ],
+  "submissions": [
+    {
+      "userId": "user_1",
+      "responses": [
+        { "questionId": "q1", "code": "...", "language": "python", "submittedAt": "ISO-timestamp" },
+        { "questionId": "q2", "code": "...", "language": "cpp", "submittedAt": "ISO-timestamp" },
+        { "questionId": "q3", "code": "...", "language": "javascript", "submittedAt": "ISO-timestamp" }
+      ]
+    },
+    {
+      "userId": "user_2",
+      "responses": [/* ... */]
+    },
+    {
+      "userId": "user_3",
+      "responses": [/* ... */]
+    }
+  ]
+}
+```
+
+---
+
+## Evaluation Pipeline (4 LLM Threads via Backboard.io)
+
+### Thread 1 — Time Complexity Analysis
+
+**Purpose:** Determine the Big-O time complexity for every submission.
+
+**Backboard Tool Definition:**
+```
+name: "analyze_time_complexity"
+description: "Analyze and return the Big-O time complexity of the submitted code relative to the problem it solves. Return the complexity class and a numeric efficiency score (1-100) where 100 is optimal."
+parameters:
+  - code (string, required): The submitted source code
+  - language (string, required): Programming language
+  - questionContext (string, required): The problem statement for context
+output:
+  - complexity (string): e.g. "O(n)", "O(n log n)", "O(n²)"
+  - score (number 1-100): Efficiency rating
+  - reasoning (string): Brief justification
+```
+
+**Output Format:**
+```json
+{
+  "roundId": "round_1",
+  "metric": "time_complexity",
+  "results": {
+    "user_1": [
+      { "questionId": "q1", "complexity": "O(n)", "score": 92, "reasoning": "..." },
+      { "questionId": "q2", "complexity": "O(n log n)", "score": 85, "reasoning": "..." },
+      { "questionId": "q3", "complexity": "O(n²)", "score": 40, "reasoning": "..." }
+    ],
+    "user_2": [/* ... */],
+    "user_3": [/* ... */]
+  }
+}
+```
+
+---
+
+### Thread 2 — Space Complexity Analysis
+
+**Purpose:** Determine the Big-O space complexity for every submission.
+
+**Backboard Tool Definition:**
+```
+name: "analyze_space_complexity"
+description: "Analyze and return the Big-O space complexity of the submitted code. Consider auxiliary space used (not input space). Return the complexity class and a numeric efficiency score (1-100)."
+parameters:
+  - code (string, required): The submitted source code
+  - language (string, required): Programming language
+  - questionContext (string, required): The problem statement for context
+output:
+  - complexity (string): e.g. "O(1)", "O(n)", "O(n²)"
+  - score (number 1-100): Efficiency rating
+  - reasoning (string): Brief justification
+```
+
+**Output Format:** Same structure as Thread 1, with `"metric": "space_complexity"`.
+
+---
+
+### Thread 3 — Originality & Context Relevance Analysis
+
+**Purpose:** Detect likely GPT-generated / copy-pasted code and evaluate how relevant the solution is to the actual question.
+
+**Scoring Criteria:**
+- **Comment density:** Excessive/formulaic comments → likely AI-generated (penalize)
+- **Code style consistency:** Unusual variable naming patterns, overly verbose docstrings
+- **Relevance:** Does the code actually solve the given problem, or is it tangential?
+- **Pattern detection:** Boilerplate patterns common in LLM outputs
+
+**Backboard Tool Definition:**
+```
+name: "analyze_originality"
+description: "Analyze code for originality signals. Check comment density (high = likely AI-generated), code style patterns, and relevance to the problem. Return an originality score (1-10) and a relevance score (1-10)."
+parameters:
+  - code (string, required): The submitted source code
+  - language (string, required): Programming language
+  - questionContext (string, required): The problem statement
+output:
+  - originalityScore (number 1-10): 10 = clearly human-written, 1 = clearly AI-generated
+  - relevanceScore (number 1-10): 10 = perfectly solves the problem, 1 = completely unrelated
+  - commentDensity (number): Comments-to-code ratio percentage
+  - flags (string[]): e.g. ["excessive_comments", "boilerplate_docstrings", "generic_variable_names"]
+  - reasoning (string): Brief justification
+```
+
+**Output Format:**
+```json
+{
+  "roundId": "round_1",
+  "metric": "originality",
+  "results": {
+    "user_1": [
+      {
+        "questionId": "q1",
+        "originalityScore": 8,
+        "relevanceScore": 9,
+        "commentDensity": 12.5,
+        "flags": [],
+        "reasoning": "..."
+      }
+    ]
+  }
+}
+```
+
+---
+
+### Thread 4 — Final Ranking (Aggregation Thread)
+
+**Purpose:** Consume the outputs of Threads 1-3, apply weights, integrate test-case pass rates from DB, and produce final rankings.
+
+**Backboard Tool Definition:**
+```
+name: "compute_final_ranking"
+description: "Given all metric scores for all users in a round, compute weighted final scores and produce a ranking. Apply the provided weights. In case of a tie, use the tiebreaker metric (time taken)."
+parameters:
+  - timeComplexityResults (object, required): Output from Thread 1
+  - spaceComplexityResults (object, required): Output from Thread 2
+  - originalityResults (object, required): Output from Thread 3
+  - testCaseResults (object, required): { userId: { passed: N, total: M } } from DB
+  - weights (object, required): { timeComplexity, spaceComplexity, originality, testCases }
+  - tiebreakerData (object, required): { userId: timeTakenMs } for each user
+output:
+  - rankings (array): Ordered list of { userId, rank, finalScore, breakdown }
+```
+
+---
+
+## Scoring Formula
+
+```
+finalScore = (TC_score × W_tc) + (SC_score × W_sc) + (originality_score × W_orig) + (testCase_score × W_test)
+```
+
+**Default Weights:**
+| Metric | Weight | Max Raw Score | Normalized To |
+|---|---|---|---|
+| Time Complexity | 25% | 100 per question | 0-25 |
+| Space Complexity | 20% | 100 per question | 0-20 |
+| Originality + Relevance | 15% | 10 per question | 0-15 |
+| Test Cases Passed | 40% | 100% pass rate | 0-40 |
+
+**Total Max Score:** 100 per question, averaged across all questions in the round.
+
+**Tiebreaker:** If two users have the same final score, the user who submitted in less total time ranks higher.
+
+---
+
+## Memory System (`/memory`)
+
+Tracks persistent user profiles across rounds for adaptive difficulty and skill classification.
+
+**Skill Tiers:**
+| Tier | Criteria |
+|---|---|
+| Beginner | Avg score < 30, struggles with basic DS |
+| Intermediate | Avg score 30-60, consistent O(n²) or better |
+| Advanced | Avg score 60-85, uses optimal approaches often |
+| Pro | Avg score 85+, consistently optimal TC/SC |
+
+**Memory stores:**
+- Historical round scores and progression trend
+- Common error patterns (off-by-one, TLE, MLE)
+- Preferred algorithms and languages
+- Skill tier + promotion/demotion history
+- Personalized coaching recommendations
+
+**Promotion Logic:**
+- 3 consecutive rounds with avg score in next tier → promote
+- 2 consecutive rounds below current tier threshold → demote
+- Memory is queried at round start to set adaptive difficulty
+
+---
+
+## API Endpoints
+
+### `POST /api/assistant` — Evaluation Pipeline
+
+**Request:**
+```json
+{
+  "roundId": "round_1",
+  "action": "evaluate",
+  "submissions": [/* full round submissions payload */],
+  "weights": { "timeComplexity": 0.25, "spaceComplexity": 0.20, "originality": 0.15, "testCases": 0.40 },
+  "testCaseResults": { "user_1": { "passed": 8, "total": 10 }, ... },
+  "tiebreakerData": { "user_1": 145000, ... }
+}
+```
+
+**Response:**
+```json
+{
+  "success": true,
+  "roundId": "round_1",
+  "evaluationId": "eval_xxx",
+  "rankings": [
+    {
+      "rank": 1,
+      "userId": "user_2",
+      "finalScore": 87.5,
+      "breakdown": {
+        "timeComplexity": { "avgScore": 90, "weighted": 22.5 },
+        "spaceComplexity": { "avgScore": 85, "weighted": 17.0 },
+        "originality": { "avgScore": 8.5, "weighted": 12.75 },
+        "testCases": { "passRate": 0.9, "weighted": 36.0 }
+      },
+      "timeTakenMs": 120000
+    }
+  ],
+  "threadIds": {
+    "timeComplexity": "thread_tc_xxx",
+    "spaceComplexity": "thread_sc_xxx",
+    "originality": "thread_orig_xxx",
+    "ranking": "thread_rank_xxx"
+  }
+}
+```
+
+### `POST /api/memory` — Player Profile Memory
+
+**Actions:** `initialize`, `update`, `retrieve`, `classify`
+
+---
+
+## Execution Flow Diagram
+
+```
+Round Ends → Collect All Submissions
+       │
+       ├──→ Thread 1: Time Complexity Analysis ──→ Store TC Results
+       ├──→ Thread 2: Space Complexity Analysis ──→ Store SC Results
+       ├──→ Thread 3: Originality Analysis ────────→ Store Orig Results
+       │         (Threads 1-3 run in parallel)
+       │
+       ▼
+  Thread 4: Aggregation & Ranking
+       │
+       ├── Fetch test case pass rates from DB
+       ├── Apply scoring weights
+       ├── Handle tiebreakers (time taken)
+       │
+       ▼
+  Final Rankings Published
+       │
+       ▼
+  /memory: Update user profiles & skill tiers
+```
+
+---
+
+## Mock Testing Strategy
+
+All evaluation logic is testable without live Backboard API calls:
+
+1. **Unit tests for scoring math** — Weight application, normalization, tiebreaker logic
+2. **Mock LLM responses** — Predefined tool call outputs for each thread
+3. **End-to-end pipeline test** — Full round with 3 mock users, 3 questions, verify ranking order
+4. **Edge cases** — Tied scores, empty submissions, single user, all-zero scores
+5. **Memory classification test** — Verify tier promotion/demotion with historical mock data
diff --git a/app/arena/page.tsx b/app/arena/page.tsx
new file mode 100644
index 0000000..ca6d747
--- /dev/null
+++ b/app/arena/page.tsx
@@ -0,0 +1,69 @@
+"use client"
+
+import { ProgressBar } from "@/components/arena/progress-bar"
+import { CodeEditor } from "@/components/arena/code-editor"
+import { UsersPanel } from "@/components/arena/users-panel"
+import { PointsPanel } from "@/components/arena/points-panel"
+import { Terminal, ArrowLeft } from "lucide-react"
+import Link from "next/link"
+
+export default function ArenaPage() {
+  return (
+    <main className="flex h-screen flex-col overflow-hidden bg-background">
+      {/* Top bar */}
+      <header className="flex items-center justify-between border-b border-border px-4 py-2">
+        <div className="flex items-center gap-3">
+          <Link
+            href="/"
+            className="flex items-center gap-1.5 text-muted-foreground transition-colors hover:text-primary"
+            aria-label="Back to home"
+          >
+            <ArrowLeft className="h-3.5 w-3.5" />
+          </Link>
+          <div className="flex items-center gap-2">
+            <Terminal className="h-4 w-4 text-primary" />
+            <span className="text-xs font-bold uppercase tracking-widest text-foreground">
+              CnC Arena
+            </span>
+          </div>
+        </div>
+        <div className="flex items-center gap-4">
+          <div className="flex items-center gap-2">
+            <div className="h-2 w-2 animate-pulse rounded-full bg-primary" />
+            <span className="text-xs uppercase tracking-widest text-primary">
+              Live
+            </span>
+          </div>
+          <span className="text-xs text-muted-foreground">
+            Mode: Code from Scratch
+          </span>
+          <Link
+            href="/profile"
+            className="flex h-7 w-7 items-center justify-center rounded-sm border border-primary/30 bg-primary/10 text-xs font-bold text-primary"
+          >
+            Y
+          </Link>
+        </div>
+      </header>
+
+      {/* Progress bar section */}
+      <div className="border-b border-border px-4 py-2">
+        <ProgressBar />
+      </div>
+
+      {/* Main content area */}
+      <div className="flex flex-1 overflow-hidden">
+        {/* Code editor - center/left */}
+        <div className="flex flex-1 flex-col overflow-hidden p-2">
+          <CodeEditor />
+        </div>
+
+        {/* Right sidebar: Users + Points */}
+        <div className="hidden w-72 flex-col gap-2 overflow-auto border-l border-border p-2 xl:flex">
+          <UsersPanel />
+          <PointsPanel />
+        </div>
+      </div>
+    </main>
+  )
+}
diff --git a/app/auth/page.tsx b/app/auth/page.tsx
new file mode 100644
index 0000000..d9b2a96
--- /dev/null
+++ b/app/auth/page.tsx
@@ -0,0 +1,155 @@
+"use client"
+
+import { Terminal, ArrowLeft } from "lucide-react"
+import Link from "next/link"
+import { useState } from "react"
+
+export default function AuthPage() {
+  const [isLoading, setIsLoading] = useState(false)
+
+  const handleGoogleSignIn = () => {
+    setIsLoading(true)
+    // Mock: In production, redirect to Supabase Google OAuth
+    setTimeout(() => {
+      setIsLoading(false)
+    }, 2000)
+  }
+
+  return (
+    <main className="relative flex min-h-screen flex-col items-center justify-center px-4">
+      {/* Grid background */}
+      <div
+        className="pointer-events-none absolute inset-0 opacity-5"
+        style={{
+          backgroundImage:
+            "linear-gradient(hsl(120 100% 50% / 0.1) 1px, transparent 1px), linear-gradient(90deg, hsl(120 100% 50% / 0.1) 1px, transparent 1px)",
+          backgroundSize: "40px 40px",
+        }}
+      />
+
+      {/* Scanline */}
+      <div className="pointer-events-none absolute inset-0 overflow-hidden">
+        <div className="animate-scanline absolute left-0 h-px w-full bg-primary/10" />
+      </div>
+
+      <div className="relative z-10 w-full max-w-md">
+        {/* Back link */}
+        <Link
+          href="/"
+          className="mb-8 flex items-center gap-2 text-xs uppercase tracking-widest text-muted-foreground transition-colors hover:text-primary"
+        >
+          <ArrowLeft className="h-3 w-3" />
+          Back to Home
+        </Link>
+
+        {/* Auth card */}
+        <div className="rounded-sm border border-border bg-card p-8">
+          {/* Header */}
+          <div className="mb-8 flex flex-col items-center gap-4 text-center">
+            <div className="flex h-12 w-12 items-center justify-center rounded-sm border border-border bg-secondary">
+              <Terminal className="h-6 w-6 text-primary" />
+            </div>
+            <div>
+              <h1 className="text-xl font-bold uppercase tracking-wider text-foreground">
+                {"Access Terminal"}
+              </h1>
+              <p className="mt-1 text-xs text-muted-foreground">
+                {"// authenticate to enter the arena"}
+              </p>
+            </div>
+          </div>
+
+          {/* Terminal-style status */}
+          <div className="mb-6 rounded-sm border border-border bg-secondary/50 p-3">
+            <div className="flex items-center gap-2 text-xs text-muted-foreground">
+              <span className="text-primary">{"$"}</span>
+              <span>{"system.auth --status"}</span>
+            </div>
+            <div className="mt-1 flex items-center gap-2 text-xs">
+              <span className="text-primary">{">"}</span>
+              <span className="text-foreground">{"Awaiting credentials..."}</span>
+              <span className="animate-blink text-primary">{"_"}</span>
+            </div>
+          </div>
+
+          {/* Google Sign In button */}
+          <button
+            onClick={handleGoogleSignIn}
+            disabled={isLoading}
+            className="flex w-full items-center justify-center gap-3 rounded-sm border border-border bg-secondary px-4 py-3 text-sm font-bold uppercase tracking-widest text-foreground transition-all hover:border-primary hover:text-primary disabled:opacity-50"
+          >
+            <svg className="h-5 w-5" viewBox="0 0 24 24">
+              <path
+                d="M22.56 12.25c0-.78-.07-1.53-.2-2.25H12v4.26h5.92a5.06 5.06 0 0 1-2.2 3.32v2.77h3.57c2.08-1.92 3.28-4.74 3.28-8.1z"
+                fill="#4285F4"
+              />
+              <path
+                d="M12 23c2.97 0 5.46-.98 7.28-2.66l-3.57-2.77c-.98.66-2.23 1.06-3.71 1.06-2.86 0-5.29-1.93-6.16-4.53H2.18v2.84C3.99 20.53 7.7 23 12 23z"
+                fill="#34A853"
+              />
+              <path
+                d="M5.84 14.09c-.22-.66-.35-1.36-.35-2.09s.13-1.43.35-2.09V7.07H2.18C1.43 8.55 1 10.22 1 12s.43 3.45 1.18 4.93l2.85-2.22.81-.62z"
+                fill="#FBBC05"
+              />
+              <path
+                d="M12 5.38c1.62 0 3.06.56 4.21 1.64l3.15-3.15C17.45 2.09 14.97 1 12 1 7.7 1 3.99 3.47 2.18 7.07l3.66 2.84c.87-2.6 3.3-4.53 6.16-4.53z"
+                fill="#EA4335"
+              />
+            </svg>
+            {isLoading ? "Connecting..." : "Sign in with Google"}
+          </button>
+
+          {/* Divider */}
+          <div className="my-6 flex items-center gap-4">
+            <div className="h-px flex-1 bg-border" />
+            <span className="text-xs text-muted-foreground">{"or"}</span>
+            <div className="h-px flex-1 bg-border" />
+          </div>
+
+          {/* Username/Email mock fields */}
+          <div className="flex flex-col gap-4">
+            <div>
+              <label
+                htmlFor="username"
+                className="mb-1 block text-xs uppercase tracking-widest text-muted-foreground"
+              >
+                Handle
+              </label>
+              <input
+                id="username"
+                type="text"
+                placeholder="your_callsign"
+                className="w-full rounded-sm border border-border bg-input px-3 py-2 text-sm text-foreground placeholder:text-muted-foreground focus:border-primary focus:outline-none focus:ring-1 focus:ring-primary"
+              />
+            </div>
+            <div>
+              <label
+                htmlFor="password"
+                className="mb-1 block text-xs uppercase tracking-widest text-muted-foreground"
+              >
+                Access Key
+              </label>
+              <input
+                id="password"
+                type="password"
+                placeholder="**************"
+                className="w-full rounded-sm border border-border bg-input px-3 py-2 text-sm text-foreground placeholder:text-muted-foreground focus:border-primary focus:outline-none focus:ring-1 focus:ring-primary"
+              />
+            </div>
+            <button className="animate-pulse-glow w-full rounded-sm border border-primary bg-primary px-4 py-2.5 text-sm font-bold uppercase tracking-widest text-primary-foreground transition-all hover:bg-primary/90">
+              Initialize Session
+            </button>
+          </div>
+
+          {/* Footer text */}
+          <p className="mt-6 text-center text-xs text-muted-foreground">
+            {"New operative? "}
+            <Link href="/auth" className="text-primary hover:underline">
+              {"Request Access"}
+            </Link>
+          </p>
+        </div>
+      </div>
+    </main>
+  )
+}
diff --git a/app/globals.css b/app/globals.css
index a2dc41e..8f13be6 100644
--- a/app/globals.css
+++ b/app/globals.css
@@ -1,26 +1,114 @@
 @import "tailwindcss";
 
-:root {
-  --background: #ffffff;
-  --foreground: #171717;
+@theme {
+  --color-background: hsl(120 5% 3%);
+  --color-foreground: hsl(120 100% 85%);
+  --color-card: hsl(120 5% 5%);
+  --color-card-foreground: hsl(120 100% 85%);
+  --color-popover: hsl(120 5% 5%);
+  --color-popover-foreground: hsl(120 100% 85%);
+  --color-primary: hsl(120 100% 50%);
+  --color-primary-foreground: hsl(120 5% 3%);
+  --color-secondary: hsl(120 5% 10%);
+  --color-secondary-foreground: hsl(120 100% 75%);
+  --color-muted: hsl(120 3% 12%);
+  --color-muted-foreground: hsl(120 10% 50%);
+  --color-accent: hsl(120 100% 50%);
+  --color-accent-foreground: hsl(120 5% 3%);
+  --color-destructive: hsl(0 80% 50%);
+  --color-destructive-foreground: hsl(0 0% 98%);
+  --color-border: hsl(120 15% 15%);
+  --color-input: hsl(120 10% 12%);
+  --color-ring: hsl(120 100% 50%);
+  --color-chart-1: hsl(120 100% 50%);
+  --color-chart-2: hsl(120 80% 40%);
+  --color-chart-3: hsl(120 60% 30%);
+  --color-chart-4: hsl(45 100% 50%);
+  --color-chart-5: hsl(0 80% 50%);
+  --color-sidebar: hsl(120 5% 5%);
+  --color-sidebar-foreground: hsl(120 100% 85%);
+  --color-sidebar-primary: hsl(120 100% 50%);
+  --color-sidebar-primary-foreground: hsl(120 5% 3%);
+  --color-sidebar-accent: hsl(120 5% 10%);
+  --color-sidebar-accent-foreground: hsl(120 100% 85%);
+  --color-sidebar-border: hsl(120 15% 15%);
+  --color-sidebar-ring: hsl(120 100% 50%);
+  --radius-sm: calc(0.375rem - 4px);
+  --radius-md: calc(0.375rem - 2px);
+  --radius-lg: 0.375rem;
+  --radius-xl: calc(0.375rem + 4px);
 }
 
-@theme inline {
-  --color-background: var(--background);
-  --color-foreground: var(--foreground);
-  --font-sans: var(--font-geist-sans);
-  --font-mono: var(--font-geist-mono);
+* {
+  border-color: var(--color-border);
 }
 
-@media (prefers-color-scheme: dark) {
-  :root {
-    --background: #0a0a0a;
-    --foreground: #ededed;
-  }
+body {
+  background-color: var(--color-background);
+  color: var(--color-foreground);
 }
 
-body {
-  background: var(--background);
-  color: var(--foreground);
-  font-family: Arial, Helvetica, sans-serif;
+/* Scanline effect */
+@keyframes scanline {
+  0% { transform: translateY(-100%); }
+  100% { transform: translateY(100vh); }
+}
+
+@keyframes blink {
+  0%, 100% { opacity: 1; }
+  50% { opacity: 0; }
+}
+
+@keyframes pulse-glow {
+  0%, 100% { box-shadow: 0 0 5px hsl(120 100% 50% / 0.3); }
+  50% { box-shadow: 0 0 20px hsl(120 100% 50% / 0.6), 0 0 40px hsl(120 100% 50% / 0.2); }
+}
+
+@keyframes typing {
+  from { width: 0; }
+  to { width: 100%; }
+}
+
+@keyframes flicker {
+  0%, 100% { opacity: 1; }
+  92% { opacity: 1; }
+  93% { opacity: 0.8; }
+  94% { opacity: 1; }
+  96% { opacity: 0.9; }
+  97% { opacity: 1; }
+}
+
+.animate-scanline {
+  animation: scanline 8s linear infinite;
+}
+
+.animate-blink {
+  animation: blink 1s step-end infinite;
+}
+
+.animate-pulse-glow {
+  animation: pulse-glow 2s ease-in-out infinite;
+}
+
+.animate-flicker {
+  animation: flicker 4s linear infinite;
+}
+
+/* Custom scrollbar */
+::-webkit-scrollbar {
+  width: 6px;
+  height: 6px;
+}
+
+::-webkit-scrollbar-track {
+  background: hsl(120 5% 5%);
+}
+
+::-webkit-scrollbar-thumb {
+  background: hsl(120 100% 50% / 0.3);
+  border-radius: 3px;
+}
+
+::-webkit-scrollbar-thumb:hover {
+  background: hsl(120 100% 50% / 0.5);
 }
diff --git a/app/layout.tsx b/app/layout.tsx
index f7fa87e..0741ec6 100644
--- a/app/layout.tsx
+++ b/app/layout.tsx
@@ -1,34 +1,31 @@
-import type { Metadata } from "next";
-import { Geist, Geist_Mono } from "next/font/google";
-import "./globals.css";
+import React from "react"
+import type { Metadata, Viewport } from 'next'
+import { JetBrains_Mono } from 'next/font/google'
 
-const geistSans = Geist({
-  variable: "--font-geist-sans",
-  subsets: ["latin"],
-});
+import './globals.css'
 
-const geistMono = Geist_Mono({
-  variable: "--font-geist-mono",
-  subsets: ["latin"],
-});
+const jetbrainsMono = JetBrains_Mono({
+  subsets: ['latin'],
+  variable: '--font-geist-mono',
+})
 
 export const metadata: Metadata = {
-  title: "Create Next App",
-  description: "Generated by create next app",
-};
+  title: 'CompileNConquer - Competitive Coding Arena',
+  description: 'A multiplayer competitive coding game that blends problem-solving depth with real-time racing excitement.',
+}
+
+export const viewport: Viewport = {
+  themeColor: '#00ff41',
+}
 
 export default function RootLayout({
   children,
 }: Readonly<{
-  children: React.ReactNode;
+  children: React.ReactNode
 }>) {
   return (
-    <html lang="en">
-      <body
-        className={`${geistSans.variable} ${geistMono.variable} antialiased`}
-      >
-        {children}
-      </body>
+    <html lang="en" className={jetbrainsMono.variable}>
+      <body className="font-mono antialiased">{children}</body>
     </html>
-  );
+  )
 }
diff --git a/app/page.tsx b/app/page.tsx
index 295f8fd..69a2aaa 100644
--- a/app/page.tsx
+++ b/app/page.tsx
@@ -1,65 +1,17 @@
-import Image from "next/image";
+import { Navbar } from "@/components/landing/navbar"
+import { Hero } from "@/components/landing/hero"
+import { Features } from "@/components/landing/features"
+import { GameModes } from "@/components/landing/game-modes"
+import { Footer } from "@/components/landing/footer"
 
-export default function Home() {
+export default function Page() {
   return (
-    <div className="flex min-h-screen items-center justify-center bg-zinc-50 font-sans dark:bg-black">
-      <main className="flex min-h-screen w-full max-w-3xl flex-col items-center justify-between py-32 px-16 bg-white dark:bg-black sm:items-start">
-        <Image
-          className="dark:invert"
-          src="/next.svg"
-          alt="Next.js logo"
-          width={100}
-          height={20}
-          priority
-        />
-        <div className="flex flex-col items-center gap-6 text-center sm:items-start sm:text-left">
-          <h1 className="max-w-xs text-3xl font-semibold leading-10 tracking-tight text-black dark:text-zinc-50">
-            To get started, edit the page.tsx file.
-          </h1>
-          <p className="max-w-md text-lg leading-8 text-zinc-600 dark:text-zinc-400">
-            Looking for a starting point or more instructions? Head over to{" "}
-            <a
-              href="https://vercel.com/templates?framework=next.js&utm_source=create-next-app&utm_medium=appdir-template-tw&utm_campaign=create-next-app"
-              className="font-medium text-zinc-950 dark:text-zinc-50"
-            >
-              Templates
-            </a>{" "}
-            or the{" "}
-            <a
-              href="https://nextjs.org/learn?utm_source=create-next-app&utm_medium=appdir-template-tw&utm_campaign=create-next-app"
-              className="font-medium text-zinc-950 dark:text-zinc-50"
-            >
-              Learning
-            </a>{" "}
-            center.
-          </p>
-        </div>
-        <div className="flex flex-col gap-4 text-base font-medium sm:flex-row">
-          <a
-            className="flex h-12 w-full items-center justify-center gap-2 rounded-full bg-foreground px-5 text-background transition-colors hover:bg-[#383838] dark:hover:bg-[#ccc] md:w-[158px]"
-            href="https://vercel.com/new?utm_source=create-next-app&utm_medium=appdir-template-tw&utm_campaign=create-next-app"
-            target="_blank"
-            rel="noopener noreferrer"
-          >
-            <Image
-              className="dark:invert"
-              src="/vercel.svg"
-              alt="Vercel logomark"
-              width={16}
-              height={16}
-            />
-            Deploy Now
-          </a>
-          <a
-            className="flex h-12 w-full items-center justify-center rounded-full border border-solid border-black/[.08] px-5 transition-colors hover:border-transparent hover:bg-black/[.04] dark:border-white/[.145] dark:hover:bg-[#1a1a1a] md:w-[158px]"
-            href="https://nextjs.org/docs?utm_source=create-next-app&utm_medium=appdir-template-tw&utm_campaign=create-next-app"
-            target="_blank"
-            rel="noopener noreferrer"
-          >
-            Documentation
-          </a>
-        </div>
-      </main>
-    </div>
-  );
+    <main className="min-h-screen">
+      <Navbar />
+      <Hero />
+      <Features />
+      <GameModes />
+      <Footer />
+    </main>
+  )
 }
diff --git a/app/profile/page.tsx b/app/profile/page.tsx
new file mode 100644
index 0000000..2d0f980
--- /dev/null
+++ b/app/profile/page.tsx
@@ -0,0 +1,186 @@
+import { Terminal, ArrowLeft, Trophy, Zap, Code, Target, Clock, TrendingUp } from "lucide-react"
+import Link from "next/link"
+
+const profile = {
+  name: "you",
+  rating: 1847,
+  rank: "#342",
+  title: "Code Warrior",
+  joined: "Jan 2026",
+  totalBattles: 128,
+  wins: 87,
+  losses: 41,
+  winRate: "68%",
+  totalXP: 24850,
+  streak: 7,
+}
+
+const stats = [
+  { label: "Battles", value: "128", icon: Target },
+  { label: "Win Rate", value: "68%", icon: TrendingUp },
+  { label: "XP", value: "24,850", icon: Zap },
+  { label: "Streak", value: "7", icon: Trophy },
+]
+
+const recentMatches = [
+  { opponent: "n3x_byte", result: "WIN", points: "+175", mode: "Scratch", date: "2 hrs ago" },
+  { opponent: "c0d3_wr4ith", result: "LOSS", points: "-50", mode: "Debug", date: "5 hrs ago" },
+  { opponent: "z3r0_day", result: "WIN", points: "+200", mode: "Reverse", date: "1 day ago" },
+  { opponent: "algo_gh0st", result: "WIN", points: "+150", mode: "Scratch", date: "1 day ago" },
+  { opponent: "byteB1aster", result: "WIN", points: "+180", mode: "Debug", date: "2 days ago" },
+]
+
+const skillBreakdown = [
+  { skill: "DSA", level: 78, color: "hsl(120 100% 50%)" },
+  { skill: "Clean Code", level: 85, color: "hsl(45 100% 50%)" },
+  { skill: "Speed", level: 62, color: "hsl(200 100% 50%)" },
+  { skill: "Debugging", level: 71, color: "hsl(0 80% 55%)" },
+  { skill: "Efficiency", level: 90, color: "hsl(120 80% 60%)" },
+]
+
+export default function ProfilePage() {
+  return (
+    <main className="min-h-screen bg-background">
+      {/* Top bar */}
+      <header className="border-b border-border px-4 py-3">
+        <div className="mx-auto flex max-w-5xl items-center justify-between">
+          <div className="flex items-center gap-3">
+            <Link
+              href="/"
+              className="flex items-center gap-1.5 text-muted-foreground transition-colors hover:text-primary"
+            >
+              <ArrowLeft className="h-3.5 w-3.5" />
+            </Link>
+            <div className="flex items-center gap-2">
+              <Terminal className="h-4 w-4 text-primary" />
+              <span className="text-xs font-bold uppercase tracking-widest text-foreground">
+                Profile Terminal
+              </span>
+            </div>
+          </div>
+          <Link
+            href="/arena"
+            className="rounded-sm border border-primary bg-primary px-4 py-1.5 text-xs font-bold uppercase tracking-widest text-primary-foreground transition-all hover:bg-primary/90"
+          >
+            Enter Arena
+          </Link>
+        </div>
+      </header>
+
+      <div className="mx-auto max-w-5xl px-4 py-8">
+        {/* Profile header */}
+        <div className="mb-8 flex flex-col gap-6 md:flex-row md:items-center md:gap-8">
+          <div className="flex h-20 w-20 items-center justify-center rounded-sm border border-primary/30 bg-primary/10 text-3xl font-bold text-primary">
+            Y
+          </div>
+          <div className="flex-1">
+            <div className="flex flex-wrap items-center gap-3">
+              <h1 className="text-2xl font-bold text-foreground">{profile.name}</h1>
+              <span className="rounded-sm border border-primary/30 bg-primary/10 px-2 py-0.5 text-xs text-primary">
+                {profile.title}
+              </span>
+            </div>
+            <div className="mt-2 flex flex-wrap items-center gap-4 text-xs text-muted-foreground">
+              <span>ELO: <span className="font-bold text-primary">{profile.rating}</span></span>
+              <span>Global Rank: <span className="font-bold text-foreground">{profile.rank}</span></span>
+              <span>Joined: {profile.joined}</span>
+            </div>
+          </div>
+        </div>
+
+        {/* Stats grid */}
+        <div className="mb-8 grid grid-cols-2 gap-3 md:grid-cols-4">
+          {stats.map((stat) => (
+            <div key={stat.label} className="rounded-sm border border-border bg-card p-4">
+              <div className="mb-2 flex items-center gap-2">
+                <stat.icon className="h-4 w-4 text-primary" />
+                <span className="text-xs uppercase tracking-widest text-muted-foreground">
+                  {stat.label}
+                </span>
+              </div>
+              <span className="text-2xl font-bold text-foreground">{stat.value}</span>
+            </div>
+          ))}
+        </div>
+
+        <div className="grid gap-6 lg:grid-cols-2">
+          {/* Skill breakdown */}
+          <div className="rounded-sm border border-border bg-card p-4">
+            <div className="mb-4 flex items-center gap-2">
+              <Code className="h-4 w-4 text-primary" />
+              <span className="text-xs uppercase tracking-widest text-primary">
+                Skill Breakdown
+              </span>
+            </div>
+            <div className="flex flex-col gap-4">
+              {skillBreakdown.map((s) => (
+                <div key={s.skill} className="flex flex-col gap-1.5">
+                  <div className="flex items-center justify-between">
+                    <span className="text-xs text-foreground">{s.skill}</span>
+                    <span className="text-xs text-muted-foreground">{s.level}%</span>
+                  </div>
+                  <div className="relative h-2 overflow-hidden rounded-sm bg-secondary">
+                    <div
+                      className="h-full rounded-sm transition-all"
+                      style={{
+                        width: `${s.level}%`,
+                        backgroundColor: s.color,
+                        opacity: 0.8,
+                      }}
+                    />
+                  </div>
+                </div>
+              ))}
+            </div>
+          </div>
+
+          {/* Recent matches */}
+          <div className="rounded-sm border border-border bg-card p-4">
+            <div className="mb-4 flex items-center gap-2">
+              <Clock className="h-4 w-4 text-primary" />
+              <span className="text-xs uppercase tracking-widest text-primary">
+                Recent Matches
+              </span>
+            </div>
+            <div className="flex flex-col">
+              {recentMatches.map((match, i) => (
+                <div
+                  key={i}
+                  className="flex items-center justify-between border-b border-border/50 py-3 last:border-b-0"
+                >
+                  <div className="flex items-center gap-3">
+                    <span
+                      className={`rounded-sm px-1.5 py-0.5 text-xs font-bold ${
+                        match.result === "WIN"
+                          ? "border border-primary/30 bg-primary/10 text-primary"
+                          : "border border-destructive/30 bg-destructive/10 text-destructive"
+                      }`}
+                    >
+                      {match.result}
+                    </span>
+                    <div className="flex flex-col">
+                      <span className="text-xs font-bold text-foreground">
+                        vs {match.opponent}
+                      </span>
+                      <span className="text-xs text-muted-foreground">{match.mode}</span>
+                    </div>
+                  </div>
+                  <div className="flex flex-col items-end">
+                    <span
+                      className={`text-xs font-bold ${
+                        match.points.startsWith("+") ? "text-primary" : "text-destructive"
+                      }`}
+                    >
+                      {match.points} XP
+                    </span>
+                    <span className="text-xs text-muted-foreground">{match.date}</span>
+                  </div>
+                </div>
+              ))}
+            </div>
+          </div>
+        </div>
+      </div>
+    </main>
+  )
+}
diff --git a/backbaord/evaluation.ts b/backbaord/evaluation.ts
new file mode 100644
index 0000000..8ecff07
--- /dev/null
+++ b/backbaord/evaluation.ts
@@ -0,0 +1,583 @@
+// ============================================================
+// Compile-n-Conquer — Evaluation Pipeline Engine
+// ============================================================
+// Orchestrates the 4-thread LLM evaluation pipeline via Backboard.io
+
+import { BackboardClient } from "backboard-sdk";
+import {
+  RoundSubmissions,
+  TimeComplexityResults,
+  SpaceComplexityResults,
+  OriginalityResults,
+  ComplexityResult,
+  OriginalityResult,
+  TestCaseResults,
+  ScoringWeights,
+  TiebreakerData,
+  RankedUser,
+  RoundEvaluation,
+  ScoreBreakdown,
+  EvaluationConfig,
+  DEFAULT_EVAL_CONFIG,
+} from "./types";
+import {
+  TIME_COMPLEXITY_TOOL,
+  SPACE_COMPLEXITY_TOOL,
+  ORIGINALITY_TOOL,
+  RANKING_TOOL,
+  SYSTEM_PROMPTS,
+} from "./tools";
+
+// Type for Backboard message responses
+type BBMessageResponse = {
+  content: string;
+  status: string;
+  toolCalls: Array<{
+    id: string;
+    function: { name: string; parsedArguments: any };
+  }> | null;
+  runId?: string;
+  threadId: string;
+};
+
+// ---- Helper: Build the batch prompt for a metric thread ----
+
+function buildBatchPrompt(
+  round: RoundSubmissions,
+  metricLabel: string
+): string {
+  let prompt = `## Round: ${round.roundId} — ${metricLabel} Analysis\n\n`;
+  prompt += `### Questions in this round:\n`;
+  for (const q of round.questions) {
+    prompt += `- **${q.id}** (${q.difficulty}): ${q.title}\n  ${q.description}\n\n`;
+  }
+
+  prompt += `### Submissions:\n\n`;
+  for (const sub of round.submissions) {
+    prompt += `#### User: ${sub.userId}\n`;
+    for (const resp of sub.responses) {
+      const question = round.questions.find((q) => q.id === resp.questionId);
+      prompt += `**Question ${resp.questionId}** (${resp.language}):\n`;
+      prompt += "```\n" + resp.code + "\n```\n\n";
+      prompt += `Call the tool for this submission with questionContext: "${question?.description || question?.title || resp.questionId}"\n\n`;
+    }
+  }
+
+  prompt += `\nAnalyze ALL submissions above. Call the tool once per submission.\n`;
+  return prompt;
+}
+
+// ---- Thread 1: Time Complexity ----
+
+export async function evaluateTimeComplexity(
+  client: BackboardClient,
+  round: RoundSubmissions,
+  config: EvaluationConfig = DEFAULT_EVAL_CONFIG
+): Promise<{ results: TimeComplexityResults; threadId: string }> {
+  const assistant = await client.createAssistant({
+    name: "CnC Time Complexity Analyzer",
+    system_prompt: SYSTEM_PROMPTS.timeComplexity,
+    tools: [TIME_COMPLEXITY_TOOL],
+  });
+
+  const thread = await client.createThread(assistant.assistantId);
+  const prompt = buildBatchPrompt(round, "Time Complexity");
+
+  let response = (await client.addMessage(thread.threadId, {
+    content: prompt,
+    llm_provider: config.llmProvider,
+    model_name: config.modelName,
+    stream: false,
+  })) as BBMessageResponse;
+
+  // Handle tool calls — collect all TC results
+  const results: Record<string, ComplexityResult[]> = {};
+  for (const sub of round.submissions) {
+    results[sub.userId] = [];
+  }
+
+  while (response.status === "REQUIRES_ACTION" && response.toolCalls) {
+    const toolOutputs = [];
+
+    for (const tc of response.toolCalls) {
+      if (tc.function.name === "analyze_time_complexity") {
+        const args = tc.function.parsedArguments;
+
+        // The LLM analyzed it — we acknowledge and capture
+        // In production, we could run our own static analysis here too
+        const analysisResult: ComplexityResult = {
+          questionId: args.questionContext || "unknown",
+          complexity: args.complexity || "unknown",
+          score: args.score || 50,
+          reasoning: args.reasoning || "No reasoning provided",
+        };
+
+        toolOutputs.push({
+          tool_call_id: tc.id,
+          output: JSON.stringify({
+            status: "recorded",
+            ...analysisResult,
+          }),
+        });
+      }
+    }
+
+    response = (await client.submitToolOutputs(
+      thread.threadId,
+      response.runId!,
+      toolOutputs,
+      false
+    )) as BBMessageResponse;
+  }
+
+  // Parse the final response content for structured results
+  const parsedResults = parseComplexityFromContent(
+    response.content,
+    round,
+    results
+  );
+
+  return {
+    results: {
+      roundId: round.roundId,
+      metric: "time_complexity",
+      results: parsedResults,
+    },
+    threadId: thread.threadId,
+  };
+}
+
+// ---- Thread 2: Space Complexity ----
+
+export async function evaluateSpaceComplexity(
+  client: BackboardClient,
+  round: RoundSubmissions,
+  config: EvaluationConfig = DEFAULT_EVAL_CONFIG
+): Promise<{ results: SpaceComplexityResults; threadId: string }> {
+  const assistant = await client.createAssistant({
+    name: "CnC Space Complexity Analyzer",
+    system_prompt: SYSTEM_PROMPTS.spaceComplexity,
+    tools: [SPACE_COMPLEXITY_TOOL],
+  });
+
+  const thread = await client.createThread(assistant.assistantId);
+  const prompt = buildBatchPrompt(round, "Space Complexity");
+
+  let response = (await client.addMessage(thread.threadId, {
+    content: prompt,
+    llm_provider: config.llmProvider,
+    model_name: config.modelName,
+    stream: false,
+  })) as BBMessageResponse;
+
+  const results: Record<string, ComplexityResult[]> = {};
+  for (const sub of round.submissions) {
+    results[sub.userId] = [];
+  }
+
+  while (response.status === "REQUIRES_ACTION" && response.toolCalls) {
+    const toolOutputs = [];
+
+    for (const tc of response.toolCalls) {
+      if (tc.function.name === "analyze_space_complexity") {
+        const args = tc.function.parsedArguments;
+        const analysisResult: ComplexityResult = {
+          questionId: args.questionContext || "unknown",
+          complexity: args.complexity || "unknown",
+          score: args.score || 50,
+          reasoning: args.reasoning || "No reasoning provided",
+        };
+
+        toolOutputs.push({
+          tool_call_id: tc.id,
+          output: JSON.stringify({ status: "recorded", ...analysisResult }),
+        });
+      }
+    }
+
+    response = (await client.submitToolOutputs(
+      thread.threadId,
+      response.runId!,
+      toolOutputs,
+      false
+    )) as BBMessageResponse;
+  }
+
+  const parsedResults = parseComplexityFromContent(
+    response.content,
+    round,
+    results
+  );
+
+  return {
+    results: {
+      roundId: round.roundId,
+      metric: "space_complexity",
+      results: parsedResults,
+    },
+    threadId: thread.threadId,
+  };
+}
+
+// ---- Thread 3: Originality & Relevance ----
+
+export async function evaluateOriginality(
+  client: BackboardClient,
+  round: RoundSubmissions,
+  config: EvaluationConfig = DEFAULT_EVAL_CONFIG
+): Promise<{ results: OriginalityResults; threadId: string }> {
+  const assistant = await client.createAssistant({
+    name: "CnC Originality Analyzer",
+    system_prompt: SYSTEM_PROMPTS.originality,
+    tools: [ORIGINALITY_TOOL],
+  });
+
+  const thread = await client.createThread(assistant.assistantId);
+  const prompt = buildBatchPrompt(round, "Originality & Relevance");
+
+  let response = (await client.addMessage(thread.threadId, {
+    content: prompt,
+    llm_provider: config.llmProvider,
+    model_name: config.modelName,
+    stream: false,
+  })) as BBMessageResponse;
+
+  const results: Record<string, OriginalityResult[]> = {};
+  for (const sub of round.submissions) {
+    results[sub.userId] = [];
+  }
+
+  while (response.status === "REQUIRES_ACTION" && response.toolCalls) {
+    const toolOutputs = [];
+
+    for (const tc of response.toolCalls) {
+      if (tc.function.name === "analyze_originality") {
+        const args = tc.function.parsedArguments;
+        const analysisResult: OriginalityResult = {
+          questionId: args.questionContext || "unknown",
+          originalityScore: args.originalityScore || 5,
+          relevanceScore: args.relevanceScore || 5,
+          commentDensity: args.commentDensity || 0,
+          flags: args.flags || [],
+          reasoning: args.reasoning || "No reasoning provided",
+        };
+
+        toolOutputs.push({
+          tool_call_id: tc.id,
+          output: JSON.stringify({ status: "recorded", ...analysisResult }),
+        });
+      }
+    }
+
+    response = (await client.submitToolOutputs(
+      thread.threadId,
+      response.runId!,
+      toolOutputs,
+      false
+    )) as BBMessageResponse;
+  }
+
+  const parsedResults = parseOriginalityFromContent(
+    response.content,
+    round,
+    results
+  );
+
+  return {
+    results: {
+      roundId: round.roundId,
+      metric: "originality",
+      results: parsedResults,
+    },
+    threadId: thread.threadId,
+  };
+}
+
+// ---- Thread 4: Final Ranking ----
+
+export async function computeRanking(
+  client: BackboardClient,
+  tcResults: TimeComplexityResults,
+  scResults: SpaceComplexityResults,
+  origResults: OriginalityResults,
+  testCaseResults: TestCaseResults,
+  weights: ScoringWeights,
+  tiebreakerData: TiebreakerData,
+  config: EvaluationConfig = DEFAULT_EVAL_CONFIG
+): Promise<{ rankings: RankedUser[]; threadId: string }> {
+  const assistant = await client.createAssistant({
+    name: "CnC Ranking Engine",
+    system_prompt: SYSTEM_PROMPTS.ranking,
+    tools: [RANKING_TOOL],
+  });
+
+  const thread = await client.createThread(assistant.assistantId);
+
+  const prompt = `Compute the final ranking for round ${tcResults.roundId}.
+
+Use the compute_final_ranking tool with the following data:
+- timeComplexityResults: ${JSON.stringify(tcResults)}
+- spaceComplexityResults: ${JSON.stringify(scResults)}
+- originalityResults: ${JSON.stringify(origResults)}
+- testCaseResults: ${JSON.stringify(testCaseResults)}
+- weights: ${JSON.stringify(weights)}
+- tiebreakerData: ${JSON.stringify(tiebreakerData)}
+
+Produce a final ranking with full score breakdowns for each user.`;
+
+  let response = (await client.addMessage(thread.threadId, {
+    content: prompt,
+    llm_provider: config.llmProvider,
+    model_name: config.modelName,
+    stream: false,
+  })) as BBMessageResponse;
+
+  while (response.status === "REQUIRES_ACTION" && response.toolCalls) {
+    const toolOutputs = [];
+
+    for (const tc of response.toolCalls) {
+      if (tc.function.name === "compute_final_ranking") {
+        // Let the LLM compute the ranking via tool — we can also verify locally
+        const localRanking = computeRankingLocally(
+          tcResults,
+          scResults,
+          origResults,
+          testCaseResults,
+          weights,
+          tiebreakerData
+        );
+
+        toolOutputs.push({
+          tool_call_id: tc.id,
+          output: JSON.stringify({ rankings: localRanking }),
+        });
+      }
+    }
+
+    response = (await client.submitToolOutputs(
+      thread.threadId,
+      response.runId!,
+      toolOutputs,
+      false
+    )) as BBMessageResponse;
+  }
+
+  // Use local computation as source of truth (LLM is for validation)
+  const rankings = computeRankingLocally(
+    tcResults,
+    scResults,
+    origResults,
+    testCaseResults,
+    weights,
+    tiebreakerData
+  );
+
+  return { rankings, threadId: thread.threadId };
+}
+
+// ---- Local Scoring Engine (deterministic, no LLM needed) ----
+
+export function computeRankingLocally(
+  tcResults: TimeComplexityResults,
+  scResults: SpaceComplexityResults,
+  origResults: OriginalityResults,
+  testCaseResults: TestCaseResults,
+  weights: ScoringWeights,
+  tiebreakerData: TiebreakerData
+): RankedUser[] {
+  const userIds = Object.keys(tcResults.results);
+  const scored: Array<{
+    userId: string;
+    finalScore: number;
+    breakdown: ScoreBreakdown;
+    timeTakenMs: number;
+  }> = [];
+
+  for (const userId of userIds) {
+    const tcScores = tcResults.results[userId] || [];
+    const scScores = scResults.results[userId] || [];
+    const origScores = origResults.results[userId] || [];
+    const testCase = testCaseResults[userId] || { passed: 0, total: 1 };
+
+    // Average TC score (out of 100)
+    const avgTcScore =
+      tcScores.length > 0
+        ? tcScores.reduce((sum, r) => sum + r.score, 0) / tcScores.length
+        : 0;
+
+    // Average SC score (out of 100)
+    const avgScScore =
+      scScores.length > 0
+        ? scScores.reduce((sum, r) => sum + r.score, 0) / scScores.length
+        : 0;
+
+    // Average originality score: combine originality (1-10) and relevance (1-10) → normalize to 100
+    const avgOrigScore =
+      origScores.length > 0
+        ? origScores.reduce(
+            (sum, r) =>
+              sum + ((r.originalityScore + r.relevanceScore) / 2) * 10,
+            0
+          ) / origScores.length
+        : 0;
+
+    // Test case pass rate → scale to 100
+    const testCaseScore =
+      testCase.total > 0 ? (testCase.passed / testCase.total) * 100 : 0;
+
+    // Weighted final score
+    const finalScore =
+      avgTcScore * weights.timeComplexity +
+      avgScScore * weights.spaceComplexity +
+      avgOrigScore * weights.originality +
+      testCaseScore * weights.testCases;
+
+    scored.push({
+      userId,
+      finalScore: Math.round(finalScore * 100) / 100,
+      breakdown: {
+        timeComplexity: {
+          avgScore: Math.round(avgTcScore * 100) / 100,
+          weighted:
+            Math.round(avgTcScore * weights.timeComplexity * 100) / 100,
+        },
+        spaceComplexity: {
+          avgScore: Math.round(avgScScore * 100) / 100,
+          weighted:
+            Math.round(avgScScore * weights.spaceComplexity * 100) / 100,
+        },
+        originality: {
+          avgScore: Math.round(avgOrigScore * 100) / 100,
+          weighted:
+            Math.round(avgOrigScore * weights.originality * 100) / 100,
+        },
+        testCases: {
+          passRate: testCase.total > 0 ? testCase.passed / testCase.total : 0,
+          weighted:
+            Math.round(testCaseScore * weights.testCases * 100) / 100,
+        },
+      },
+      timeTakenMs: tiebreakerData[userId] || Infinity,
+    });
+  }
+
+  // Sort: highest score first, then lowest time (tiebreaker)
+  scored.sort((a, b) => {
+    if (b.finalScore !== a.finalScore) return b.finalScore - a.finalScore;
+    return a.timeTakenMs - b.timeTakenMs; // lower time wins
+  });
+
+  return scored.map((s, i) => ({
+    rank: i + 1,
+    ...s,
+  }));
+}
+
+// ---- Full Pipeline Orchestrator ----
+
+export async function runEvaluationPipeline(
+  round: RoundSubmissions,
+  testCaseResults: TestCaseResults,
+  tiebreakerData: TiebreakerData,
+  weights: ScoringWeights,
+  config: EvaluationConfig = DEFAULT_EVAL_CONFIG
+): Promise<RoundEvaluation> {
+  const client = new BackboardClient({
+    apiKey: process.env.BACKBOARD_API_KEY!,
+  });
+
+  // Threads 1-3 run in parallel
+  const [tcResult, scResult, origResult] = await Promise.all([
+    evaluateTimeComplexity(client, round, config),
+    evaluateSpaceComplexity(client, round, config),
+    evaluateOriginality(client, round, config),
+  ]);
+
+  // Thread 4: aggregation (depends on 1-3)
+  const rankingResult = await computeRanking(
+    client,
+    tcResult.results,
+    scResult.results,
+    origResult.results,
+    testCaseResults,
+    weights,
+    tiebreakerData,
+    config
+  );
+
+  return {
+    roundId: round.roundId,
+    evaluationId: `eval_${round.roundId}_${Date.now()}`,
+    rankings: rankingResult.rankings,
+    threadIds: {
+      timeComplexity: tcResult.threadId,
+      spaceComplexity: scResult.threadId,
+      originality: origResult.threadId,
+      ranking: rankingResult.threadId,
+    },
+    evaluatedAt: new Date().toISOString(),
+  };
+}
+
+// ---- Content Parsers (extract structured data from LLM final response) ----
+
+function parseComplexityFromContent(
+  content: string,
+  round: RoundSubmissions,
+  fallback: Record<string, ComplexityResult[]>
+): Record<string, ComplexityResult[]> {
+  // Try to parse JSON from LLM response
+  try {
+    const jsonMatch = content.match(/\{[\s\S]*\}/);
+    if (jsonMatch) {
+      const parsed = JSON.parse(jsonMatch[0]);
+      if (parsed.results) return parsed.results;
+    }
+  } catch {
+    // Fall through to fallback
+  }
+
+  // If parsing fails, return whatever was collected from tool calls
+  // or generate defaults
+  for (const sub of round.submissions) {
+    if (!fallback[sub.userId] || fallback[sub.userId].length === 0) {
+      fallback[sub.userId] = sub.responses.map((r) => ({
+        questionId: r.questionId,
+        complexity: "unknown",
+        score: 50,
+        reasoning: "Could not extract from LLM response",
+      }));
+    }
+  }
+  return fallback;
+}
+
+function parseOriginalityFromContent(
+  content: string,
+  round: RoundSubmissions,
+  fallback: Record<string, OriginalityResult[]>
+): Record<string, OriginalityResult[]> {
+  try {
+    const jsonMatch = content.match(/\{[\s\S]*\}/);
+    if (jsonMatch) {
+      const parsed = JSON.parse(jsonMatch[0]);
+      if (parsed.results) return parsed.results;
+    }
+  } catch {
+    // Fall through
+  }
+
+  for (const sub of round.submissions) {
+    if (!fallback[sub.userId] || fallback[sub.userId].length === 0) {
+      fallback[sub.userId] = sub.responses.map((r) => ({
+        questionId: r.questionId,
+        originalityScore: 5,
+        relevanceScore: 5,
+        commentDensity: 0,
+        flags: [],
+        reasoning: "Could not extract from LLM response",
+      }));
+    }
+  }
+  return fallback;
+}
diff --git a/backbaord/index.ts b/backbaord/index.ts
new file mode 100644
index 0000000..3656907
--- /dev/null
+++ b/backbaord/index.ts
@@ -0,0 +1,9 @@
+// ============================================================
+// Compile-n-Conquer — Backboard Evaluation Pipeline
+// ============================================================
+// Barrel export for all modules
+
+export * from "./types";
+export * from "./tools";
+export * from "./evaluation";
+export * from "./memory";
diff --git a/backbaord/memory.ts b/backbaord/memory.ts
new file mode 100644
index 0000000..60b8b4c
--- /dev/null
+++ b/backbaord/memory.ts
@@ -0,0 +1,204 @@
+// ============================================================
+// Compile-n-Conquer — Memory / Skill Tier Engine
+// ============================================================
+
+import { BackboardClient } from "backboard-sdk";
+import {
+  PlayerProfile,
+  SkillTier,
+  RoundScore,
+  TierChange,
+  EvaluationConfig,
+  DEFAULT_EVAL_CONFIG,
+} from "./types";
+import { SYSTEM_PROMPTS } from "./tools";
+
+// ---- Skill Tier Thresholds ----
+
+const TIER_THRESHOLDS: Record<SkillTier, { min: number; max: number }> = {
+  beginner: { min: 0, max: 30 },
+  intermediate: { min: 30, max: 60 },
+  advanced: { min: 60, max: 85 },
+  pro: { min: 85, max: 100 },
+};
+
+const PROMOTION_STREAK = 3; // consecutive rounds needed to promote
+const DEMOTION_STREAK = 2;  // consecutive rounds needed to demote
+
+// ---- Classify Tier from Score ----
+
+export function classifyTier(avgScore: number): SkillTier {
+  if (avgScore >= TIER_THRESHOLDS.pro.min) return "pro";
+  if (avgScore >= TIER_THRESHOLDS.advanced.min) return "advanced";
+  if (avgScore >= TIER_THRESHOLDS.intermediate.min) return "intermediate";
+  return "beginner";
+}
+
+// ---- Check Promotion / Demotion ----
+
+export function evaluateTierChange(
+  currentTier: SkillTier,
+  roundHistory: RoundScore[]
+): { newTier: SkillTier; changed: boolean; reason: string } {
+  if (roundHistory.length === 0) {
+    return { newTier: currentTier, changed: false, reason: "No round history" };
+  }
+
+  const tierOrder: SkillTier[] = ["beginner", "intermediate", "advanced", "pro"];
+  const currentIdx = tierOrder.indexOf(currentTier);
+
+  // Check promotion (last N rounds all qualify for next tier)
+  if (currentIdx < tierOrder.length - 1) {
+    const nextTier = tierOrder[currentIdx + 1];
+    const nextThreshold = TIER_THRESHOLDS[nextTier].min;
+    const recentForPromotion = roundHistory.slice(-PROMOTION_STREAK);
+
+    if (
+      recentForPromotion.length >= PROMOTION_STREAK &&
+      recentForPromotion.every((r) => r.finalScore >= nextThreshold)
+    ) {
+      return {
+        newTier: nextTier,
+        changed: true,
+        reason: `${PROMOTION_STREAK} consecutive rounds with avg score ≥ ${nextThreshold} → promoted to ${nextTier}`,
+      };
+    }
+  }
+
+  // Check demotion (last N rounds all fall below current tier)
+  if (currentIdx > 0) {
+    const currentThreshold = TIER_THRESHOLDS[currentTier].min;
+    const recentForDemotion = roundHistory.slice(-DEMOTION_STREAK);
+
+    if (
+      recentForDemotion.length >= DEMOTION_STREAK &&
+      recentForDemotion.every((r) => r.finalScore < currentThreshold)
+    ) {
+      const prevTier = tierOrder[currentIdx - 1];
+      return {
+        newTier: prevTier,
+        changed: true,
+        reason: `${DEMOTION_STREAK} consecutive rounds with avg score < ${currentThreshold} → demoted to ${prevTier}`,
+      };
+    }
+  }
+
+  return { newTier: currentTier, changed: false, reason: "No tier change" };
+}
+
+// ---- Update Player Profile After a Round ----
+
+export function updatePlayerProfile(
+  profile: PlayerProfile,
+  roundScore: RoundScore
+): PlayerProfile {
+  const updatedHistory = [...profile.roundHistory, roundScore];
+
+  // Recalculate avg score from last 5 rounds
+  const recentRounds = updatedHistory.slice(-5);
+  const avgScore =
+    recentRounds.reduce((sum, r) => sum + r.finalScore, 0) /
+    recentRounds.length;
+
+  // Check tier change
+  const tierResult = evaluateTierChange(profile.skillTier, updatedHistory);
+
+  const promotionHistory = [...profile.promotionHistory];
+  if (tierResult.changed) {
+    promotionHistory.push({
+      from: profile.skillTier,
+      to: tierResult.newTier,
+      reason: tierResult.reason,
+      changedAt: new Date().toISOString(),
+    });
+  }
+
+  return {
+    ...profile,
+    skillTier: tierResult.newTier,
+    avgScore: Math.round(avgScore * 100) / 100,
+    roundHistory: updatedHistory,
+    promotionHistory,
+  };
+}
+
+// ---- Store Memory via Backboard ----
+
+export async function storePlayerMemory(
+  client: BackboardClient,
+  profile: PlayerProfile,
+  config: EvaluationConfig = DEFAULT_EVAL_CONFIG
+): Promise<{ threadId: string; memoryOperationId?: string }> {
+  const assistant = await client.createAssistant({
+    name: "CnC Player Memory Manager",
+    system_prompt: SYSTEM_PROMPTS.memory,
+  });
+
+  const thread = await client.createThread(assistant.assistantId);
+
+  const memoryMessage = `
+Player Profile Update:
+
+User: ${profile.userId}
+Current Tier: ${profile.skillTier}
+Average Score: ${profile.avgScore}
+
+Round History (last 5):
+${profile.roundHistory
+  .slice(-5)
+  .map((r) => `- Round ${r.roundId}: Score ${r.finalScore}, Rank #${r.rank}`)
+  .join("\n")}
+
+Common Errors: ${profile.commonErrors.join(", ") || "None recorded"}
+Preferred Algorithms: ${profile.preferredAlgorithms.join(", ") || "None recorded"}
+
+Tier Changes:
+${
+  profile.promotionHistory.length > 0
+    ? profile.promotionHistory
+        .slice(-3)
+        .map((tc) => `- ${tc.from} → ${tc.to}: ${tc.reason}`)
+        .join("\n")
+    : "No tier changes yet"
+}
+
+Remember this profile for personalized coaching and adaptive difficulty.
+`;
+
+  const response = (await client.addMessage(thread.threadId, {
+    content: memoryMessage,
+    memory: "Auto",
+    stream: false,
+  })) as any;
+
+  return {
+    threadId: thread.threadId,
+    memoryOperationId: response.memoryOperationId,
+  };
+}
+
+// ---- Retrieve Player Context from Memory ----
+
+export async function retrievePlayerMemory(
+  client: BackboardClient,
+  userId: string,
+  config: EvaluationConfig = DEFAULT_EVAL_CONFIG
+): Promise<{ content: string; threadId: string }> {
+  const assistant = await client.createAssistant({
+    name: "CnC Player Memory Manager",
+    system_prompt: SYSTEM_PROMPTS.memory,
+  });
+
+  const thread = await client.createThread(assistant.assistantId);
+
+  const response = (await client.addMessage(thread.threadId, {
+    content: `Retrieve everything you remember about user ${userId}. Provide their current skill tier, recent performance trends, areas for improvement, and personalized coaching recommendations.`,
+    memory: "Auto",
+    stream: false,
+  })) as any;
+
+  return {
+    content: response.content,
+    threadId: thread.threadId,
+  };
+}
diff --git a/backbaord/mock-test.ts b/backbaord/mock-test.ts
new file mode 100644
index 0000000..5c92d59
--- /dev/null
+++ b/backbaord/mock-test.ts
@@ -0,0 +1,869 @@
+// ============================================================
+// Compile-n-Conquer — Mock Test Suite
+// ============================================================
+// Run: npx tsx backbaord/mock-test.ts
+
+// NOTE: We import types directly and scoring/memory functions inline
+// to avoid pulling in backboard-sdk (which has ESM export issues in tsx).
+// In production, use the barrel export from ./index.ts
+
+import {
+  RoundSubmissions,
+  TimeComplexityResults,
+  SpaceComplexityResults,
+  OriginalityResults,
+  TestCaseResults,
+  ScoringWeights,
+  TiebreakerData,
+  DEFAULT_WEIGHTS,
+  PlayerProfile,
+  RoundScore,
+  RankedUser,
+  ScoreBreakdown,
+  SkillTier,
+} from "./types";
+
+// ---- Inline: computeRankingLocally (from evaluation.ts) ----
+
+function computeRankingLocally(
+  tcResults: TimeComplexityResults,
+  scResults: SpaceComplexityResults,
+  origResults: OriginalityResults,
+  testCaseResults: TestCaseResults,
+  weights: ScoringWeights,
+  tiebreakerData: TiebreakerData
+): RankedUser[] {
+  const userIds = Object.keys(tcResults.results);
+  const scored: Array<{
+    userId: string;
+    finalScore: number;
+    breakdown: ScoreBreakdown;
+    timeTakenMs: number;
+  }> = [];
+
+  for (const userId of userIds) {
+    const tcScores = tcResults.results[userId] || [];
+    const scScores = scResults.results[userId] || [];
+    const origScores = origResults.results[userId] || [];
+    const testCase = testCaseResults[userId] || { passed: 0, total: 1 };
+
+    const avgTcScore =
+      tcScores.length > 0
+        ? tcScores.reduce((sum, r) => sum + r.score, 0) / tcScores.length
+        : 0;
+    const avgScScore =
+      scScores.length > 0
+        ? scScores.reduce((sum, r) => sum + r.score, 0) / scScores.length
+        : 0;
+    const avgOrigScore =
+      origScores.length > 0
+        ? origScores.reduce(
+            (sum, r) =>
+              sum + ((r.originalityScore + r.relevanceScore) / 2) * 10,
+            0
+          ) / origScores.length
+        : 0;
+    const testCaseScore =
+      testCase.total > 0 ? (testCase.passed / testCase.total) * 100 : 0;
+
+    const finalScore =
+      avgTcScore * weights.timeComplexity +
+      avgScScore * weights.spaceComplexity +
+      avgOrigScore * weights.originality +
+      testCaseScore * weights.testCases;
+
+    scored.push({
+      userId,
+      finalScore: Math.round(finalScore * 100) / 100,
+      breakdown: {
+        timeComplexity: {
+          avgScore: Math.round(avgTcScore * 100) / 100,
+          weighted: Math.round(avgTcScore * weights.timeComplexity * 100) / 100,
+        },
+        spaceComplexity: {
+          avgScore: Math.round(avgScScore * 100) / 100,
+          weighted: Math.round(avgScScore * weights.spaceComplexity * 100) / 100,
+        },
+        originality: {
+          avgScore: Math.round(avgOrigScore * 100) / 100,
+          weighted: Math.round(avgOrigScore * weights.originality * 100) / 100,
+        },
+        testCases: {
+          passRate: testCase.total > 0 ? testCase.passed / testCase.total : 0,
+          weighted: Math.round(testCaseScore * weights.testCases * 100) / 100,
+        },
+      },
+      timeTakenMs: tiebreakerData[userId] || Infinity,
+    });
+  }
+
+  scored.sort((a, b) => {
+    if (b.finalScore !== a.finalScore) return b.finalScore - a.finalScore;
+    return a.timeTakenMs - b.timeTakenMs;
+  });
+
+  return scored.map((s, i) => ({ rank: i + 1, ...s }));
+}
+
+// ---- Inline: Tier functions (from memory.ts) ----
+
+const TIER_THRESHOLDS: Record<SkillTier, { min: number; max: number }> = {
+  beginner: { min: 0, max: 30 },
+  intermediate: { min: 30, max: 60 },
+  advanced: { min: 60, max: 85 },
+  pro: { min: 85, max: 100 },
+};
+
+function classifyTier(avgScore: number): SkillTier {
+  if (avgScore >= TIER_THRESHOLDS.pro.min) return "pro";
+  if (avgScore >= TIER_THRESHOLDS.advanced.min) return "advanced";
+  if (avgScore >= TIER_THRESHOLDS.intermediate.min) return "intermediate";
+  return "beginner";
+}
+
+function evaluateTierChange(
+  currentTier: SkillTier,
+  roundHistory: RoundScore[]
+): { newTier: SkillTier; changed: boolean; reason: string } {
+  if (roundHistory.length === 0) {
+    return { newTier: currentTier, changed: false, reason: "No round history" };
+  }
+  const tierOrder: SkillTier[] = ["beginner", "intermediate", "advanced", "pro"];
+  const currentIdx = tierOrder.indexOf(currentTier);
+
+  if (currentIdx < tierOrder.length - 1) {
+    const nextTier = tierOrder[currentIdx + 1];
+    const nextThreshold = TIER_THRESHOLDS[nextTier].min;
+    const recentForPromotion = roundHistory.slice(-3);
+    if (
+      recentForPromotion.length >= 3 &&
+      recentForPromotion.every((r) => r.finalScore >= nextThreshold)
+    ) {
+      return {
+        newTier: nextTier,
+        changed: true,
+        reason: `3 consecutive rounds with avg score ≥ ${nextThreshold} → promoted to ${nextTier}`,
+      };
+    }
+  }
+
+  if (currentIdx > 0) {
+    const currentThreshold = TIER_THRESHOLDS[currentTier].min;
+    const recentForDemotion = roundHistory.slice(-2);
+    if (
+      recentForDemotion.length >= 2 &&
+      recentForDemotion.every((r) => r.finalScore < currentThreshold)
+    ) {
+      const prevTier = tierOrder[currentIdx - 1];
+      return {
+        newTier: prevTier,
+        changed: true,
+        reason: `2 consecutive rounds with avg score < ${currentThreshold} → demoted to ${prevTier}`,
+      };
+    }
+  }
+
+  return { newTier: currentTier, changed: false, reason: "No tier change" };
+}
+
+function updatePlayerProfile(
+  profile: PlayerProfile,
+  roundScore: RoundScore
+): PlayerProfile {
+  const updatedHistory = [...profile.roundHistory, roundScore];
+  const recentRounds = updatedHistory.slice(-5);
+  const avgScore =
+    recentRounds.reduce((sum, r) => sum + r.finalScore, 0) / recentRounds.length;
+  const tierResult = evaluateTierChange(profile.skillTier, updatedHistory);
+  const promotionHistory = [...profile.promotionHistory];
+  if (tierResult.changed) {
+    promotionHistory.push({
+      from: profile.skillTier,
+      to: tierResult.newTier,
+      reason: tierResult.reason,
+      changedAt: new Date().toISOString(),
+    });
+  }
+  return {
+    ...profile,
+    skillTier: tierResult.newTier,
+    avgScore: Math.round(avgScore * 100) / 100,
+    roundHistory: updatedHistory,
+    promotionHistory,
+  };
+}
+
+// ============================================================
+// TEST DATA — 3 users, 3 questions, 1 round
+// ============================================================
+
+const MOCK_ROUND: RoundSubmissions = {
+  roundId: "round_1",
+  questions: [
+    {
+      id: "q1",
+      title: "Two Sum",
+      description: "Given an array of integers and a target, return indices of two numbers that add up to the target.",
+      difficulty: "easy",
+    },
+    {
+      id: "q2",
+      title: "Longest Substring Without Repeating Characters",
+      description: "Find the length of the longest substring without repeating characters.",
+      difficulty: "medium",
+    },
+    {
+      id: "q3",
+      title: "Merge K Sorted Lists",
+      description: "Merge k sorted linked lists into one sorted linked list.",
+      difficulty: "hard",
+    },
+  ],
+  submissions: [
+    {
+      userId: "user_1",
+      responses: [
+        {
+          questionId: "q1",
+          language: "python",
+          submittedAt: "2026-02-09T10:05:00Z",
+          code: `def two_sum(nums, target):
+    seen = {}
+    for i, num in enumerate(nums):
+        comp = target - num
+        if comp in seen:
+            return [seen[comp], i]
+        seen[num] = i
+    return []`,
+        },
+        {
+          questionId: "q2",
+          language: "python",
+          submittedAt: "2026-02-09T10:15:00Z",
+          code: `def length_of_longest_substring(s):
+    char_set = set()
+    l = 0
+    result = 0
+    for r in range(len(s)):
+        while s[r] in char_set:
+            char_set.remove(s[l])
+            l += 1
+        char_set.add(s[r])
+        result = max(result, r - l + 1)
+    return result`,
+        },
+        {
+          questionId: "q3",
+          language: "python",
+          submittedAt: "2026-02-09T10:30:00Z",
+          code: `import heapq
+def merge_k_lists(lists):
+    heap = []
+    for i, l in enumerate(lists):
+        if l:
+            heapq.heappush(heap, (l.val, i, l))
+    dummy = ListNode(0)
+    curr = dummy
+    while heap:
+        val, i, node = heapq.heappop(heap)
+        curr.next = node
+        curr = curr.next
+        if node.next:
+            heapq.heappush(heap, (node.next.val, i, node.next))
+    return dummy.next`,
+        },
+      ],
+    },
+    {
+      userId: "user_2",
+      responses: [
+        {
+          questionId: "q1",
+          language: "cpp",
+          submittedAt: "2026-02-09T10:03:00Z",
+          code: `vector<int> twoSum(vector<int>& nums, int target) {
+    // This function finds two numbers that sum to target
+    // It uses a brute force approach to check all pairs
+    // Time complexity: O(n^2)
+    // Space complexity: O(1)
+    for (int i = 0; i < nums.size(); i++) {
+        // Iterate through each element
+        for (int j = i + 1; j < nums.size(); j++) {
+            // Check if the pair sums to target
+            if (nums[i] + nums[j] == target) {
+                // Return the indices
+                return {i, j};
+            }
+        }
+    }
+    // Return empty if no pair found
+    return {};
+}`,
+        },
+        {
+          questionId: "q2",
+          language: "cpp",
+          submittedAt: "2026-02-09T10:18:00Z",
+          code: `int lengthOfLongestSubstring(string s) {
+    unordered_set<char> chars;
+    int l = 0, res = 0;
+    for (int r = 0; r < s.size(); r++) {
+        while (chars.count(s[r])) {
+            chars.erase(s[l]);
+            l++;
+        }
+        chars.insert(s[r]);
+        res = max(res, r - l + 1);
+    }
+    return res;
+}`,
+        },
+        {
+          questionId: "q3",
+          language: "cpp",
+          submittedAt: "2026-02-09T10:28:00Z",
+          code: `ListNode* mergeKLists(vector<ListNode*>& lists) {
+    auto cmp = [](ListNode* a, ListNode* b) { return a->val > b->val; };
+    priority_queue<ListNode*, vector<ListNode*>, decltype(cmp)> pq(cmp);
+    for (auto l : lists) if (l) pq.push(l);
+    ListNode dummy(0);
+    ListNode* curr = &dummy;
+    while (!pq.empty()) {
+        curr->next = pq.top(); pq.pop();
+        curr = curr->next;
+        if (curr->next) pq.push(curr->next);
+    }
+    return dummy.next;
+}`,
+        },
+      ],
+    },
+    {
+      userId: "user_3",
+      responses: [
+        {
+          questionId: "q1",
+          language: "javascript",
+          submittedAt: "2026-02-09T10:08:00Z",
+          code: `/**
+ * @param {number[]} nums - Array of integers
+ * @param {number} target - Target sum
+ * @returns {number[]} - Indices of two numbers
+ * @description This function implements the Two Sum algorithm
+ * using a hash map for O(n) time complexity
+ */
+function twoSum(nums, target) {
+    // Create a hash map to store values and their indices
+    const map = new Map();
+    // Iterate through each number in the array
+    for (let i = 0; i < nums.length; i++) {
+        // Calculate the complement
+        const complement = target - nums[i];
+        // Check if complement exists in our map
+        if (map.has(complement)) {
+            // Return the pair of indices
+            return [map.get(complement), i];
+        }
+        // Store current number and its index
+        map.set(nums[i], i);
+    }
+    // Return empty array if no solution found
+    return [];
+}`,
+        },
+        {
+          questionId: "q2",
+          language: "javascript",
+          submittedAt: "2026-02-09T10:22:00Z",
+          code: `function lengthOfLongestSubstring(s) {
+    let max = 0;
+    for (let i = 0; i < s.length; i++) {
+        let seen = new Set();
+        for (let j = i; j < s.length; j++) {
+            if (seen.has(s[j])) break;
+            seen.add(s[j]);
+            max = Math.max(max, j - i + 1);
+        }
+    }
+    return max;
+}`,
+        },
+        {
+          questionId: "q3",
+          language: "javascript",
+          submittedAt: "2026-02-09T10:40:00Z",
+          code: `// didnt finish this one
+function mergeKLists(lists) {
+    if (!lists.length) return null;
+    return lists[0]; // just returning first list lol
+}`,
+        },
+      ],
+    },
+  ],
+};
+
+// ---- Mock LLM Outputs (what Threads 1-3 would return) ----
+
+const MOCK_TC_RESULTS: TimeComplexityResults = {
+  roundId: "round_1",
+  metric: "time_complexity",
+  results: {
+    user_1: [
+      { questionId: "q1", complexity: "O(n)", score: 95, reasoning: "Single-pass hash map approach" },
+      { questionId: "q2", complexity: "O(n)", score: 92, reasoning: "Sliding window, each char processed at most twice" },
+      { questionId: "q3", complexity: "O(N log k)", score: 90, reasoning: "Min-heap with k elements" },
+    ],
+    user_2: [
+      { questionId: "q1", complexity: "O(n²)", score: 40, reasoning: "Brute force nested loops" },
+      { questionId: "q2", complexity: "O(n)", score: 92, reasoning: "Sliding window technique" },
+      { questionId: "q3", complexity: "O(N log k)", score: 90, reasoning: "Priority queue approach" },
+    ],
+    user_3: [
+      { questionId: "q1", complexity: "O(n)", score: 95, reasoning: "Hash map single pass" },
+      { questionId: "q2", complexity: "O(n²)", score: 35, reasoning: "Brute force nested loop approach" },
+      { questionId: "q3", complexity: "O(1)", score: 5, reasoning: "No real solution, just returns first list" },
+    ],
+  },
+};
+
+const MOCK_SC_RESULTS: SpaceComplexityResults = {
+  roundId: "round_1",
+  metric: "space_complexity",
+  results: {
+    user_1: [
+      { questionId: "q1", complexity: "O(n)", score: 80, reasoning: "Hash map stores up to n elements" },
+      { questionId: "q2", complexity: "O(min(n,m))", score: 85, reasoning: "Set bounded by alphabet size" },
+      { questionId: "q3", complexity: "O(k)", score: 90, reasoning: "Heap of size k" },
+    ],
+    user_2: [
+      { questionId: "q1", complexity: "O(1)", score: 100, reasoning: "No extra space" },
+      { questionId: "q2", complexity: "O(min(n,m))", score: 85, reasoning: "Set for window chars" },
+      { questionId: "q3", complexity: "O(k)", score: 90, reasoning: "Priority queue of size k" },
+    ],
+    user_3: [
+      { questionId: "q1", complexity: "O(n)", score: 80, reasoning: "Map stores values" },
+      { questionId: "q2", complexity: "O(n)", score: 70, reasoning: "New set per iteration, up to n" },
+      { questionId: "q3", complexity: "O(1)", score: 100, reasoning: "No extra space (but no real solution)" },
+    ],
+  },
+};
+
+const MOCK_ORIG_RESULTS: OriginalityResults = {
+  roundId: "round_1",
+  metric: "originality",
+  results: {
+    user_1: [
+      { questionId: "q1", originalityScore: 9, relevanceScore: 10, commentDensity: 0, flags: [], reasoning: "Clean, human-style competitive code" },
+      { questionId: "q2", originalityScore: 9, relevanceScore: 10, commentDensity: 0, flags: [], reasoning: "Idiomatic sliding window" },
+      { questionId: "q3", originalityScore: 8, relevanceScore: 10, commentDensity: 0, flags: [], reasoning: "Standard heap approach, well-written" },
+    ],
+    user_2: [
+      { questionId: "q1", originalityScore: 3, relevanceScore: 9, commentDensity: 55, flags: ["excessive_comments", "boilerplate_docstrings"], reasoning: "Every line has an explanatory comment — strong GPT signal" },
+      { questionId: "q2", originalityScore: 8, relevanceScore: 10, commentDensity: 0, flags: [], reasoning: "Clean competitive code" },
+      { questionId: "q3", originalityScore: 8, relevanceScore: 10, commentDensity: 0, flags: [], reasoning: "Concise and idiomatic" },
+    ],
+    user_3: [
+      { questionId: "q1", originalityScore: 2, relevanceScore: 10, commentDensity: 62, flags: ["excessive_comments", "boilerplate_docstrings", "generic_variable_names"], reasoning: "JSDoc + line-by-line comments strongly suggest AI generation" },
+      { questionId: "q2", originalityScore: 7, relevanceScore: 8, commentDensity: 0, flags: [], reasoning: "Human-style brute force" },
+      { questionId: "q3", originalityScore: 6, relevanceScore: 1, commentDensity: 10, flags: [], reasoning: "Honest comment about not finishing, but doesn't solve the problem" },
+    ],
+  },
+};
+
+const MOCK_TEST_CASES: TestCaseResults = {
+  user_1: { passed: 28, total: 30 },
+  user_2: { passed: 25, total: 30 },
+  user_3: { passed: 15, total: 30 },
+};
+
+const MOCK_TIEBREAKER: TiebreakerData = {
+  user_1: 1500000, // 25 min
+  user_2: 1500000, // 25 min (same as user_1 to test tiebreaker)
+  user_3: 1920000, // 32 min
+};
+
+// ============================================================
+// TEST RUNNER
+// ============================================================
+
+function assert(condition: boolean, message: string) {
+  if (condition) {
+    console.log(`  ✅ PASS: ${message}`);
+  } else {
+    console.error(`  ❌ FAIL: ${message}`);
+    process.exitCode = 1;
+  }
+}
+
+function section(title: string) {
+  console.log(`\n${"=".repeat(60)}`);
+  console.log(`  ${title}`);
+  console.log("=".repeat(60));
+}
+
+// ---- Test 1: Local Ranking Computation ----
+
+function testRankingComputation() {
+  section("Test 1: Ranking Computation with Default Weights");
+
+  const rankings = computeRankingLocally(
+    MOCK_TC_RESULTS,
+    MOCK_SC_RESULTS,
+    MOCK_ORIG_RESULTS,
+    MOCK_TEST_CASES,
+    DEFAULT_WEIGHTS,
+    MOCK_TIEBREAKER
+  );
+
+  console.log("\n  Rankings:");
+  for (const r of rankings) {
+    console.log(
+      `  #${r.rank} ${r.userId} — Score: ${r.finalScore} | TC: ${r.breakdown.timeComplexity.weighted} | SC: ${r.breakdown.spaceComplexity.weighted} | Orig: ${r.breakdown.originality.weighted} | Tests: ${r.breakdown.testCases.weighted}`
+    );
+  }
+
+  assert(rankings.length === 3, "3 users ranked");
+  assert(rankings[0].rank === 1, "Rank 1 assigned");
+  assert(rankings[1].rank === 2, "Rank 2 assigned");
+  assert(rankings[2].rank === 3, "Rank 3 assigned");
+  assert(rankings[0].finalScore >= rankings[1].finalScore, "Rank 1 score ≥ Rank 2 score");
+  assert(rankings[1].finalScore >= rankings[2].finalScore, "Rank 2 score ≥ Rank 3 score");
+  assert(rankings[0].userId === "user_1", "User 1 should be ranked first (best overall)");
+  assert(rankings[2].userId === "user_3", "User 3 should be ranked last (incomplete submission)");
+
+  return rankings;
+}
+
+// ---- Test 2: Tiebreaker Logic ----
+
+function testTiebreaker() {
+  section("Test 2: Tiebreaker — Same Scores, Different Times");
+
+  // Create identical scores for two users
+  const identicalTC: TimeComplexityResults = {
+    roundId: "round_tie",
+    metric: "time_complexity",
+    results: {
+      user_a: [{ questionId: "q1", complexity: "O(n)", score: 80, reasoning: "" }],
+      user_b: [{ questionId: "q1", complexity: "O(n)", score: 80, reasoning: "" }],
+    },
+  };
+  const identicalSC: SpaceComplexityResults = {
+    roundId: "round_tie",
+    metric: "space_complexity",
+    results: {
+      user_a: [{ questionId: "q1", complexity: "O(1)", score: 90, reasoning: "" }],
+      user_b: [{ questionId: "q1", complexity: "O(1)", score: 90, reasoning: "" }],
+    },
+  };
+  const identicalOrig: OriginalityResults = {
+    roundId: "round_tie",
+    metric: "originality",
+    results: {
+      user_a: [{ questionId: "q1", originalityScore: 8, relevanceScore: 9, commentDensity: 5, flags: [], reasoning: "" }],
+      user_b: [{ questionId: "q1", originalityScore: 8, relevanceScore: 9, commentDensity: 5, flags: [], reasoning: "" }],
+    },
+  };
+  const identicalTests: TestCaseResults = {
+    user_a: { passed: 9, total: 10 },
+    user_b: { passed: 9, total: 10 },
+  };
+
+  // user_b was faster
+  const tiebreaker: TiebreakerData = {
+    user_a: 300000, // 5 min
+    user_b: 180000, // 3 min — faster
+  };
+
+  const rankings = computeRankingLocally(
+    identicalTC,
+    identicalSC,
+    identicalOrig,
+    identicalTests,
+    DEFAULT_WEIGHTS,
+    tiebreaker
+  );
+
+  console.log("\n  Tied Rankings:");
+  for (const r of rankings) {
+    console.log(`  #${r.rank} ${r.userId} — Score: ${r.finalScore} | Time: ${r.timeTakenMs}ms`);
+  }
+
+  assert(rankings[0].finalScore === rankings[1].finalScore, "Scores are identical");
+  assert(rankings[0].userId === "user_b", "Faster user (user_b) wins tiebreaker");
+  assert(rankings[1].userId === "user_a", "Slower user (user_a) ranks second");
+}
+
+// ---- Test 3: Weight Sensitivity ----
+
+function testWeightSensitivity() {
+  section("Test 3: Weight Sensitivity — Test Cases Dominate");
+
+  const heavyTestWeights: ScoringWeights = {
+    timeComplexity: 0.05,
+    spaceComplexity: 0.05,
+    originality: 0.05,
+    testCases: 0.85, // test cases heavily weighted
+  };
+
+  const rankings = computeRankingLocally(
+    MOCK_TC_RESULTS,
+    MOCK_SC_RESULTS,
+    MOCK_ORIG_RESULTS,
+    MOCK_TEST_CASES,
+    heavyTestWeights,
+    MOCK_TIEBREAKER
+  );
+
+  console.log("\n  With heavy test-case weight (85%):");
+  for (const r of rankings) {
+    console.log(
+      `  #${r.rank} ${r.userId} — Score: ${r.finalScore} | Tests: ${r.breakdown.testCases.weighted} (${(r.breakdown.testCases.passRate * 100).toFixed(0)}%)`
+    );
+  }
+
+  assert(rankings[0].userId === "user_1", "User 1 still first (highest test pass rate)");
+  assert(
+    rankings[0].breakdown.testCases.weighted > rankings[0].breakdown.timeComplexity.weighted,
+    "Test case contribution dominates TC contribution"
+  );
+}
+
+// ---- Test 4: Edge Case — Single User ----
+
+function testSingleUser() {
+  section("Test 4: Edge Case — Single User Round");
+
+  const singleTC: TimeComplexityResults = {
+    roundId: "round_solo",
+    metric: "time_complexity",
+    results: {
+      solo_user: [{ questionId: "q1", complexity: "O(n)", score: 70, reasoning: "" }],
+    },
+  };
+  const singleSC: SpaceComplexityResults = {
+    roundId: "round_solo",
+    metric: "space_complexity",
+    results: {
+      solo_user: [{ questionId: "q1", complexity: "O(1)", score: 100, reasoning: "" }],
+    },
+  };
+  const singleOrig: OriginalityResults = {
+    roundId: "round_solo",
+    metric: "originality",
+    results: {
+      solo_user: [{ questionId: "q1", originalityScore: 7, relevanceScore: 8, commentDensity: 8, flags: [], reasoning: "" }],
+    },
+  };
+
+  const rankings = computeRankingLocally(
+    singleTC,
+    singleSC,
+    singleOrig,
+    { solo_user: { passed: 10, total: 10 } },
+    DEFAULT_WEIGHTS,
+    { solo_user: 120000 }
+  );
+
+  assert(rankings.length === 1, "Single user in rankings");
+  assert(rankings[0].rank === 1, "Solo user is rank 1");
+  assert(rankings[0].finalScore > 0, "Score is positive");
+  console.log(`  Solo user score: ${rankings[0].finalScore}`);
+}
+
+// ---- Test 5: Edge Case — Empty/Zero Submissions ----
+
+function testZeroScores() {
+  section("Test 5: Edge Case — All Zero Scores");
+
+  const zeroTC: TimeComplexityResults = {
+    roundId: "round_zero",
+    metric: "time_complexity",
+    results: {
+      user_x: [{ questionId: "q1", complexity: "unknown", score: 0, reasoning: "No code" }],
+    },
+  };
+  const zeroSC: SpaceComplexityResults = {
+    roundId: "round_zero",
+    metric: "space_complexity",
+    results: {
+      user_x: [{ questionId: "q1", complexity: "unknown", score: 0, reasoning: "No code" }],
+    },
+  };
+  const zeroOrig: OriginalityResults = {
+    roundId: "round_zero",
+    metric: "originality",
+    results: {
+      user_x: [{ questionId: "q1", originalityScore: 0, relevanceScore: 0, commentDensity: 0, flags: [], reasoning: "Empty" }],
+    },
+  };
+
+  const rankings = computeRankingLocally(
+    zeroTC,
+    zeroSC,
+    zeroOrig,
+    { user_x: { passed: 0, total: 10 } },
+    DEFAULT_WEIGHTS,
+    { user_x: 600000 }
+  );
+
+  assert(rankings.length === 1, "User still ranked");
+  assert(rankings[0].finalScore === 0, "Score is zero");
+}
+
+// ---- Test 6: Tier Classification ----
+
+function testTierClassification() {
+  section("Test 6: Skill Tier Classification");
+
+  assert(classifyTier(15) === "beginner", "Score 15 → beginner");
+  assert(classifyTier(29) === "beginner", "Score 29 → beginner");
+  assert(classifyTier(30) === "intermediate", "Score 30 → intermediate");
+  assert(classifyTier(59) === "intermediate", "Score 59 → intermediate");
+  assert(classifyTier(60) === "advanced", "Score 60 → advanced");
+  assert(classifyTier(84) === "advanced", "Score 84 → advanced");
+  assert(classifyTier(85) === "pro", "Score 85 → pro");
+  assert(classifyTier(100) === "pro", "Score 100 → pro");
+}
+
+// ---- Test 7: Tier Promotion ----
+
+function testTierPromotion() {
+  section("Test 7: Tier Promotion Logic");
+
+  const history: RoundScore[] = [
+    { roundId: "r1", finalScore: 65, rank: 1, evaluatedAt: "" },
+    { roundId: "r2", finalScore: 70, rank: 1, evaluatedAt: "" },
+    { roundId: "r3", finalScore: 72, rank: 2, evaluatedAt: "" },
+  ];
+
+  const result = evaluateTierChange("intermediate", history);
+  assert(result.changed === true, "Should be promoted");
+  assert(result.newTier === "advanced", "Promoted to advanced");
+  console.log(`  Reason: ${result.reason}`);
+}
+
+// ---- Test 8: Tier Demotion ----
+
+function testTierDemotion() {
+  section("Test 8: Tier Demotion Logic");
+
+  const history: RoundScore[] = [
+    { roundId: "r1", finalScore: 88, rank: 1, evaluatedAt: "" },
+    { roundId: "r2", finalScore: 50, rank: 3, evaluatedAt: "" },
+    { roundId: "r3", finalScore: 55, rank: 3, evaluatedAt: "" },
+  ];
+
+  const result = evaluateTierChange("advanced", history);
+  assert(result.changed === true, "Should be demoted");
+  assert(result.newTier === "intermediate", "Demoted to intermediate");
+  console.log(`  Reason: ${result.reason}`);
+}
+
+// ---- Test 9: No Tier Change ----
+
+function testNoTierChange() {
+  section("Test 9: No Tier Change — Inconsistent Performance");
+
+  const history: RoundScore[] = [
+    { roundId: "r1", finalScore: 70, rank: 1, evaluatedAt: "" },
+    { roundId: "r2", finalScore: 50, rank: 2, evaluatedAt: "" }, // dips below
+    { roundId: "r3", finalScore: 75, rank: 1, evaluatedAt: "" },
+  ];
+
+  const result = evaluateTierChange("intermediate", history);
+  assert(result.changed === false, "No change with inconsistent scores");
+}
+
+// ---- Test 10: Full Profile Update Flow ----
+
+function testProfileUpdate() {
+  section("Test 10: Full Player Profile Update");
+
+  const profile: PlayerProfile = {
+    userId: "test_user",
+    skillTier: "intermediate",
+    avgScore: 55,
+    roundHistory: [
+      { roundId: "r1", finalScore: 62, rank: 2, evaluatedAt: "" },
+      { roundId: "r2", finalScore: 68, rank: 1, evaluatedAt: "" },
+    ],
+    commonErrors: ["Off-by-one errors"],
+    preferredAlgorithms: ["Binary Search"],
+    promotionHistory: [],
+  };
+
+  const newRound: RoundScore = {
+    roundId: "r3",
+    finalScore: 71,
+    rank: 1,
+    evaluatedAt: new Date().toISOString(),
+  };
+
+  const updated = updatePlayerProfile(profile, newRound);
+
+  console.log(`  Before: ${profile.skillTier} (avg: ${profile.avgScore})`);
+  console.log(`  After:  ${updated.skillTier} (avg: ${updated.avgScore})`);
+  console.log(`  Rounds: ${updated.roundHistory.length}`);
+
+  assert(updated.roundHistory.length === 3, "Round added to history");
+  assert(updated.skillTier === "advanced", "Promoted to advanced after 3 rounds ≥ 60");
+  assert(updated.promotionHistory.length === 1, "Promotion recorded");
+  console.log(`  Promotion: ${updated.promotionHistory[0].reason}`);
+}
+
+// ---- Test 11: Score Breakdown Integrity ----
+
+function testScoreBreakdownIntegrity() {
+  section("Test 11: Score Breakdown Adds Up to Final Score");
+
+  const rankings = computeRankingLocally(
+    MOCK_TC_RESULTS,
+    MOCK_SC_RESULTS,
+    MOCK_ORIG_RESULTS,
+    MOCK_TEST_CASES,
+    DEFAULT_WEIGHTS,
+    MOCK_TIEBREAKER
+  );
+
+  for (const r of rankings) {
+    const sumOfWeighted =
+      r.breakdown.timeComplexity.weighted +
+      r.breakdown.spaceComplexity.weighted +
+      r.breakdown.originality.weighted +
+      r.breakdown.testCases.weighted;
+
+    const diff = Math.abs(sumOfWeighted - r.finalScore);
+    assert(
+      diff < 0.02, // allow tiny floating point drift
+      `${r.userId}: breakdown sum (${sumOfWeighted.toFixed(2)}) ≈ finalScore (${r.finalScore})`
+    );
+  }
+}
+
+// ============================================================
+// RUN ALL TESTS
+// ============================================================
+
+console.log("\n🏟️  Compile-n-Conquer — Evaluation Pipeline Mock Tests\n");
+
+testRankingComputation();
+testTiebreaker();
+testWeightSensitivity();
+testSingleUser();
+testZeroScores();
+testTierClassification();
+testTierPromotion();
+testTierDemotion();
+testNoTierChange();
+testProfileUpdate();
+testScoreBreakdownIntegrity();
+
+section("SUMMARY");
+console.log(
+  process.exitCode
+    ? "  ⚠️  Some tests FAILED. Check output above."
+    : "  🎉 All tests PASSED!"
+);
+console.log("");
diff --git a/backbaord/testing.ts b/backbaord/testing.ts
new file mode 100644
index 0000000..e0d77d3
--- /dev/null
+++ b/backbaord/testing.ts
@@ -0,0 +1,39 @@
+// Install: npm install backboard-sdk
+import { BackboardClient } from 'backboard-sdk';
+
+async function main() {
+  const apiKey = process.env.BACKBOARD_API_KEY;
+  if (!apiKey) throw new Error('Missing BACKBOARD_API_KEY');
+
+  // Initialize the Backboard client (types are bundled with the package)
+  const client = new BackboardClient({ apiKey });
+
+  // Create an assistant
+  const assistant = await client.createAssistant({
+    name: 'My First Assistant',
+    system_prompt: 'A helpful assistant'
+  });
+
+  // Create a thread
+  const thread = await client.createThread(assistant.assistantId);
+
+  // Send a message and get the complete response
+  const response = await client.addMessage(thread.threadId, {
+    content: 'Hello! Tell me a fun fact about space.',
+    llm_provider: 'google',
+    model_name: 'gemini-2.5-flash',
+    stream: false
+  });
+
+  if ('content' in response) {
+    console.log(response.content);
+  } else {
+    let fullContent = '';
+    for await (const chunk of response) {
+      fullContent += chunk;
+    }
+    console.log(fullContent);
+  }
+}
+
+main().catch(console.error);
\ No newline at end of file
diff --git a/backbaord/tools.ts b/backbaord/tools.ts
new file mode 100644
index 0000000..87bd1a4
--- /dev/null
+++ b/backbaord/tools.ts
@@ -0,0 +1,223 @@
+// ============================================================
+// Backboard Tool Definitions for the Evaluation Pipeline
+// ============================================================
+
+import { BackboardToolDef } from "./types";
+
+// ---- Thread 1: Time Complexity Analysis ----
+export const TIME_COMPLEXITY_TOOL: BackboardToolDef = {
+  type: "function",
+  function: {
+    name: "analyze_time_complexity",
+    description:
+      "Analyze and return the Big-O time complexity of the submitted code relative to the problem it solves. Return the complexity class and a numeric efficiency score (1-100) where 100 is the optimal known solution.",
+    parameters: {
+      type: "object",
+      properties: {
+        code: {
+          type: "string",
+          description: "The submitted source code to analyze",
+        },
+        language: {
+          type: "string",
+          description: "Programming language of the submission (python, cpp, javascript, java, etc.)",
+        },
+        questionContext: {
+          type: "string",
+          description: "The problem statement / question description for context",
+        },
+      },
+      required: ["code", "language", "questionContext"],
+    },
+  },
+};
+
+// ---- Thread 2: Space Complexity Analysis ----
+export const SPACE_COMPLEXITY_TOOL: BackboardToolDef = {
+  type: "function",
+  function: {
+    name: "analyze_space_complexity",
+    description:
+      "Analyze and return the Big-O space complexity (auxiliary space only, excluding input) of the submitted code. Return the complexity class and a numeric efficiency score (1-100) where 100 is optimal.",
+    parameters: {
+      type: "object",
+      properties: {
+        code: {
+          type: "string",
+          description: "The submitted source code to analyze",
+        },
+        language: {
+          type: "string",
+          description: "Programming language of the submission",
+        },
+        questionContext: {
+          type: "string",
+          description: "The problem statement for context",
+        },
+      },
+      required: ["code", "language", "questionContext"],
+    },
+  },
+};
+
+// ---- Thread 3: Originality & Relevance Analysis ----
+export const ORIGINALITY_TOOL: BackboardToolDef = {
+  type: "function",
+  function: {
+    name: "analyze_originality",
+    description:
+      "Analyze code for originality signals. Check comment density (high comment-to-code ratio = likely AI-generated), code style patterns, boilerplate detection, and relevance to the problem. Return an originality score (1-10 where 10 is clearly human-written) and a relevance score (1-10 where 10 perfectly solves the problem).",
+    parameters: {
+      type: "object",
+      properties: {
+        code: {
+          type: "string",
+          description: "The submitted source code to analyze",
+        },
+        language: {
+          type: "string",
+          description: "Programming language of the submission",
+        },
+        questionContext: {
+          type: "string",
+          description: "The problem statement to check relevance against",
+        },
+      },
+      required: ["code", "language", "questionContext"],
+    },
+  },
+};
+
+// ---- Thread 4: Final Ranking Aggregation ----
+export const RANKING_TOOL: BackboardToolDef = {
+  type: "function",
+  function: {
+    name: "compute_final_ranking",
+    description:
+      "Given all metric scores for all users in a round, compute weighted final scores and produce a ranking. Apply the provided weights to normalize scores. In case of tied final scores, use the tiebreaker data (time taken in ms — lower is better) to determine rank order.",
+    parameters: {
+      type: "object",
+      properties: {
+        timeComplexityResults: {
+          type: "string",
+          description: "JSON string of time complexity results for all users",
+        },
+        spaceComplexityResults: {
+          type: "string",
+          description: "JSON string of space complexity results for all users",
+        },
+        originalityResults: {
+          type: "string",
+          description: "JSON string of originality/relevance results for all users",
+        },
+        testCaseResults: {
+          type: "string",
+          description: "JSON string of { userId: { passed, total } } from the database",
+        },
+        weights: {
+          type: "string",
+          description: "JSON string of scoring weights { timeComplexity, spaceComplexity, originality, testCases }",
+        },
+        tiebreakerData: {
+          type: "string",
+          description: "JSON string of { userId: timeTakenMs } for tiebreaker resolution",
+        },
+      },
+      required: [
+        "timeComplexityResults",
+        "spaceComplexityResults",
+        "originalityResults",
+        "testCaseResults",
+        "weights",
+        "tiebreakerData",
+      ],
+    },
+  },
+};
+
+// ---- System Prompts ----
+
+export const SYSTEM_PROMPTS = {
+  timeComplexity: `You are an expert algorithm analyst for a competitive coding platform called Compile-n-Conquer.
+
+Your job: Analyze submitted code and determine its Big-O TIME COMPLEXITY.
+
+For each piece of code you receive:
+1. Identify the dominant operations and loops
+2. Determine the worst-case time complexity as a Big-O expression
+3. Score the efficiency from 1-100 (100 = optimal known solution for the problem)
+4. Provide brief reasoning
+
+You will receive batched submissions for a round. Analyze each one using the analyze_time_complexity tool. Be strict and accurate — this is a competitive setting.
+
+IMPORTANT: You MUST call the analyze_time_complexity tool for EVERY submission in the batch. Do not skip any.`,
+
+  spaceComplexity: `You are an expert algorithm analyst for a competitive coding platform called Compile-n-Conquer.
+
+Your job: Analyze submitted code and determine its Big-O SPACE COMPLEXITY (auxiliary space only — do not count the input).
+
+For each piece of code you receive:
+1. Identify all extra data structures, recursion depth, and allocations
+2. Determine the worst-case auxiliary space complexity as a Big-O expression
+3. Score the efficiency from 1-100 (100 = optimal space usage)
+4. Provide brief reasoning
+
+You will receive batched submissions for a round. Analyze each one using the analyze_space_complexity tool. Be strict and accurate.
+
+IMPORTANT: You MUST call the analyze_space_complexity tool for EVERY submission in the batch. Do not skip any.`,
+
+  originality: `You are a code originality and relevance analyst for a competitive coding platform called Compile-n-Conquer.
+
+Your job: Detect whether code was likely AI-generated (e.g. from ChatGPT/Copilot) and assess how relevant it is to the problem.
+
+Detection signals for AI-generated code:
+- Excessive inline comments explaining obvious operations
+- Over-structured docstrings with parameter/return descriptions for simple functions
+- Boilerplate patterns (e.g. "# Initialize variables", "# Edge case handling")
+- Unnaturally consistent and verbose naming conventions
+- Generic solution patterns that don't match the specific problem constraints
+
+Scoring:
+- originalityScore (1-10): 10 = clearly human-written competitive code, 1 = obviously pasted from AI
+- relevanceScore (1-10): 10 = perfectly addresses the problem, 1 = completely unrelated code
+- commentDensity: percentage of comment lines vs code lines
+- flags: array of detected signals
+
+You will receive batched submissions. Analyze each one using the analyze_originality tool.
+
+IMPORTANT: You MUST call the analyze_originality tool for EVERY submission in the batch.`,
+
+  ranking: `You are the ranking engine for Compile-n-Conquer.
+
+You receive pre-computed scores from three analysis threads (time complexity, space complexity, originality) plus test case pass rates from the database.
+
+Your job:
+1. Apply the provided scoring weights to compute a final score for each user
+2. Average scores across all questions in the round
+3. Rank users from highest to lowest final score
+4. If two users have the exact same final score, the one with LOWER timeTakenMs ranks higher
+
+Use the compute_final_ranking tool with all the data to produce the final ranking.
+
+Output a clear, structured ranking with full score breakdowns.`,
+
+  memory: `You are the Player Profile Manager for Compile-n-Conquer, a competitive coding platform.
+
+You maintain persistent memory about each player:
+- Skill tier: beginner / intermediate / advanced / pro
+- Performance history: scores, ranks, trends
+- Common error patterns and weak areas
+- Preferred algorithms and languages
+- Coaching recommendations
+
+Tier classification rules:
+- Beginner: avg score < 30 across recent rounds
+- Intermediate: avg score 30-60
+- Advanced: avg score 60-85
+- Pro: avg score 85+
+
+Promotion: 3 consecutive rounds with avg score in the next tier → promote
+Demotion: 2 consecutive rounds below current tier threshold → demote
+
+Always provide actionable coaching feedback based on the player's history.`,
+};
diff --git a/backbaord/types.ts b/backbaord/types.ts
new file mode 100644
index 0000000..f54cde7
--- /dev/null
+++ b/backbaord/types.ts
@@ -0,0 +1,174 @@
+// ============================================================
+// Compile-n-Conquer — Evaluation Pipeline Types
+// ============================================================
+
+// ---- Input Types ----
+
+export interface Question {
+  id: string;
+  title: string;
+  description: string;
+  difficulty: "easy" | "medium" | "hard";
+}
+
+export interface UserResponse {
+  questionId: string;
+  code: string;
+  language: string;
+  submittedAt: string; // ISO timestamp
+}
+
+export interface UserSubmission {
+  userId: string;
+  responses: UserResponse[];
+}
+
+export interface RoundSubmissions {
+  roundId: string;
+  questions: Question[];
+  submissions: UserSubmission[];
+}
+
+// ---- Metric Result Types ----
+
+export interface ComplexityResult {
+  questionId: string;
+  complexity: string; // e.g. "O(n)", "O(n log n)"
+  score: number;      // 1-100
+  reasoning: string;
+}
+
+export interface OriginalityResult {
+  questionId: string;
+  originalityScore: number;  // 1-10
+  relevanceScore: number;    // 1-10
+  commentDensity: number;    // percentage
+  flags: string[];
+  reasoning: string;
+}
+
+export interface MetricResults<T> {
+  roundId: string;
+  metric: "time_complexity" | "space_complexity" | "originality";
+  results: Record<string, T[]>; // userId -> per-question results
+}
+
+export type TimeComplexityResults = MetricResults<ComplexityResult>;
+export type SpaceComplexityResults = MetricResults<ComplexityResult>;
+export type OriginalityResults = MetricResults<OriginalityResult>;
+
+// ---- Test Case Types ----
+
+export interface TestCaseResult {
+  passed: number;
+  total: number;
+}
+
+export type TestCaseResults = Record<string, TestCaseResult>; // userId -> result
+
+// ---- Scoring & Ranking Types ----
+
+export interface ScoringWeights {
+  timeComplexity: number;  // e.g. 0.25
+  spaceComplexity: number; // e.g. 0.20
+  originality: number;     // e.g. 0.15
+  testCases: number;       // e.g. 0.40
+}
+
+export const DEFAULT_WEIGHTS: ScoringWeights = {
+  timeComplexity: 0.25,
+  spaceComplexity: 0.20,
+  originality: 0.15,
+  testCases: 0.40,
+};
+
+export interface ScoreBreakdown {
+  timeComplexity: { avgScore: number; weighted: number };
+  spaceComplexity: { avgScore: number; weighted: number };
+  originality: { avgScore: number; weighted: number };
+  testCases: { passRate: number; weighted: number };
+}
+
+export interface RankedUser {
+  rank: number;
+  userId: string;
+  finalScore: number;
+  breakdown: ScoreBreakdown;
+  timeTakenMs: number;
+}
+
+export interface RoundEvaluation {
+  roundId: string;
+  evaluationId: string;
+  rankings: RankedUser[];
+  threadIds: {
+    timeComplexity: string;
+    spaceComplexity: string;
+    originality: string;
+    ranking: string;
+  };
+  evaluatedAt: string;
+}
+
+// ---- Tiebreaker ----
+
+export type TiebreakerData = Record<string, number>; // userId -> timeTakenMs
+
+// ---- Memory / Skill Tier Types ----
+
+export type SkillTier = "beginner" | "intermediate" | "advanced" | "pro";
+
+export interface PlayerProfile {
+  userId: string;
+  skillTier: SkillTier;
+  avgScore: number;
+  roundHistory: RoundScore[];
+  commonErrors: string[];
+  preferredAlgorithms: string[];
+  promotionHistory: TierChange[];
+}
+
+export interface RoundScore {
+  roundId: string;
+  finalScore: number;
+  rank: number;
+  evaluatedAt: string;
+}
+
+export interface TierChange {
+  from: SkillTier;
+  to: SkillTier;
+  reason: string;
+  changedAt: string;
+}
+
+// ---- Backboard Tool Definitions ----
+
+export interface BackboardToolDef {
+  type: "function";
+  function: {
+    name: string;
+    description: string;
+    parameters: {
+      type: "object";
+      properties: Record<string, { type: string; description: string }>;
+      required: string[];
+    };
+  };
+}
+
+// ---- Evaluation Pipeline Config ----
+
+export interface EvaluationConfig {
+  llmProvider: string;
+  modelName: string;
+  weights: ScoringWeights;
+  maxRetries: number;
+}
+
+export const DEFAULT_EVAL_CONFIG: EvaluationConfig = {
+  llmProvider: "google",
+  modelName: "gemini-2.5-flash",
+  weights: DEFAULT_WEIGHTS,
+  maxRetries: 2,
+};
diff --git a/components/arena/code-editor.tsx b/components/arena/code-editor.tsx
new file mode 100644
index 0000000..51e56a4
--- /dev/null
+++ b/components/arena/code-editor.tsx
@@ -0,0 +1,257 @@
+"use client"
+
+import { useState } from "react"
+import { Play, RotateCcw, Send, ChevronDown } from "lucide-react"
+
+const defaultCode = `def two_sum(nums, target):
+    """
+    Given an array of integers nums and
+    an integer target, return indices of
+    the two numbers that add up to target.
+    """
+    seen = {}
+    for i, num in enumerate(nums):
+        complement = target - num
+        if complement in seen:
+            return [seen[complement], i]
+        seen[num] = i
+    return []
+
+# Test
+print(two_sum([2, 7, 11, 15], 9))
+`
+
+const problemStatement = {
+  title: "Two Sum",
+  difficulty: "Easy",
+  tag: "Q1 / 5",
+  description:
+    "Given an array of integers nums and an integer target, return the indices of the two numbers such that they add up to target. You may assume that each input would have exactly one solution.",
+  examples: [
+    { input: "nums = [2,7,11,15], target = 9", output: "[0, 1]" },
+    { input: "nums = [3,2,4], target = 6", output: "[1, 2]" },
+  ],
+  constraints: [
+    "2 <= nums.length <= 10^4",
+    "-10^9 <= nums[i] <= 10^9",
+    "Only one valid answer exists.",
+  ],
+}
+
+export function CodeEditor() {
+  const [code, setCode] = useState(defaultCode)
+  const [activeTab, setActiveTab] = useState<"problem" | "output">("problem")
+  const [language, setLanguage] = useState("python")
+  const [showLangDropdown, setShowLangDropdown] = useState(false)
+  const [output, setOutput] = useState("")
+
+  const handleRun = () => {
+    setActiveTab("output")
+    setOutput("Running...\n")
+    setTimeout(() => {
+      setOutput(
+        `$ python solution.py\n[0, 1]\n\n---\nTest Case 1: PASSED\nTest Case 2: PASSED\nTest Case 3: PASSED\n\nAll test cases passed.\nExecution time: 4ms\nMemory: 14.2 MB`
+      )
+    }, 1200)
+  }
+
+  const handleSubmit = () => {
+    setActiveTab("output")
+    setOutput("Submitting...\n")
+    setTimeout(() => {
+      setOutput(
+        `$ submit solution.py\n\n[ACCEPTED]\n\nRuntime: 4ms (faster than 95.2%)\nMemory: 14.2 MB (less than 88.1%)\n\nTime Complexity: O(n)\nSpace Complexity: O(n)\n\nCode Quality Score: 87/100\n  - Naming: 9/10\n  - Readability: 9/10\n  - Efficiency: 10/10\n  - Clean Code: 8.7/10\n\n+150 XP | +25 Speed Bonus | First Blood: +50 XP`
+      )
+    }, 1500)
+  }
+
+  return (
+    <div className="flex flex-1 flex-col overflow-hidden rounded-sm border border-border bg-card lg:flex-row">
+      {/* Left panel: Problem + Output */}
+      <div className="flex flex-col border-b border-border lg:w-2/5 lg:border-b-0 lg:border-r">
+        {/* Tabs */}
+        <div className="flex border-b border-border">
+          <button
+            onClick={() => setActiveTab("problem")}
+            className={`flex-1 px-4 py-2 text-xs uppercase tracking-widest transition-colors ${
+              activeTab === "problem"
+                ? "border-b-2 border-primary bg-secondary/50 text-primary"
+                : "text-muted-foreground hover:text-foreground"
+            }`}
+          >
+            Problem
+          </button>
+          <button
+            onClick={() => setActiveTab("output")}
+            className={`flex-1 px-4 py-2 text-xs uppercase tracking-widest transition-colors ${
+              activeTab === "output"
+                ? "border-b-2 border-primary bg-secondary/50 text-primary"
+                : "text-muted-foreground hover:text-foreground"
+            }`}
+          >
+            Output
+          </button>
+        </div>
+
+        {/* Content */}
+        <div className="flex-1 overflow-auto p-4">
+          {activeTab === "problem" ? (
+            <div className="flex flex-col gap-4">
+              <div className="flex items-center gap-3">
+                <span className="text-xs text-primary">{problemStatement.tag}</span>
+                <h2 className="text-lg font-bold text-foreground">
+                  {problemStatement.title}
+                </h2>
+                <span className="rounded-sm border border-primary/30 bg-primary/10 px-2 py-0.5 text-xs text-primary">
+                  {problemStatement.difficulty}
+                </span>
+              </div>
+              <p className="text-sm leading-relaxed text-muted-foreground">
+                {problemStatement.description}
+              </p>
+              <div className="flex flex-col gap-3">
+                <span className="text-xs uppercase tracking-widest text-primary">
+                  {"Examples"}
+                </span>
+                {problemStatement.examples.map((ex, i) => (
+                  <div
+                    key={i}
+                    className="rounded-sm border border-border bg-secondary/50 p-3"
+                  >
+                    <div className="text-xs text-muted-foreground">
+                      <span className="text-primary">{"Input: "}</span>
+                      {ex.input}
+                    </div>
+                    <div className="mt-1 text-xs text-muted-foreground">
+                      <span className="text-primary">{"Output: "}</span>
+                      {ex.output}
+                    </div>
+                  </div>
+                ))}
+              </div>
+              <div className="flex flex-col gap-2">
+                <span className="text-xs uppercase tracking-widest text-primary">
+                  {"Constraints"}
+                </span>
+                <ul className="flex flex-col gap-1">
+                  {problemStatement.constraints.map((c) => (
+                    <li key={c} className="flex items-center gap-2 text-xs text-muted-foreground">
+                      <span className="text-primary">{">"}</span>
+                      {c}
+                    </li>
+                  ))}
+                </ul>
+              </div>
+            </div>
+          ) : (
+            <pre className="whitespace-pre-wrap text-xs leading-relaxed text-foreground">
+              {output || "No output yet. Run your code to see results."}
+            </pre>
+          )}
+        </div>
+      </div>
+
+      {/* Right panel: Code Editor */}
+      <div className="flex flex-1 flex-col">
+        {/* Toolbar */}
+        <div className="flex items-center justify-between border-b border-border px-4 py-2">
+          <div className="relative">
+            <button
+              onClick={() => setShowLangDropdown(!showLangDropdown)}
+              className="flex items-center gap-1 text-xs uppercase tracking-widest text-muted-foreground hover:text-foreground"
+            >
+              {language}
+              <ChevronDown className="h-3 w-3" />
+            </button>
+            {showLangDropdown && (
+              <div className="absolute left-0 top-full z-20 mt-1 rounded-sm border border-border bg-card py-1 shadow-lg">
+                {["python", "c++", "java", "javascript"].map((lang) => (
+                  <button
+                    key={lang}
+                    onClick={() => {
+                      setLanguage(lang)
+                      setShowLangDropdown(false)
+                    }}
+                    className={`block w-full px-4 py-1.5 text-left text-xs uppercase tracking-widest ${
+                      language === lang ? "text-primary" : "text-muted-foreground hover:text-foreground"
+                    }`}
+                  >
+                    {lang}
+                  </button>
+                ))}
+              </div>
+            )}
+          </div>
+          <div className="flex items-center gap-2">
+            <button
+              onClick={() => setCode(defaultCode)}
+              className="rounded-sm border border-border p-1.5 text-muted-foreground transition-colors hover:border-primary/50 hover:text-foreground"
+              aria-label="Reset code"
+            >
+              <RotateCcw className="h-3.5 w-3.5" />
+            </button>
+            <button
+              onClick={handleRun}
+              className="flex items-center gap-1.5 rounded-sm border border-border bg-secondary px-3 py-1.5 text-xs uppercase tracking-widest text-foreground transition-all hover:border-primary/50"
+            >
+              <Play className="h-3 w-3 text-primary" />
+              Run
+            </button>
+            <button
+              onClick={handleSubmit}
+              className="flex items-center gap-1.5 rounded-sm border border-primary bg-primary px-3 py-1.5 text-xs uppercase tracking-widest text-primary-foreground transition-all hover:bg-primary/90"
+            >
+              <Send className="h-3 w-3" />
+              Submit
+            </button>
+          </div>
+        </div>
+
+        {/* Line numbers + textarea */}
+        <div className="relative flex flex-1 overflow-auto">
+          {/* Line numbers */}
+          <div className="flex flex-col border-r border-border bg-secondary/30 px-3 py-3 text-right">
+            {code.split("\n").map((_, i) => (
+              <span
+                key={i}
+                className="text-xs leading-5 text-muted-foreground/50"
+              >
+                {i + 1}
+              </span>
+            ))}
+          </div>
+
+          {/* Code area */}
+          <textarea
+            value={code}
+            onChange={(e) => setCode(e.target.value)}
+            className="flex-1 resize-none bg-transparent p-3 text-xs leading-5 text-foreground caret-primary focus:outline-none"
+            spellCheck={false}
+            autoComplete="off"
+            autoCorrect="off"
+            autoCapitalize="off"
+          />
+        </div>
+
+        {/* Complexity analyzer */}
+        <div className="border-t border-border px-4 py-2">
+          <div className="flex items-center justify-between">
+            <span className="text-xs uppercase tracking-widest text-primary">
+              {"Complexity Analyzer"}
+            </span>
+            <div className="flex items-center gap-4">
+              <div className="flex items-center gap-2">
+                <span className="text-xs text-muted-foreground">{"Time:"}</span>
+                <span className="text-xs font-bold text-primary">{"O(n)"}</span>
+              </div>
+              <div className="flex items-center gap-2">
+                <span className="text-xs text-muted-foreground">{"Space:"}</span>
+                <span className="text-xs font-bold text-primary">{"O(n)"}</span>
+              </div>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+  )
+}
diff --git a/components/arena/points-panel.tsx b/components/arena/points-panel.tsx
new file mode 100644
index 0000000..21673e9
--- /dev/null
+++ b/components/arena/points-panel.tsx
@@ -0,0 +1,157 @@
+import { Trophy, Zap, Star, Clock } from "lucide-react"
+
+interface QuestionResult {
+  id: number
+  title: string
+  status: "solved" | "attempted" | "locked"
+  points: number
+  maxPoints: number
+  bonuses: string[]
+}
+
+const questions: QuestionResult[] = [
+  {
+    id: 1,
+    title: "Two Sum",
+    status: "solved",
+    points: 150,
+    maxPoints: 150,
+    bonuses: ["First Blood +50", "Clean Code +20"],
+  },
+  {
+    id: 2,
+    title: "Valid Parentheses",
+    status: "solved",
+    points: 120,
+    maxPoints: 150,
+    bonuses: ["Speed +15"],
+  },
+  {
+    id: 3,
+    title: "Merge Intervals",
+    status: "attempted",
+    points: 0,
+    maxPoints: 200,
+    bonuses: [],
+  },
+  {
+    id: 4,
+    title: "LRU Cache",
+    status: "locked",
+    points: 0,
+    maxPoints: 250,
+    bonuses: [],
+  },
+  {
+    id: 5,
+    title: "Binary Tree Paths",
+    status: "locked",
+    points: 0,
+    maxPoints: 200,
+    bonuses: [],
+  },
+]
+
+const statusStyles = {
+  solved: "border-primary/30 bg-primary/5 text-primary",
+  attempted: "border-yellow-500/30 bg-yellow-500/5 text-yellow-400",
+  locked: "border-border bg-secondary/30 text-muted-foreground",
+}
+
+const statusLabels = {
+  solved: "SOLVED",
+  attempted: "IN PROGRESS",
+  locked: "LOCKED",
+}
+
+export function PointsPanel() {
+  const totalPoints = questions.reduce((sum, q) => sum + q.points, 0)
+  const maxPoints = questions.reduce((sum, q) => sum + q.maxPoints, 0)
+
+  return (
+    <div className="flex flex-col rounded-sm border border-border bg-card">
+      {/* Header with total */}
+      <div className="flex items-center justify-between border-b border-border px-3 py-2">
+        <span className="text-xs uppercase tracking-widest text-primary">
+          Scoreboard
+        </span>
+        <div className="flex items-center gap-1.5">
+          <Trophy className="h-3 w-3 text-primary" />
+          <span className="text-sm font-bold text-primary">{totalPoints}</span>
+          <span className="text-xs text-muted-foreground">/ {maxPoints}</span>
+        </div>
+      </div>
+
+      {/* Question breakdown */}
+      <div className="flex flex-col">
+        {questions.map((q) => (
+          <div
+            key={q.id}
+            className={`flex flex-col gap-1.5 border-b border-border/50 px-3 py-2.5 last:border-b-0 ${
+              q.status === "locked" ? "opacity-40" : ""
+            }`}
+          >
+            <div className="flex items-center justify-between">
+              <div className="flex items-center gap-2">
+                <span className="text-xs text-muted-foreground">
+                  {"Q" + q.id}
+                </span>
+                <span className="text-xs font-bold text-foreground">
+                  {q.title}
+                </span>
+              </div>
+              <span
+                className={`rounded-sm border px-1.5 py-0.5 text-xs ${statusStyles[q.status]}`}
+              >
+                {statusLabels[q.status]}
+              </span>
+            </div>
+
+            {/* Points bar */}
+            <div className="flex items-center gap-2">
+              <div className="relative h-1.5 flex-1 overflow-hidden rounded-sm bg-secondary">
+                <div
+                  className="h-full rounded-sm bg-primary transition-all"
+                  style={{ width: `${(q.points / q.maxPoints) * 100}%` }}
+                />
+              </div>
+              <span className="text-xs text-muted-foreground">
+                {q.points}/{q.maxPoints}
+              </span>
+            </div>
+
+            {/* Bonuses */}
+            {q.bonuses.length > 0 && (
+              <div className="flex flex-wrap gap-1">
+                {q.bonuses.map((b) => (
+                  <span
+                    key={b}
+                    className="flex items-center gap-1 rounded-sm border border-primary/20 bg-primary/5 px-1.5 py-0.5 text-xs text-primary"
+                  >
+                    <Zap className="h-2.5 w-2.5" />
+                    {b}
+                  </span>
+                ))}
+              </div>
+            )}
+          </div>
+        ))}
+      </div>
+
+      {/* Summary footer */}
+      <div className="flex items-center justify-between border-t border-border px-3 py-2">
+        <div className="flex items-center gap-3">
+          <div className="flex items-center gap-1">
+            <Star className="h-3 w-3 text-primary" />
+            <span className="text-xs text-muted-foreground">Rank: #2</span>
+          </div>
+          <div className="flex items-center gap-1">
+            <Clock className="h-3 w-3 text-muted-foreground" />
+            <span className="text-xs text-muted-foreground">12:48</span>
+          </div>
+        </div>
+        <span className="text-xs font-bold text-primary">+85 XP bonus</span>
+      </div>
+    </div>
+  )
+}
diff --git a/components/arena/progress-bar.tsx b/components/arena/progress-bar.tsx
new file mode 100644
index 0000000..8bc3a4d
--- /dev/null
+++ b/components/arena/progress-bar.tsx
@@ -0,0 +1,109 @@
+"use client"
+
+import { useEffect, useState } from "react"
+
+interface Player {
+  id: string
+  name: string
+  avatar: string
+  progress: number
+  solved: number
+  total: number
+  color: string
+}
+
+const initialPlayers: Player[] = [
+  { id: "1", name: "you", avatar: "Y", progress: 45, solved: 2, total: 5, color: "hsl(120 100% 50%)" },
+  { id: "2", name: "n3x_byte", avatar: "N", progress: 62, solved: 3, total: 5, color: "hsl(45 100% 50%)" },
+  { id: "3", name: "z3r0_day", avatar: "Z", progress: 38, solved: 2, total: 5, color: "hsl(200 100% 50%)" },
+  { id: "4", name: "c0d3_wr4ith", avatar: "C", progress: 55, solved: 3, total: 5, color: "hsl(0 80% 55%)" },
+  { id: "5", name: "algo_gh0st", avatar: "A", progress: 28, solved: 1, total: 5, color: "hsl(280 80% 60%)" },
+]
+
+export function ProgressBar() {
+  const [players, setPlayers] = useState(initialPlayers)
+
+  // Simulate live progress updates
+  useEffect(() => {
+    const interval = setInterval(() => {
+      setPlayers((prev) =>
+        prev.map((p) => ({
+          ...p,
+          progress: p.id === "1" ? p.progress : Math.min(100, p.progress + Math.random() * 3 - 0.5),
+        }))
+      )
+    }, 2000)
+    return () => clearInterval(interval)
+  }, [])
+
+  const sorted = [...players].sort((a, b) => b.progress - a.progress)
+
+  return (
+    <div className="rounded-sm border border-border bg-card p-3">
+      {/* Header */}
+      <div className="mb-3 flex items-center justify-between">
+        <div className="flex items-center gap-2">
+          <div className="h-2 w-2 animate-pulse rounded-full bg-primary" />
+          <span className="text-xs uppercase tracking-widest text-primary">
+            Live Progress
+          </span>
+        </div>
+        <div className="flex items-center gap-2">
+          <span className="text-xs text-muted-foreground">{"Round 1 / 5"}</span>
+          <span className="text-xs text-muted-foreground">{"04:32"}</span>
+        </div>
+      </div>
+
+      {/* Progress tracks */}
+      <div className="flex flex-col gap-2">
+        {sorted.map((player, index) => (
+          <div key={player.id} className="flex items-center gap-3">
+            {/* Rank */}
+            <span className="w-4 text-right text-xs text-muted-foreground">
+              {index + 1}
+            </span>
+
+            {/* Avatar */}
+            <div
+              className="flex h-6 w-6 flex-shrink-0 items-center justify-center rounded-sm text-xs font-bold"
+              style={{
+                backgroundColor: `${player.color}20`,
+                color: player.color,
+                border: `1px solid ${player.color}40`,
+              }}
+            >
+              {player.avatar}
+            </div>
+
+            {/* Name */}
+            <span
+              className={`w-24 truncate text-xs ${
+                player.id === "1" ? "font-bold text-primary" : "text-muted-foreground"
+              }`}
+            >
+              {player.name}
+            </span>
+
+            {/* Bar */}
+            <div className="relative h-3 flex-1 overflow-hidden rounded-sm bg-secondary">
+              <div
+                className="h-full rounded-sm transition-all duration-1000 ease-out"
+                style={{
+                  width: `${player.progress}%`,
+                  backgroundColor: player.color,
+                  opacity: 0.8,
+                  boxShadow: `0 0 8px ${player.color}40`,
+                }}
+              />
+            </div>
+
+            {/* Score */}
+            <span className="w-12 text-right text-xs text-muted-foreground">
+              {player.solved}/{player.total}
+            </span>
+          </div>
+        ))}
+      </div>
+    </div>
+  )
+}
diff --git a/components/arena/users-panel.tsx b/components/arena/users-panel.tsx
new file mode 100644
index 0000000..951a1f7
--- /dev/null
+++ b/components/arena/users-panel.tsx
@@ -0,0 +1,110 @@
+"use client"
+
+import { useEffect, useState } from "react"
+import { Wifi, WifiOff } from "lucide-react"
+
+interface User {
+  id: string
+  name: string
+  avatar: string
+  status: "coding" | "idle" | "submitted"
+  rank: number
+  rating: number
+  color: string
+}
+
+const initialUsers: User[] = [
+  { id: "1", name: "you", avatar: "Y", status: "coding", rank: 1, rating: 1847, color: "hsl(120 100% 50%)" },
+  { id: "2", name: "n3x_byte", avatar: "N", status: "coding", rank: 2, rating: 2103, color: "hsl(45 100% 50%)" },
+  { id: "3", name: "z3r0_day", avatar: "Z", status: "idle", rank: 3, rating: 1956, color: "hsl(200 100% 50%)" },
+  { id: "4", name: "c0d3_wr4ith", avatar: "C", status: "submitted", rank: 4, rating: 2241, color: "hsl(0 80% 55%)" },
+  { id: "5", name: "algo_gh0st", avatar: "A", status: "coding", rank: 5, rating: 1724, color: "hsl(280 80% 60%)" },
+]
+
+const statusConfig = {
+  coding: { label: "CODING", dotClass: "bg-primary animate-pulse" },
+  idle: { label: "IDLE", dotClass: "bg-muted-foreground" },
+  submitted: { label: "DONE", dotClass: "bg-yellow-400" },
+}
+
+export function UsersPanel() {
+  const [users, setUsers] = useState(initialUsers)
+
+  // Simulate status changes
+  useEffect(() => {
+    const interval = setInterval(() => {
+      setUsers((prev) =>
+        prev.map((u) => {
+          if (u.id === "1") return u
+          const r = Math.random()
+          if (r > 0.92) return { ...u, status: "submitted" as const }
+          if (r > 0.85) return { ...u, status: "idle" as const }
+          return { ...u, status: "coding" as const }
+        })
+      )
+    }, 3000)
+    return () => clearInterval(interval)
+  }, [])
+
+  return (
+    <div className="flex flex-col rounded-sm border border-border bg-card">
+      {/* Header */}
+      <div className="flex items-center justify-between border-b border-border px-3 py-2">
+        <span className="text-xs uppercase tracking-widest text-primary">
+          Opponents
+        </span>
+        <div className="flex items-center gap-1">
+          <Wifi className="h-3 w-3 text-primary" />
+          <span className="text-xs text-muted-foreground">{users.length}</span>
+        </div>
+      </div>
+
+      {/* User list */}
+      <div className="flex flex-col">
+        {users.map((user) => {
+          const sc = statusConfig[user.status]
+          return (
+            <div
+              key={user.id}
+              className={`flex items-center gap-3 border-b border-border/50 px-3 py-2.5 last:border-b-0 ${
+                user.id === "1" ? "bg-primary/5" : ""
+              }`}
+            >
+              {/* Avatar */}
+              <div
+                className="flex h-7 w-7 flex-shrink-0 items-center justify-center rounded-sm text-xs font-bold"
+                style={{
+                  backgroundColor: `${user.color}15`,
+                  color: user.color,
+                  border: `1px solid ${user.color}30`,
+                }}
+              >
+                {user.avatar}
+              </div>
+
+              {/* Info */}
+              <div className="flex flex-1 flex-col">
+                <span
+                  className={`text-xs font-bold ${
+                    user.id === "1" ? "text-primary" : "text-foreground"
+                  }`}
+                >
+                  {user.name}
+                </span>
+                <span className="text-xs text-muted-foreground">
+                  {user.rating} ELO
+                </span>
+              </div>
+
+              {/* Status */}
+              <div className="flex items-center gap-1.5">
+                <div className={`h-1.5 w-1.5 rounded-full ${sc.dotClass}`} />
+                <span className="text-xs text-muted-foreground">{sc.label}</span>
+              </div>
+            </div>
+          )
+        })}
+      </div>
+    </div>
+  )
+}
diff --git a/components/landing/features.tsx b/components/landing/features.tsx
new file mode 100644
index 0000000..b0b0d16
--- /dev/null
+++ b/components/landing/features.tsx
@@ -0,0 +1,81 @@
+import { Zap, Shield, Eye, Code, Timer, Trophy } from "lucide-react"
+
+const features = [
+  {
+    icon: Zap,
+    title: "Live Progress Arena",
+    description:
+      "Real-time race bars with live avatars. Watch opponents pass test cases in real time.",
+  },
+  {
+    icon: Code,
+    title: "Integrated IDE",
+    description:
+      "Side-by-side code editor with built-in complexity analyzer. Real-time feedback on your logic.",
+  },
+  {
+    icon: Shield,
+    title: "Comprehensive Grading",
+    description:
+      "Evaluated on efficiency, execution speed, code quality, and clean code heuristics.",
+  },
+  {
+    icon: Eye,
+    title: "Reverse Engineering",
+    description:
+      "Deduce algorithms from I/O sets. A unique mode that tests deep understanding.",
+  },
+  {
+    icon: Timer,
+    title: "First Blood Bonuses",
+    description:
+      "Be the first to solve and earn bonus points. Speed matters as much as quality.",
+  },
+  {
+    icon: Trophy,
+    title: "Ranked Leaderboards",
+    description:
+      "Climb the global rankings. Track your win rate, efficiency score, and code quality rating.",
+  },
+]
+
+export function Features() {
+  return (
+    <section id="features" className="relative px-4 py-24">
+      <div className="mx-auto max-w-6xl">
+        {/* Section header */}
+        <div className="mb-16 flex flex-col items-center gap-4 text-center">
+          <span className="text-xs uppercase tracking-widest text-primary">
+            {"// system_capabilities"}
+          </span>
+          <h2 className="text-balance text-3xl font-bold text-foreground md:text-4xl">
+            {"Built for Competitive Coders"}
+          </h2>
+          <p className="max-w-lg text-muted-foreground">
+            {"Every feature is designed to test your skills, reward clean code, and create an electrifying competitive experience."}
+          </p>
+        </div>
+
+        {/* Features grid */}
+        <div className="grid gap-4 md:grid-cols-2 lg:grid-cols-3">
+          {features.map((feature) => (
+            <div
+              key={feature.title}
+              className="group rounded-sm border border-border bg-card p-6 transition-all hover:border-primary/50 hover:shadow-[0_0_15px_hsl(120_100%_50%_/_0.05)]"
+            >
+              <div className="mb-4 flex h-10 w-10 items-center justify-center rounded-sm border border-border bg-secondary">
+                <feature.icon className="h-5 w-5 text-primary" />
+              </div>
+              <h3 className="mb-2 text-sm font-bold uppercase tracking-wider text-foreground">
+                {feature.title}
+              </h3>
+              <p className="text-sm leading-relaxed text-muted-foreground">
+                {feature.description}
+              </p>
+            </div>
+          ))}
+        </div>
+      </div>
+    </section>
+  )
+}
diff --git a/components/landing/footer.tsx b/components/landing/footer.tsx
new file mode 100644
index 0000000..6473dd8
--- /dev/null
+++ b/components/landing/footer.tsx
@@ -0,0 +1,40 @@
+import { Terminal } from "lucide-react"
+import Link from "next/link"
+
+export function Footer() {
+  return (
+    <footer className="border-t border-border px-4 py-12">
+      <div className="mx-auto flex max-w-6xl flex-col items-center gap-6 text-center">
+        <div className="flex items-center gap-2">
+          <Terminal className="h-4 w-4 text-primary" />
+          <span className="text-xs font-bold uppercase tracking-widest text-foreground">
+            CompileNConquer
+          </span>
+        </div>
+        <div className="flex flex-wrap justify-center gap-6">
+          <Link
+            href="#features"
+            className="text-xs uppercase tracking-widest text-muted-foreground transition-colors hover:text-primary"
+          >
+            Features
+          </Link>
+          <Link
+            href="/arena"
+            className="text-xs uppercase tracking-widest text-muted-foreground transition-colors hover:text-primary"
+          >
+            Arena
+          </Link>
+          <Link
+            href="/profile"
+            className="text-xs uppercase tracking-widest text-muted-foreground transition-colors hover:text-primary"
+          >
+            Profile
+          </Link>
+        </div>
+        <p className="text-xs text-muted-foreground">
+          {"// 2026 CompileNConquer. All systems operational."}
+        </p>
+      </div>
+    </footer>
+  )
+}
diff --git a/components/landing/game-modes.tsx b/components/landing/game-modes.tsx
new file mode 100644
index 0000000..4b0726e
--- /dev/null
+++ b/components/landing/game-modes.tsx
@@ -0,0 +1,126 @@
+"use client"
+
+import { useState } from "react"
+import { Bug, Code2, Shuffle } from "lucide-react"
+
+const modes = [
+  {
+    id: "debug",
+    icon: Bug,
+    name: "Debugging",
+    tag: "MODE_01",
+    description:
+      "Fix a broken codebase with the fewest changes possible. Surgical precision is rewarded.",
+    details: [
+      "Identify bugs in existing code",
+      "Minimize number of changes",
+      "Fewest edits wins tiebreaker",
+    ],
+  },
+  {
+    id: "scratch",
+    icon: Code2,
+    name: "Code from Scratch",
+    tag: "MODE_02",
+    description:
+      "Standard competitive coding. Implement the solution from a problem statement, fast and clean.",
+    details: [
+      "Full implementation required",
+      "Graded on speed + quality",
+      "Time & space complexity matters",
+    ],
+  },
+  {
+    id: "reverse",
+    icon: Shuffle,
+    name: "Reverse Engineering",
+    tag: "MODE_03",
+    description:
+      "Given input/output sets, deduce and write the underlying algorithm. Think backwards to go forward.",
+    details: [
+      "Analyze I/O patterns",
+      "Deduce the algorithm",
+      "Write the hidden function",
+    ],
+  },
+]
+
+export function GameModes() {
+  const [activeMode, setActiveMode] = useState("debug")
+
+  const active = modes.find((m) => m.id === activeMode)!
+
+  return (
+    <section className="relative px-4 py-24">
+      <div className="mx-auto max-w-6xl">
+        {/* Section header */}
+        <div className="mb-16 flex flex-col items-center gap-4 text-center">
+          <span className="text-xs uppercase tracking-widest text-primary">
+            {"// game_modes"}
+          </span>
+          <h2 className="text-balance text-3xl font-bold text-foreground md:text-4xl">
+            {"Choose Your Battle"}
+          </h2>
+        </div>
+
+        {/* Mode selector tabs */}
+        <div className="mb-8 flex flex-wrap justify-center gap-2">
+          {modes.map((mode) => (
+            <button
+              key={mode.id}
+              onClick={() => setActiveMode(mode.id)}
+              className={`flex items-center gap-2 rounded-sm border px-4 py-2 text-xs uppercase tracking-widest transition-all ${
+                activeMode === mode.id
+                  ? "border-primary bg-primary text-primary-foreground"
+                  : "border-border bg-card text-muted-foreground hover:border-primary/50 hover:text-foreground"
+              }`}
+            >
+              <mode.icon className="h-4 w-4" />
+              {mode.name}
+            </button>
+          ))}
+        </div>
+
+        {/* Active mode display */}
+        <div className="rounded-sm border border-border bg-card p-8">
+          <div className="flex flex-col gap-6 md:flex-row md:items-start md:gap-12">
+            <div className="flex-1">
+              <div className="mb-2 flex items-center gap-3">
+                <span className="text-xs text-primary">{active.tag}</span>
+                <span className="text-xs text-muted-foreground">{"//"}</span>
+                <span className="text-xs uppercase tracking-wider text-muted-foreground">
+                  {"active"}
+                </span>
+              </div>
+              <h3 className="mb-4 text-2xl font-bold text-foreground">
+                {active.name}
+              </h3>
+              <p className="leading-relaxed text-muted-foreground">
+                {active.description}
+              </p>
+            </div>
+            <div className="flex-1">
+              <div className="rounded-sm border border-border bg-secondary/50 p-4">
+                <div className="mb-3 text-xs uppercase tracking-widest text-primary">
+                  {"> objectives"}
+                </div>
+                <ul className="flex flex-col gap-3">
+                  {active.details.map((detail) => (
+                    <li
+                      key={detail}
+                      className="flex items-center gap-3 text-sm text-foreground"
+                    >
+                      <span className="text-primary">{"["}</span>
+                      <span>{detail}</span>
+                      <span className="text-primary">{"]"}</span>
+                    </li>
+                  ))}
+                </ul>
+              </div>
+            </div>
+          </div>
+        </div>
+      </div>
+    </section>
+  )
+}
diff --git a/components/landing/hero.tsx b/components/landing/hero.tsx
new file mode 100644
index 0000000..17c36c8
--- /dev/null
+++ b/components/landing/hero.tsx
@@ -0,0 +1,124 @@
+"use client"
+
+import { useState, useEffect } from "react"
+import Link from "next/link"
+import { Terminal, ChevronRight } from "lucide-react"
+
+export function Hero() {
+  const [displayText, setDisplayText] = useState("")
+  const fullText = "CompileNConquer"
+  const [showCursor, setShowCursor] = useState(true)
+
+  useEffect(() => {
+    let i = 0
+    const interval = setInterval(() => {
+      if (i <= fullText.length) {
+        setDisplayText(fullText.slice(0, i))
+        i++
+      } else {
+        clearInterval(interval)
+      }
+    }, 100)
+    return () => clearInterval(interval)
+  }, [])
+
+  useEffect(() => {
+    const interval = setInterval(() => {
+      setShowCursor((prev) => !prev)
+    }, 530)
+    return () => clearInterval(interval)
+  }, [])
+
+  return (
+    <section className="relative flex min-h-screen flex-col items-center justify-center overflow-hidden px-4">
+      {/* Scanline overlay */}
+      <div className="pointer-events-none absolute inset-0 overflow-hidden">
+        <div className="animate-scanline absolute left-0 h-px w-full bg-primary/10" />
+      </div>
+
+      {/* Grid background */}
+      <div
+        className="pointer-events-none absolute inset-0 opacity-5"
+        style={{
+          backgroundImage:
+            "linear-gradient(hsl(120 100% 50% / 0.1) 1px, transparent 1px), linear-gradient(90deg, hsl(120 100% 50% / 0.1) 1px, transparent 1px)",
+          backgroundSize: "40px 40px",
+        }}
+      />
+
+      <div className="relative z-10 flex max-w-4xl flex-col items-center gap-8 text-center">
+        {/* Terminal badge */}
+        <div className="flex items-center gap-2 rounded-sm border border-border bg-card px-4 py-2">
+          <Terminal className="h-4 w-4 text-primary" />
+          <span className="text-xs uppercase tracking-widest text-muted-foreground">
+            {"v1.0.0 // live arena"}
+          </span>
+        </div>
+
+        {/* Main title */}
+        <h1 className="text-balance text-5xl font-bold tracking-tight text-primary md:text-7xl lg:text-8xl">
+          <span className="animate-flicker">{displayText}</span>
+          <span
+            className={`inline-block w-3 bg-primary ${showCursor ? "opacity-100" : "opacity-0"}`}
+            style={{ height: "0.8em", marginLeft: "2px" }}
+          />
+        </h1>
+
+        {/* Subtitle */}
+        <p className="max-w-2xl text-balance text-lg leading-relaxed text-muted-foreground md:text-xl">
+          {"Real-time competitive coding. Race opponents head-to-head. Write the fastest, cleanest code. Climb the leaderboard."}
+        </p>
+
+        {/* Terminal prompt */}
+        <div className="w-full max-w-lg rounded-sm border border-border bg-card p-4 text-left">
+          <div className="flex items-center gap-2 text-sm text-muted-foreground">
+            <span className="text-primary">{">"}</span>
+            <span>{"Modes: Debug // Scratch // Reverse Engineering"}</span>
+          </div>
+          <div className="mt-2 flex items-center gap-2 text-sm text-muted-foreground">
+            <span className="text-primary">{">"}</span>
+            <span>{"Metrics: Speed + Efficiency + Code Quality"}</span>
+          </div>
+          <div className="mt-2 flex items-center gap-2 text-sm">
+            <span className="text-primary">{">"}</span>
+            <span className="text-foreground">{"Ready to compile?"}</span>
+            <span className="animate-blink text-primary">{"_"}</span>
+          </div>
+        </div>
+
+        {/* CTA buttons */}
+        <div className="flex flex-col gap-4 sm:flex-row">
+          <Link
+            href="/auth"
+            className="animate-pulse-glow flex items-center gap-2 rounded-sm border border-primary bg-primary px-8 py-3 text-sm font-bold uppercase tracking-widest text-primary-foreground transition-all hover:bg-primary/90"
+          >
+            Enter Arena
+            <ChevronRight className="h-4 w-4" />
+          </Link>
+          <Link
+            href="#features"
+            className="flex items-center gap-2 rounded-sm border border-border bg-transparent px-8 py-3 text-sm font-bold uppercase tracking-widest text-foreground transition-all hover:border-primary hover:text-primary"
+          >
+            Recon
+          </Link>
+        </div>
+
+        {/* Stats bar */}
+        <div className="mt-8 flex flex-wrap items-center justify-center gap-8 border-t border-border pt-8">
+          {[
+            { label: "Active Players", value: "2,847" },
+            { label: "Battles Fought", value: "48,291" },
+            { label: "Lines Compiled", value: "12.4M" },
+          ].map((stat) => (
+            <div key={stat.label} className="flex flex-col items-center gap-1">
+              <span className="text-2xl font-bold text-primary">{stat.value}</span>
+              <span className="text-xs uppercase tracking-wider text-muted-foreground">
+                {stat.label}
+              </span>
+            </div>
+          ))}
+        </div>
+      </div>
+    </section>
+  )
+}
diff --git a/components/landing/navbar.tsx b/components/landing/navbar.tsx
new file mode 100644
index 0000000..0cc43a0
--- /dev/null
+++ b/components/landing/navbar.tsx
@@ -0,0 +1,95 @@
+"use client"
+
+import Link from "next/link"
+import { Terminal, Menu, X } from "lucide-react"
+import { useState } from "react"
+
+export function Navbar() {
+  const [open, setOpen] = useState(false)
+
+  return (
+    <header className="fixed left-0 right-0 top-0 z-50 border-b border-border bg-background/80 backdrop-blur-md">
+      <nav className="mx-auto flex max-w-6xl items-center justify-between px-4 py-3">
+        <Link href="/" className="flex items-center gap-2">
+          <Terminal className="h-5 w-5 text-primary" />
+          <span className="text-sm font-bold uppercase tracking-widest text-foreground">
+            CnC
+          </span>
+        </Link>
+
+        {/* Desktop nav */}
+        <div className="hidden items-center gap-6 md:flex">
+          <Link
+            href="#features"
+            className="text-xs uppercase tracking-widest text-muted-foreground transition-colors hover:text-primary"
+          >
+            Features
+          </Link>
+          <Link
+            href="#features"
+            className="text-xs uppercase tracking-widest text-muted-foreground transition-colors hover:text-primary"
+          >
+            Modes
+          </Link>
+          <Link
+            href="/arena"
+            className="text-xs uppercase tracking-widest text-muted-foreground transition-colors hover:text-primary"
+          >
+            Arena
+          </Link>
+          <Link
+            href="/auth"
+            className="rounded-sm border border-primary bg-primary px-4 py-1.5 text-xs font-bold uppercase tracking-widest text-primary-foreground transition-all hover:bg-primary/90"
+          >
+            Sign In
+          </Link>
+        </div>
+
+        {/* Mobile toggle */}
+        <button
+          onClick={() => setOpen(!open)}
+          className="text-foreground md:hidden"
+          aria-label="Toggle navigation menu"
+        >
+          {open ? <X className="h-5 w-5" /> : <Menu className="h-5 w-5" />}
+        </button>
+      </nav>
+
+      {/* Mobile nav */}
+      {open && (
+        <div className="border-t border-border bg-background px-4 py-4 md:hidden">
+          <div className="flex flex-col gap-4">
+            <Link
+              href="#features"
+              onClick={() => setOpen(false)}
+              className="text-xs uppercase tracking-widest text-muted-foreground transition-colors hover:text-primary"
+            >
+              Features
+            </Link>
+            <Link
+              href="#features"
+              onClick={() => setOpen(false)}
+              className="text-xs uppercase tracking-widest text-muted-foreground transition-colors hover:text-primary"
+            >
+              Modes
+            </Link>
+            <Link
+              href="/arena"
+              onClick={() => setOpen(false)}
+              className="text-xs uppercase tracking-widest text-muted-foreground transition-colors hover:text-primary"
+            >
+              Arena
+            </Link>
+            <Link
+              href="/auth"
+              onClick={() => setOpen(false)}
+              className="rounded-sm border border-primary bg-primary px-4 py-1.5 text-center text-xs font-bold uppercase tracking-widest text-primary-foreground"
+            >
+              Sign In
+            </Link>
+          </div>
+        </div>
+      )}
+    </header>
+  )
+}
diff --git a/components/theme-provider.tsx b/components/theme-provider.tsx
new file mode 100644
index 0000000..55c2f6e
--- /dev/null
+++ b/components/theme-provider.tsx
@@ -0,0 +1,11 @@
+'use client'
+
+import * as React from 'react'
+import {
+  ThemeProvider as NextThemesProvider,
+  type ThemeProviderProps,
+} from 'next-themes'
+
+export function ThemeProvider({ children, ...props }: ThemeProviderProps) {
+  return <NextThemesProvider {...props}>{children}</NextThemesProvider>
+}
diff --git a/components/ui/accordion.tsx b/components/ui/accordion.tsx
new file mode 100644
index 0000000..b69428b
--- /dev/null
+++ b/components/ui/accordion.tsx
@@ -0,0 +1,58 @@
+'use client'
+
+import * as React from 'react'
+import * as AccordionPrimitive from '@radix-ui/react-accordion'
+import { ChevronDown } from 'lucide-react'
+
+import { cn } from '@/lib/utils'
+
+const Accordion = AccordionPrimitive.Root
+
+const AccordionItem = React.forwardRef<
+  React.ElementRef<typeof AccordionPrimitive.Item>,
+  React.ComponentPropsWithoutRef<typeof AccordionPrimitive.Item>
+>(({ className, ...props }, ref) => (
+  <AccordionPrimitive.Item
+    ref={ref}
+    className={cn('border-b', className)}
+    {...props}
+  />
+))
+AccordionItem.displayName = 'AccordionItem'
+
+const AccordionTrigger = React.forwardRef<
+  React.ElementRef<typeof AccordionPrimitive.Trigger>,
+  React.ComponentPropsWithoutRef<typeof AccordionPrimitive.Trigger>
+>(({ className, children, ...props }, ref) => (
+  <AccordionPrimitive.Header className="flex">
+    <AccordionPrimitive.Trigger
+      ref={ref}
+      className={cn(
+        'flex flex-1 items-center justify-between py-4 font-medium transition-all hover:underline [&[data-state=open]>svg]:rotate-180',
+        className,
+      )}
+      {...props}
+    >
+      {children}
+      <ChevronDown className="h-4 w-4 shrink-0 transition-transform duration-200" />
+    </AccordionPrimitive.Trigger>
+  </AccordionPrimitive.Header>
+))
+AccordionTrigger.displayName = AccordionPrimitive.Trigger.displayName
+
+const AccordionContent = React.forwardRef<
+  React.ElementRef<typeof AccordionPrimitive.Content>,
+  React.ComponentPropsWithoutRef<typeof AccordionPrimitive.Content>
+>(({ className, children, ...props }, ref) => (
+  <AccordionPrimitive.Content
+    ref={ref}
+    className="overflow-hidden text-sm transition-all data-[state=closed]:animate-accordion-up data-[state=open]:animate-accordion-down"
+    {...props}
+  >
+    <div className={cn('pb-4 pt-0', className)}>{children}</div>
+  </AccordionPrimitive.Content>
+))
+
+AccordionContent.displayName = AccordionPrimitive.Content.displayName
+
+export { Accordion, AccordionItem, AccordionTrigger, AccordionContent }
diff --git a/components/ui/alert-dialog.tsx b/components/ui/alert-dialog.tsx
new file mode 100644
index 0000000..e58f90a
--- /dev/null
+++ b/components/ui/alert-dialog.tsx
@@ -0,0 +1,141 @@
+'use client'
+
+import * as React from 'react'
+import * as AlertDialogPrimitive from '@radix-ui/react-alert-dialog'
+
+import { cn } from '@/lib/utils'
+import { buttonVariants } from '@/components/ui/button'
+
+const AlertDialog = AlertDialogPrimitive.Root
+
+const AlertDialogTrigger = AlertDialogPrimitive.Trigger
+
+const AlertDialogPortal = AlertDialogPrimitive.Portal
+
+const AlertDialogOverlay = React.forwardRef<
+  React.ElementRef<typeof AlertDialogPrimitive.Overlay>,
+  React.ComponentPropsWithoutRef<typeof AlertDialogPrimitive.Overlay>
+>(({ className, ...props }, ref) => (
+  <AlertDialogPrimitive.Overlay
+    className={cn(
+      'fixed inset-0 z-50 bg-black/80  data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0',
+      className,
+    )}
+    {...props}
+    ref={ref}
+  />
+))
+AlertDialogOverlay.displayName = AlertDialogPrimitive.Overlay.displayName
+
+const AlertDialogContent = React.forwardRef<
+  React.ElementRef<typeof AlertDialogPrimitive.Content>,
+  React.ComponentPropsWithoutRef<typeof AlertDialogPrimitive.Content>
+>(({ className, ...props }, ref) => (
+  <AlertDialogPortal>
+    <AlertDialogOverlay />
+    <AlertDialogPrimitive.Content
+      ref={ref}
+      className={cn(
+        'fixed left-[50%] top-[50%] z-50 grid w-full max-w-lg translate-x-[-50%] translate-y-[-50%] gap-4 border bg-background p-6 shadow-lg duration-200 data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[state=closed]:slide-out-to-left-1/2 data-[state=closed]:slide-out-to-top-[48%] data-[state=open]:slide-in-from-left-1/2 data-[state=open]:slide-in-from-top-[48%] sm:rounded-lg',
+        className,
+      )}
+      {...props}
+    />
+  </AlertDialogPortal>
+))
+AlertDialogContent.displayName = AlertDialogPrimitive.Content.displayName
+
+const AlertDialogHeader = ({
+  className,
+  ...props
+}: React.HTMLAttributes<HTMLDivElement>) => (
+  <div
+    className={cn(
+      'flex flex-col space-y-2 text-center sm:text-left',
+      className,
+    )}
+    {...props}
+  />
+)
+AlertDialogHeader.displayName = 'AlertDialogHeader'
+
+const AlertDialogFooter = ({
+  className,
+  ...props
+}: React.HTMLAttributes<HTMLDivElement>) => (
+  <div
+    className={cn(
+      'flex flex-col-reverse sm:flex-row sm:justify-end sm:space-x-2',
+      className,
+    )}
+    {...props}
+  />
+)
+AlertDialogFooter.displayName = 'AlertDialogFooter'
+
+const AlertDialogTitle = React.forwardRef<
+  React.ElementRef<typeof AlertDialogPrimitive.Title>,
+  React.ComponentPropsWithoutRef<typeof AlertDialogPrimitive.Title>
+>(({ className, ...props }, ref) => (
+  <AlertDialogPrimitive.Title
+    ref={ref}
+    className={cn('text-lg font-semibold', className)}
+    {...props}
+  />
+))
+AlertDialogTitle.displayName = AlertDialogPrimitive.Title.displayName
+
+const AlertDialogDescription = React.forwardRef<
+  React.ElementRef<typeof AlertDialogPrimitive.Description>,
+  React.ComponentPropsWithoutRef<typeof AlertDialogPrimitive.Description>
+>(({ className, ...props }, ref) => (
+  <AlertDialogPrimitive.Description
+    ref={ref}
+    className={cn('text-sm text-muted-foreground', className)}
+    {...props}
+  />
+))
+AlertDialogDescription.displayName =
+  AlertDialogPrimitive.Description.displayName
+
+const AlertDialogAction = React.forwardRef<
+  React.ElementRef<typeof AlertDialogPrimitive.Action>,
+  React.ComponentPropsWithoutRef<typeof AlertDialogPrimitive.Action>
+>(({ className, ...props }, ref) => (
+  <AlertDialogPrimitive.Action
+    ref={ref}
+    className={cn(buttonVariants(), className)}
+    {...props}
+  />
+))
+AlertDialogAction.displayName = AlertDialogPrimitive.Action.displayName
+
+const AlertDialogCancel = React.forwardRef<
+  React.ElementRef<typeof AlertDialogPrimitive.Cancel>,
+  React.ComponentPropsWithoutRef<typeof AlertDialogPrimitive.Cancel>
+>(({ className, ...props }, ref) => (
+  <AlertDialogPrimitive.Cancel
+    ref={ref}
+    className={cn(
+      buttonVariants({ variant: 'outline' }),
+      'mt-2 sm:mt-0',
+      className,
+    )}
+    {...props}
+  />
+))
+AlertDialogCancel.displayName = AlertDialogPrimitive.Cancel.displayName
+
+export {
+  AlertDialog,
+  AlertDialogPortal,
+  AlertDialogOverlay,
+  AlertDialogTrigger,
+  AlertDialogContent,
+  AlertDialogHeader,
+  AlertDialogFooter,
+  AlertDialogTitle,
+  AlertDialogDescription,
+  AlertDialogAction,
+  AlertDialogCancel,
+}
diff --git a/components/ui/alert.tsx b/components/ui/alert.tsx
new file mode 100644
index 0000000..2b2ced8
--- /dev/null
+++ b/components/ui/alert.tsx
@@ -0,0 +1,59 @@
+import * as React from 'react'
+import { cva, type VariantProps } from 'class-variance-authority'
+
+import { cn } from '@/lib/utils'
+
+const alertVariants = cva(
+  'relative w-full rounded-lg border p-4 [&>svg~*]:pl-7 [&>svg+div]:translate-y-[-3px] [&>svg]:absolute [&>svg]:left-4 [&>svg]:top-4 [&>svg]:text-foreground',
+  {
+    variants: {
+      variant: {
+        default: 'bg-background text-foreground',
+        destructive:
+          'border-destructive/50 text-destructive dark:border-destructive [&>svg]:text-destructive',
+      },
+    },
+    defaultVariants: {
+      variant: 'default',
+    },
+  },
+)
+
+const Alert = React.forwardRef<
+  HTMLDivElement,
+  React.HTMLAttributes<HTMLDivElement> & VariantProps<typeof alertVariants>
+>(({ className, variant, ...props }, ref) => (
+  <div
+    ref={ref}
+    role="alert"
+    className={cn(alertVariants({ variant }), className)}
+    {...props}
+  />
+))
+Alert.displayName = 'Alert'
+
+const AlertTitle = React.forwardRef<
+  HTMLParagraphElement,
+  React.HTMLAttributes<HTMLHeadingElement>
+>(({ className, ...props }, ref) => (
+  <h5
+    ref={ref}
+    className={cn('mb-1 font-medium leading-none tracking-tight', className)}
+    {...props}
+  />
+))
+AlertTitle.displayName = 'AlertTitle'
+
+const AlertDescription = React.forwardRef<
+  HTMLParagraphElement,
+  React.HTMLAttributes<HTMLParagraphElement>
+>(({ className, ...props }, ref) => (
+  <div
+    ref={ref}
+    className={cn('text-sm [&_p]:leading-relaxed', className)}
+    {...props}
+  />
+))
+AlertDescription.displayName = 'AlertDescription'
+
+export { Alert, AlertTitle, AlertDescription }
diff --git a/components/ui/aspect-ratio.tsx b/components/ui/aspect-ratio.tsx
new file mode 100644
index 0000000..794c6f4
--- /dev/null
+++ b/components/ui/aspect-ratio.tsx
@@ -0,0 +1,7 @@
+'use client'
+
+import * as AspectRatioPrimitive from '@radix-ui/react-aspect-ratio'
+
+const AspectRatio = AspectRatioPrimitive.Root
+
+export { AspectRatio }
diff --git a/components/ui/avatar.tsx b/components/ui/avatar.tsx
new file mode 100644
index 0000000..77fde46
--- /dev/null
+++ b/components/ui/avatar.tsx
@@ -0,0 +1,50 @@
+'use client'
+
+import * as React from 'react'
+import * as AvatarPrimitive from '@radix-ui/react-avatar'
+
+import { cn } from '@/lib/utils'
+
+const Avatar = React.forwardRef<
+  React.ElementRef<typeof AvatarPrimitive.Root>,
+  React.ComponentPropsWithoutRef<typeof AvatarPrimitive.Root>
+>(({ className, ...props }, ref) => (
+  <AvatarPrimitive.Root
+    ref={ref}
+    className={cn(
+      'relative flex h-10 w-10 shrink-0 overflow-hidden rounded-full',
+      className,
+    )}
+    {...props}
+  />
+))
+Avatar.displayName = AvatarPrimitive.Root.displayName
+
+const AvatarImage = React.forwardRef<
+  React.ElementRef<typeof AvatarPrimitive.Image>,
+  React.ComponentPropsWithoutRef<typeof AvatarPrimitive.Image>
+>(({ className, ...props }, ref) => (
+  <AvatarPrimitive.Image
+    ref={ref}
+    className={cn('aspect-square h-full w-full', className)}
+    {...props}
+  />
+))
+AvatarImage.displayName = AvatarPrimitive.Image.displayName
+
+const AvatarFallback = React.forwardRef<
+  React.ElementRef<typeof AvatarPrimitive.Fallback>,
+  React.ComponentPropsWithoutRef<typeof AvatarPrimitive.Fallback>
+>(({ className, ...props }, ref) => (
+  <AvatarPrimitive.Fallback
+    ref={ref}
+    className={cn(
+      'flex h-full w-full items-center justify-center rounded-full bg-muted',
+      className,
+    )}
+    {...props}
+  />
+))
+AvatarFallback.displayName = AvatarPrimitive.Fallback.displayName
+
+export { Avatar, AvatarImage, AvatarFallback }
diff --git a/components/ui/badge.tsx b/components/ui/badge.tsx
new file mode 100644
index 0000000..eb4ccad
--- /dev/null
+++ b/components/ui/badge.tsx
@@ -0,0 +1,37 @@
+import * as React from 'react'
+import { cva, type VariantProps } from 'class-variance-authority'
+
+import { cn } from '@/lib/utils'
+
+const badgeVariants = cva(
+  'inline-flex items-center rounded-full border px-2.5 py-0.5 text-xs font-semibold transition-colors focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2',
+  {
+    variants: {
+      variant: {
+        default:
+          'border-transparent bg-primary text-primary-foreground hover:bg-primary/80',
+        secondary:
+          'border-transparent bg-secondary text-secondary-foreground hover:bg-secondary/80',
+        destructive:
+          'border-transparent bg-destructive text-destructive-foreground hover:bg-destructive/80',
+        outline: 'text-foreground',
+      },
+    },
+    defaultVariants: {
+      variant: 'default',
+    },
+  },
+)
+
+export interface BadgeProps
+  extends
+    React.HTMLAttributes<HTMLDivElement>,
+    VariantProps<typeof badgeVariants> {}
+
+function Badge({ className, variant, ...props }: BadgeProps) {
+  return (
+    <div className={cn(badgeVariants({ variant }), className)} {...props} />
+  )
+}
+
+export { Badge, badgeVariants }
diff --git a/components/ui/breadcrumb.tsx b/components/ui/breadcrumb.tsx
new file mode 100644
index 0000000..d731202
--- /dev/null
+++ b/components/ui/breadcrumb.tsx
@@ -0,0 +1,115 @@
+import * as React from 'react'
+import { Slot } from '@radix-ui/react-slot'
+import { ChevronRight, MoreHorizontal } from 'lucide-react'
+
+import { cn } from '@/lib/utils'
+
+const Breadcrumb = React.forwardRef<
+  HTMLElement,
+  React.ComponentPropsWithoutRef<'nav'> & {
+    separator?: React.ReactNode
+  }
+>(({ ...props }, ref) => <nav ref={ref} aria-label="breadcrumb" {...props} />)
+Breadcrumb.displayName = 'Breadcrumb'
+
+const BreadcrumbList = React.forwardRef<
+  HTMLOListElement,
+  React.ComponentPropsWithoutRef<'ol'>
+>(({ className, ...props }, ref) => (
+  <ol
+    ref={ref}
+    className={cn(
+      'flex flex-wrap items-center gap-1.5 break-words text-sm text-muted-foreground sm:gap-2.5',
+      className,
+    )}
+    {...props}
+  />
+))
+BreadcrumbList.displayName = 'BreadcrumbList'
+
+const BreadcrumbItem = React.forwardRef<
+  HTMLLIElement,
+  React.ComponentPropsWithoutRef<'li'>
+>(({ className, ...props }, ref) => (
+  <li
+    ref={ref}
+    className={cn('inline-flex items-center gap-1.5', className)}
+    {...props}
+  />
+))
+BreadcrumbItem.displayName = 'BreadcrumbItem'
+
+const BreadcrumbLink = React.forwardRef<
+  HTMLAnchorElement,
+  React.ComponentPropsWithoutRef<'a'> & {
+    asChild?: boolean
+  }
+>(({ asChild, className, ...props }, ref) => {
+  const Comp = asChild ? Slot : 'a'
+
+  return (
+    <Comp
+      ref={ref}
+      className={cn('transition-colors hover:text-foreground', className)}
+      {...props}
+    />
+  )
+})
+BreadcrumbLink.displayName = 'BreadcrumbLink'
+
+const BreadcrumbPage = React.forwardRef<
+  HTMLSpanElement,
+  React.ComponentPropsWithoutRef<'span'>
+>(({ className, ...props }, ref) => (
+  <span
+    ref={ref}
+    role="link"
+    aria-disabled="true"
+    aria-current="page"
+    className={cn('font-normal text-foreground', className)}
+    {...props}
+  />
+))
+BreadcrumbPage.displayName = 'BreadcrumbPage'
+
+const BreadcrumbSeparator = ({
+  children,
+  className,
+  ...props
+}: React.ComponentProps<'li'>) => (
+  <li
+    role="presentation"
+    aria-hidden="true"
+    className={cn('[&>svg]:w-3.5 [&>svg]:h-3.5', className)}
+    {...props}
+  >
+    {children ?? <ChevronRight />}
+  </li>
+)
+BreadcrumbSeparator.displayName = 'BreadcrumbSeparator'
+
+const BreadcrumbEllipsis = ({
+  className,
+  ...props
+}: React.ComponentProps<'span'>) => (
+  <span
+    role="presentation"
+    aria-hidden="true"
+    className={cn('flex h-9 w-9 items-center justify-center', className)}
+    {...props}
+  >
+    <MoreHorizontal className="h-4 w-4" />
+    <span className="sr-only">More</span>
+  </span>
+)
+BreadcrumbEllipsis.displayName = 'BreadcrumbElipssis'
+
+export {
+  Breadcrumb,
+  BreadcrumbList,
+  BreadcrumbItem,
+  BreadcrumbLink,
+  BreadcrumbPage,
+  BreadcrumbSeparator,
+  BreadcrumbEllipsis,
+}
diff --git a/components/ui/button.tsx b/components/ui/button.tsx
new file mode 100644
index 0000000..7c700e1
--- /dev/null
+++ b/components/ui/button.tsx
@@ -0,0 +1,57 @@
+import * as React from 'react'
+import { Slot } from '@radix-ui/react-slot'
+import { cva, type VariantProps } from 'class-variance-authority'
+
+import { cn } from '@/lib/utils'
+
+const buttonVariants = cva(
+  'inline-flex items-center justify-center gap-2 whitespace-nowrap rounded-md text-sm font-medium ring-offset-background transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:size-4 [&_svg]:shrink-0',
+  {
+    variants: {
+      variant: {
+        default: 'bg-primary text-primary-foreground hover:bg-primary/90',
+        destructive:
+          'bg-destructive text-destructive-foreground hover:bg-destructive/90',
+        outline:
+          'border border-input bg-background hover:bg-accent hover:text-accent-foreground',
+        secondary:
+          'bg-secondary text-secondary-foreground hover:bg-secondary/80',
+        ghost: 'hover:bg-accent hover:text-accent-foreground',
+        link: 'text-primary underline-offset-4 hover:underline',
+      },
+      size: {
+        default: 'h-10 px-4 py-2',
+        sm: 'h-9 rounded-md px-3',
+        lg: 'h-11 rounded-md px-8',
+        icon: 'h-10 w-10',
+      },
+    },
+    defaultVariants: {
+      variant: 'default',
+      size: 'default',
+    },
+  },
+)
+
+export interface ButtonProps
+  extends
+    React.ButtonHTMLAttributes<HTMLButtonElement>,
+    VariantProps<typeof buttonVariants> {
+  asChild?: boolean
+}
+
+const Button = React.forwardRef<HTMLButtonElement, ButtonProps>(
+  ({ className, variant, size, asChild = false, ...props }, ref) => {
+    const Comp = asChild ? Slot : 'button'
+    return (
+      <Comp
+        className={cn(buttonVariants({ variant, size, className }))}
+        ref={ref}
+        {...props}
+      />
+    )
+  },
+)
+Button.displayName = 'Button'
+
+export { Button, buttonVariants }
diff --git a/components/ui/calendar.tsx b/components/ui/calendar.tsx
new file mode 100644
index 0000000..4c6fa90
--- /dev/null
+++ b/components/ui/calendar.tsx
@@ -0,0 +1,66 @@
+'use client'
+
+import * as React from 'react'
+import { ChevronLeft, ChevronRight } from 'lucide-react'
+import { DayPicker } from 'react-day-picker'
+
+import { cn } from '@/lib/utils'
+import { buttonVariants } from '@/components/ui/button'
+
+export type CalendarProps = React.ComponentProps<typeof DayPicker>
+
+function Calendar({
+  className,
+  classNames,
+  showOutsideDays = true,
+  ...props
+}: CalendarProps) {
+  return (
+    <DayPicker
+      showOutsideDays={showOutsideDays}
+      className={cn('p-3', className)}
+      classNames={{
+        months: 'flex flex-col sm:flex-row space-y-4 sm:space-x-4 sm:space-y-0',
+        month: 'space-y-4',
+        caption: 'flex justify-center pt-1 relative items-center',
+        caption_label: 'text-sm font-medium',
+        nav: 'space-x-1 flex items-center',
+        nav_button: cn(
+          buttonVariants({ variant: 'outline' }),
+          'h-7 w-7 bg-transparent p-0 opacity-50 hover:opacity-100',
+        ),
+        nav_button_previous: 'absolute left-1',
+        nav_button_next: 'absolute right-1',
+        table: 'w-full border-collapse space-y-1',
+        head_row: 'flex',
+        head_cell:
+          'text-muted-foreground rounded-md w-9 font-normal text-[0.8rem]',
+        row: 'flex w-full mt-2',
+        cell: 'h-9 w-9 text-center text-sm p-0 relative [&:has([aria-selected].day-range-end)]:rounded-r-md [&:has([aria-selected].day-outside)]:bg-accent/50 [&:has([aria-selected])]:bg-accent first:[&:has([aria-selected])]:rounded-l-md last:[&:has([aria-selected])]:rounded-r-md focus-within:relative focus-within:z-20',
+        day: cn(
+          buttonVariants({ variant: 'ghost' }),
+          'h-9 w-9 p-0 font-normal aria-selected:opacity-100',
+        ),
+        day_range_end: 'day-range-end',
+        day_selected:
+          'bg-primary text-primary-foreground hover:bg-primary hover:text-primary-foreground focus:bg-primary focus:text-primary-foreground',
+        day_today: 'bg-accent text-accent-foreground',
+        day_outside:
+          'day-outside text-muted-foreground aria-selected:bg-accent/50 aria-selected:text-muted-foreground',
+        day_disabled: 'text-muted-foreground opacity-50',
+        day_range_middle:
+          'aria-selected:bg-accent aria-selected:text-accent-foreground',
+        day_hidden: 'invisible',
+        ...classNames,
+      }}
+      components={{
+        IconLeft: ({ ...props }) => <ChevronLeft className="h-4 w-4" />,
+        IconRight: ({ ...props }) => <ChevronRight className="h-4 w-4" />,
+      }}
+      {...props}
+    />
+  )
+}
+Calendar.displayName = 'Calendar'
+
+export { Calendar }
diff --git a/components/ui/card.tsx b/components/ui/card.tsx
new file mode 100644
index 0000000..1aab4ef
--- /dev/null
+++ b/components/ui/card.tsx
@@ -0,0 +1,79 @@
+import * as React from 'react'
+
+import { cn } from '@/lib/utils'
+
+const Card = React.forwardRef<
+  HTMLDivElement,
+  React.HTMLAttributes<HTMLDivElement>
+>(({ className, ...props }, ref) => (
+  <div
+    ref={ref}
+    className={cn(
+      'rounded-lg border bg-card text-card-foreground shadow-sm',
+      className,
+    )}
+    {...props}
+  />
+))
+Card.displayName = 'Card'
+
+const CardHeader = React.forwardRef<
+  HTMLDivElement,
+  React.HTMLAttributes<HTMLDivElement>
+>(({ className, ...props }, ref) => (
+  <div
+    ref={ref}
+    className={cn('flex flex-col space-y-1.5 p-6', className)}
+    {...props}
+  />
+))
+CardHeader.displayName = 'CardHeader'
+
+const CardTitle = React.forwardRef<
+  HTMLDivElement,
+  React.HTMLAttributes<HTMLDivElement>
+>(({ className, ...props }, ref) => (
+  <div
+    ref={ref}
+    className={cn(
+      'text-2xl font-semibold leading-none tracking-tight',
+      className,
+    )}
+    {...props}
+  />
+))
+CardTitle.displayName = 'CardTitle'
+
+const CardDescription = React.forwardRef<
+  HTMLDivElement,
+  React.HTMLAttributes<HTMLDivElement>
+>(({ className, ...props }, ref) => (
+  <div
+    ref={ref}
+    className={cn('text-sm text-muted-foreground', className)}
+    {...props}
+  />
+))
+CardDescription.displayName = 'CardDescription'
+
+const CardContent = React.forwardRef<
+  HTMLDivElement,
+  React.HTMLAttributes<HTMLDivElement>
+>(({ className, ...props }, ref) => (
+  <div ref={ref} className={cn('p-6 pt-0', className)} {...props} />
+))
+CardContent.displayName = 'CardContent'
+
+const CardFooter = React.forwardRef<
+  HTMLDivElement,
+  React.HTMLAttributes<HTMLDivElement>
+>(({ className, ...props }, ref) => (
+  <div
+    ref={ref}
+    className={cn('flex items-center p-6 pt-0', className)}
+    {...props}
+  />
+))
+CardFooter.displayName = 'CardFooter'
+
+export { Card, CardHeader, CardFooter, CardTitle, CardDescription, CardContent }
diff --git a/components/ui/carousel.tsx b/components/ui/carousel.tsx
new file mode 100644
index 0000000..4c82dbc
--- /dev/null
+++ b/components/ui/carousel.tsx
@@ -0,0 +1,262 @@
+'use client'
+
+import * as React from 'react'
+import useEmblaCarousel, {
+  type UseEmblaCarouselType,
+} from 'embla-carousel-react'
+import { ArrowLeft, ArrowRight } from 'lucide-react'
+
+import { cn } from '@/lib/utils'
+import { Button } from '@/components/ui/button'
+
+type CarouselApi = UseEmblaCarouselType[1]
+type UseCarouselParameters = Parameters<typeof useEmblaCarousel>
+type CarouselOptions = UseCarouselParameters[0]
+type CarouselPlugin = UseCarouselParameters[1]
+
+type CarouselProps = {
+  opts?: CarouselOptions
+  plugins?: CarouselPlugin
+  orientation?: 'horizontal' | 'vertical'
+  setApi?: (api: CarouselApi) => void
+}
+
+type CarouselContextProps = {
+  carouselRef: ReturnType<typeof useEmblaCarousel>[0]
+  api: ReturnType<typeof useEmblaCarousel>[1]
+  scrollPrev: () => void
+  scrollNext: () => void
+  canScrollPrev: boolean
+  canScrollNext: boolean
+} & CarouselProps
+
+const CarouselContext = React.createContext<CarouselContextProps | null>(null)
+
+function useCarousel() {
+  const context = React.useContext(CarouselContext)
+
+  if (!context) {
+    throw new Error('useCarousel must be used within a <Carousel />')
+  }
+
+  return context
+}
+
+const Carousel = React.forwardRef<
+  HTMLDivElement,
+  React.HTMLAttributes<HTMLDivElement> & CarouselProps
+>(
+  (
+    {
+      orientation = 'horizontal',
+      opts,
+      setApi,
+      plugins,
+      className,
+      children,
+      ...props
+    },
+    ref,
+  ) => {
+    const [carouselRef, api] = useEmblaCarousel(
+      {
+        ...opts,
+        axis: orientation === 'horizontal' ? 'x' : 'y',
+      },
+      plugins,
+    )
+    const [canScrollPrev, setCanScrollPrev] = React.useState(false)
+    const [canScrollNext, setCanScrollNext] = React.useState(false)
+
+    const onSelect = React.useCallback((api: CarouselApi) => {
+      if (!api) {
+        return
+      }
+
+      setCanScrollPrev(api.canScrollPrev())
+      setCanScrollNext(api.canScrollNext())
+    }, [])
+
+    const scrollPrev = React.useCallback(() => {
+      api?.scrollPrev()
+    }, [api])
+
+    const scrollNext = React.useCallback(() => {
+      api?.scrollNext()
+    }, [api])
+
+    const handleKeyDown = React.useCallback(
+      (event: React.KeyboardEvent<HTMLDivElement>) => {
+        if (event.key === 'ArrowLeft') {
+          event.preventDefault()
+          scrollPrev()
+        } else if (event.key === 'ArrowRight') {
+          event.preventDefault()
+          scrollNext()
+        }
+      },
+      [scrollPrev, scrollNext],
+    )
+
+    React.useEffect(() => {
+      if (!api || !setApi) {
+        return
+      }
+
+      setApi(api)
+    }, [api, setApi])
+
+    React.useEffect(() => {
+      if (!api) {
+        return
+      }
+
+      onSelect(api)
+      api.on('reInit', onSelect)
+      api.on('select', onSelect)
+
+      return () => {
+        api?.off('select', onSelect)
+      }
+    }, [api, onSelect])
+
+    return (
+      <CarouselContext.Provider
+        value={{
+          carouselRef,
+          api: api,
+          opts,
+          orientation:
+            orientation || (opts?.axis === 'y' ? 'vertical' : 'horizontal'),
+          scrollPrev,
+          scrollNext,
+          canScrollPrev,
+          canScrollNext,
+        }}
+      >
+        <div
+          ref={ref}
+          onKeyDownCapture={handleKeyDown}
+          className={cn('relative', className)}
+          role="region"
+          aria-roledescription="carousel"
+          {...props}
+        >
+          {children}
+        </div>
+      </CarouselContext.Provider>
+    )
+  },
+)
+Carousel.displayName = 'Carousel'
+
+const CarouselContent = React.forwardRef<
+  HTMLDivElement,
+  React.HTMLAttributes<HTMLDivElement>
+>(({ className, ...props }, ref) => {
+  const { carouselRef, orientation } = useCarousel()
+
+  return (
+    <div ref={carouselRef} className="overflow-hidden">
+      <div
+        ref={ref}
+        className={cn(
+          'flex',
+          orientation === 'horizontal' ? '-ml-4' : '-mt-4 flex-col',
+          className,
+        )}
+        {...props}
+      />
+    </div>
+  )
+})
+CarouselContent.displayName = 'CarouselContent'
+
+const CarouselItem = React.forwardRef<
+  HTMLDivElement,
+  React.HTMLAttributes<HTMLDivElement>
+>(({ className, ...props }, ref) => {
+  const { orientation } = useCarousel()
+
+  return (
+    <div
+      ref={ref}
+      role="group"
+      aria-roledescription="slide"
+      className={cn(
+        'min-w-0 shrink-0 grow-0 basis-full',
+        orientation === 'horizontal' ? 'pl-4' : 'pt-4',
+        className,
+      )}
+      {...props}
+    />
+  )
+})
+CarouselItem.displayName = 'CarouselItem'
+
+const CarouselPrevious = React.forwardRef<
+  HTMLButtonElement,
+  React.ComponentProps<typeof Button>
+>(({ className, variant = 'outline', size = 'icon', ...props }, ref) => {
+  const { orientation, scrollPrev, canScrollPrev } = useCarousel()
+
+  return (
+    <Button
+      ref={ref}
+      variant={variant}
+      size={size}
+      className={cn(
+        'absolute  h-8 w-8 rounded-full',
+        orientation === 'horizontal'
+          ? '-left-12 top-1/2 -translate-y-1/2'
+          : '-top-12 left-1/2 -translate-x-1/2 rotate-90',
+        className,
+      )}
+      disabled={!canScrollPrev}
+      onClick={scrollPrev}
+      {...props}
+    >
+      <ArrowLeft className="h-4 w-4" />
+      <span className="sr-only">Previous slide</span>
+    </Button>
+  )
+})
+CarouselPrevious.displayName = 'CarouselPrevious'
+
+const CarouselNext = React.forwardRef<
+  HTMLButtonElement,
+  React.ComponentProps<typeof Button>
+>(({ className, variant = 'outline', size = 'icon', ...props }, ref) => {
+  const { orientation, scrollNext, canScrollNext } = useCarousel()
+
+  return (
+    <Button
+      ref={ref}
+      variant={variant}
+      size={size}
+      className={cn(
+        'absolute h-8 w-8 rounded-full',
+        orientation === 'horizontal'
+          ? '-right-12 top-1/2 -translate-y-1/2'
+          : '-bottom-12 left-1/2 -translate-x-1/2 rotate-90',
+        className,
+      )}
+      disabled={!canScrollNext}
+      onClick={scrollNext}
+      {...props}
+    >
+      <ArrowRight className="h-4 w-4" />
+      <span className="sr-only">Next slide</span>
+    </Button>
+  )
+})
+CarouselNext.displayName = 'CarouselNext'
+
+export {
+  type CarouselApi,
+  Carousel,
+  CarouselContent,
+  CarouselItem,
+  CarouselPrevious,
+  CarouselNext,
+}
diff --git a/components/ui/chart.tsx b/components/ui/chart.tsx
new file mode 100644
index 0000000..7bbe8e3
--- /dev/null
+++ b/components/ui/chart.tsx
@@ -0,0 +1,365 @@
+'use client'
+
+import * as React from 'react'
+import * as RechartsPrimitive from 'recharts'
+
+import { cn } from '@/lib/utils'
+
+// Format: { THEME_NAME: CSS_SELECTOR }
+const THEMES = { light: '', dark: '.dark' } as const
+
+export type ChartConfig = {
+  [k in string]: {
+    label?: React.ReactNode
+    icon?: React.ComponentType
+  } & (
+    | { color?: string; theme?: never }
+    | { color?: never; theme: Record<keyof typeof THEMES, string> }
+  )
+}
+
+type ChartContextProps = {
+  config: ChartConfig
+}
+
+const ChartContext = React.createContext<ChartContextProps | null>(null)
+
+function useChart() {
+  const context = React.useContext(ChartContext)
+
+  if (!context) {
+    throw new Error('useChart must be used within a <ChartContainer />')
+  }
+
+  return context
+}
+
+const ChartContainer = React.forwardRef<
+  HTMLDivElement,
+  React.ComponentProps<'div'> & {
+    config: ChartConfig
+    children: React.ComponentProps<
+      typeof RechartsPrimitive.ResponsiveContainer
+    >['children']
+  }
+>(({ id, className, children, config, ...props }, ref) => {
+  const uniqueId = React.useId()
+  const chartId = `chart-${id || uniqueId.replace(/:/g, '')}`
+
+  return (
+    <ChartContext.Provider value={{ config }}>
+      <div
+        data-chart={chartId}
+        ref={ref}
+        className={cn(
+          "flex aspect-video justify-center text-xs [&_.recharts-cartesian-axis-tick_text]:fill-muted-foreground [&_.recharts-cartesian-grid_line[stroke='#ccc']]:stroke-border/50 [&_.recharts-curve.recharts-tooltip-cursor]:stroke-border [&_.recharts-dot[stroke='#fff']]:stroke-transparent [&_.recharts-layer]:outline-none [&_.recharts-polar-grid_[stroke='#ccc']]:stroke-border [&_.recharts-radial-bar-background-sector]:fill-muted [&_.recharts-rectangle.recharts-tooltip-cursor]:fill-muted [&_.recharts-reference-line_[stroke='#ccc']]:stroke-border [&_.recharts-sector[stroke='#fff']]:stroke-transparent [&_.recharts-sector]:outline-none [&_.recharts-surface]:outline-none",
+          className,
+        )}
+        {...props}
+      >
+        <ChartStyle id={chartId} config={config} />
+        <RechartsPrimitive.ResponsiveContainer>
+          {children}
+        </RechartsPrimitive.ResponsiveContainer>
+      </div>
+    </ChartContext.Provider>
+  )
+})
+ChartContainer.displayName = 'Chart'
+
+const ChartStyle = ({ id, config }: { id: string; config: ChartConfig }) => {
+  const colorConfig = Object.entries(config).filter(
+    ([_, config]) => config.theme || config.color,
+  )
+
+  if (!colorConfig.length) {
+    return null
+  }
+
+  return (
+    <style
+      dangerouslySetInnerHTML={{
+        __html: Object.entries(THEMES)
+          .map(
+            ([theme, prefix]) => `
+${prefix} [data-chart=${id}] {
+${colorConfig
+  .map(([key, itemConfig]) => {
+    const color =
+      itemConfig.theme?.[theme as keyof typeof itemConfig.theme] ||
+      itemConfig.color
+    return color ? `  --color-${key}: ${color};` : null
+  })
+  .join('\n')}
+}
+`,
+          )
+          .join('\n'),
+      }}
+    />
+  )
+}
+
+const ChartTooltip = RechartsPrimitive.Tooltip
+
+const ChartTooltipContent = React.forwardRef<
+  HTMLDivElement,
+  React.ComponentProps<typeof RechartsPrimitive.Tooltip> &
+    React.ComponentProps<'div'> & {
+      hideLabel?: boolean
+      hideIndicator?: boolean
+      indicator?: 'line' | 'dot' | 'dashed'
+      nameKey?: string
+      labelKey?: string
+    }
+>(
+  (
+    {
+      active,
+      payload,
+      className,
+      indicator = 'dot',
+      hideLabel = false,
+      hideIndicator = false,
+      label,
+      labelFormatter,
+      labelClassName,
+      formatter,
+      color,
+      nameKey,
+      labelKey,
+    },
+    ref,
+  ) => {
+    const { config } = useChart()
+
+    const tooltipLabel = React.useMemo(() => {
+      if (hideLabel || !payload?.length) {
+        return null
+      }
+
+      const [item] = payload
+      const key = `${labelKey || item.dataKey || item.name || 'value'}`
+      const itemConfig = getPayloadConfigFromPayload(config, item, key)
+      const value =
+        !labelKey && typeof label === 'string'
+          ? config[label as keyof typeof config]?.label || label
+          : itemConfig?.label
+
+      if (labelFormatter) {
+        return (
+          <div className={cn('font-medium', labelClassName)}>
+            {labelFormatter(value, payload)}
+          </div>
+        )
+      }
+
+      if (!value) {
+        return null
+      }
+
+      return <div className={cn('font-medium', labelClassName)}>{value}</div>
+    }, [
+      label,
+      labelFormatter,
+      payload,
+      hideLabel,
+      labelClassName,
+      config,
+      labelKey,
+    ])
+
+    if (!active || !payload?.length) {
+      return null
+    }
+
+    const nestLabel = payload.length === 1 && indicator !== 'dot'
+
+    return (
+      <div
+        ref={ref}
+        className={cn(
+          'grid min-w-[8rem] items-start gap-1.5 rounded-lg border border-border/50 bg-background px-2.5 py-1.5 text-xs shadow-xl',
+          className,
+        )}
+      >
+        {!nestLabel ? tooltipLabel : null}
+        <div className="grid gap-1.5">
+          {payload.map((item, index) => {
+            const key = `${nameKey || item.name || item.dataKey || 'value'}`
+            const itemConfig = getPayloadConfigFromPayload(config, item, key)
+            const indicatorColor = color || item.payload.fill || item.color
+
+            return (
+              <div
+                key={item.dataKey}
+                className={cn(
+                  'flex w-full flex-wrap items-stretch gap-2 [&>svg]:h-2.5 [&>svg]:w-2.5 [&>svg]:text-muted-foreground',
+                  indicator === 'dot' && 'items-center',
+                )}
+              >
+                {formatter && item?.value !== undefined && item.name ? (
+                  formatter(item.value, item.name, item, index, item.payload)
+                ) : (
+                  <>
+                    {itemConfig?.icon ? (
+                      <itemConfig.icon />
+                    ) : (
+                      !hideIndicator && (
+                        <div
+                          className={cn(
+                            'shrink-0 rounded-[2px] border-[--color-border] bg-[--color-bg]',
+                            {
+                              'h-2.5 w-2.5': indicator === 'dot',
+                              'w-1': indicator === 'line',
+                              'w-0 border-[1.5px] border-dashed bg-transparent':
+                                indicator === 'dashed',
+                              'my-0.5': nestLabel && indicator === 'dashed',
+                            },
+                          )}
+                          style={
+                            {
+                              '--color-bg': indicatorColor,
+                              '--color-border': indicatorColor,
+                            } as React.CSSProperties
+                          }
+                        />
+                      )
+                    )}
+                    <div
+                      className={cn(
+                        'flex flex-1 justify-between leading-none',
+                        nestLabel ? 'items-end' : 'items-center',
+                      )}
+                    >
+                      <div className="grid gap-1.5">
+                        {nestLabel ? tooltipLabel : null}
+                        <span className="text-muted-foreground">
+                          {itemConfig?.label || item.name}
+                        </span>
+                      </div>
+                      {item.value && (
+                        <span className="font-mono font-medium tabular-nums text-foreground">
+                          {item.value.toLocaleString()}
+                        </span>
+                      )}
+                    </div>
+                  </>
+                )}
+              </div>
+            )
+          })}
+        </div>
+      </div>
+    )
+  },
+)
+ChartTooltipContent.displayName = 'ChartTooltip'
+
+const ChartLegend = RechartsPrimitive.Legend
+
+const ChartLegendContent = React.forwardRef<
+  HTMLDivElement,
+  React.ComponentProps<'div'> &
+    Pick<RechartsPrimitive.LegendProps, 'payload' | 'verticalAlign'> & {
+      hideIcon?: boolean
+      nameKey?: string
+    }
+>(
+  (
+    { className, hideIcon = false, payload, verticalAlign = 'bottom', nameKey },
+    ref,
+  ) => {
+    const { config } = useChart()
+
+    if (!payload?.length) {
+      return null
+    }
+
+    return (
+      <div
+        ref={ref}
+        className={cn(
+          'flex items-center justify-center gap-4',
+          verticalAlign === 'top' ? 'pb-3' : 'pt-3',
+          className,
+        )}
+      >
+        {payload.map((item) => {
+          const key = `${nameKey || item.dataKey || 'value'}`
+          const itemConfig = getPayloadConfigFromPayload(config, item, key)
+
+          return (
+            <div
+              key={item.value}
+              className={cn(
+                'flex items-center gap-1.5 [&>svg]:h-3 [&>svg]:w-3 [&>svg]:text-muted-foreground',
+              )}
+            >
+              {itemConfig?.icon && !hideIcon ? (
+                <itemConfig.icon />
+              ) : (
+                <div
+                  className="h-2 w-2 shrink-0 rounded-[2px]"
+                  style={{
+                    backgroundColor: item.color,
+                  }}
+                />
+              )}
+              {itemConfig?.label}
+            </div>
+          )
+        })}
+      </div>
+    )
+  },
+)
+ChartLegendContent.displayName = 'ChartLegend'
+
+// Helper to extract item config from a payload.
+function getPayloadConfigFromPayload(
+  config: ChartConfig,
+  payload: unknown,
+  key: string,
+) {
+  if (typeof payload !== 'object' || payload === null) {
+    return undefined
+  }
+
+  const payloadPayload =
+    'payload' in payload &&
+    typeof payload.payload === 'object' &&
+    payload.payload !== null
+      ? payload.payload
+      : undefined
+
+  let configLabelKey: string = key
+
+  if (
+    key in payload &&
+    typeof payload[key as keyof typeof payload] === 'string'
+  ) {
+    configLabelKey = payload[key as keyof typeof payload] as string
+  } else if (
+    payloadPayload &&
+    key in payloadPayload &&
+    typeof payloadPayload[key as keyof typeof payloadPayload] === 'string'
+  ) {
+    configLabelKey = payloadPayload[
+      key as keyof typeof payloadPayload
+    ] as string
+  }
+
+  return configLabelKey in config
+    ? config[configLabelKey]
+    : config[key as keyof typeof config]
+}
+
+export {
+  ChartContainer,
+  ChartTooltip,
+  ChartTooltipContent,
+  ChartLegend,
+  ChartLegendContent,
+  ChartStyle,
+}
diff --git a/components/ui/checkbox.tsx b/components/ui/checkbox.tsx
new file mode 100644
index 0000000..f2a17ee
--- /dev/null
+++ b/components/ui/checkbox.tsx
@@ -0,0 +1,30 @@
+'use client'
+
+import * as React from 'react'
+import * as CheckboxPrimitive from '@radix-ui/react-checkbox'
+import { Check } from 'lucide-react'
+
+import { cn } from '@/lib/utils'
+
+const Checkbox = React.forwardRef<
+  React.ElementRef<typeof CheckboxPrimitive.Root>,
+  React.ComponentPropsWithoutRef<typeof CheckboxPrimitive.Root>
+>(({ className, ...props }, ref) => (
+  <CheckboxPrimitive.Root
+    ref={ref}
+    className={cn(
+      'peer h-4 w-4 shrink-0 rounded-sm border border-primary ring-offset-background focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50 data-[state=checked]:bg-primary data-[state=checked]:text-primary-foreground',
+      className,
+    )}
+    {...props}
+  >
+    <CheckboxPrimitive.Indicator
+      className={cn('flex items-center justify-center text-current')}
+    >
+      <Check className="h-4 w-4" />
+    </CheckboxPrimitive.Indicator>
+  </CheckboxPrimitive.Root>
+))
+Checkbox.displayName = CheckboxPrimitive.Root.displayName
+
+export { Checkbox }
diff --git a/components/ui/collapsible.tsx b/components/ui/collapsible.tsx
new file mode 100644
index 0000000..1bbaed5
--- /dev/null
+++ b/components/ui/collapsible.tsx
@@ -0,0 +1,11 @@
+'use client'
+
+import * as CollapsiblePrimitive from '@radix-ui/react-collapsible'
+
+const Collapsible = CollapsiblePrimitive.Root
+
+const CollapsibleTrigger = CollapsiblePrimitive.CollapsibleTrigger
+
+const CollapsibleContent = CollapsiblePrimitive.CollapsibleContent
+
+export { Collapsible, CollapsibleTrigger, CollapsibleContent }
diff --git a/components/ui/command.tsx b/components/ui/command.tsx
new file mode 100644
index 0000000..d04242c
--- /dev/null
+++ b/components/ui/command.tsx
@@ -0,0 +1,153 @@
+'use client'
+
+import * as React from 'react'
+import { type DialogProps } from '@radix-ui/react-dialog'
+import { Command as CommandPrimitive } from 'cmdk'
+import { Search } from 'lucide-react'
+
+import { cn } from '@/lib/utils'
+import { Dialog, DialogContent } from '@/components/ui/dialog'
+
+const Command = React.forwardRef<
+  React.ElementRef<typeof CommandPrimitive>,
+  React.ComponentPropsWithoutRef<typeof CommandPrimitive>
+>(({ className, ...props }, ref) => (
+  <CommandPrimitive
+    ref={ref}
+    className={cn(
+      'flex h-full w-full flex-col overflow-hidden rounded-md bg-popover text-popover-foreground',
+      className,
+    )}
+    {...props}
+  />
+))
+Command.displayName = CommandPrimitive.displayName
+
+const CommandDialog = ({ children, ...props }: DialogProps) => {
+  return (
+    <Dialog {...props}>
+      <DialogContent className="overflow-hidden p-0 shadow-lg">
+        <Command className="[&_[cmdk-group-heading]]:px-2 [&_[cmdk-group-heading]]:font-medium [&_[cmdk-group-heading]]:text-muted-foreground [&_[cmdk-group]:not([hidden])_~[cmdk-group]]:pt-0 [&_[cmdk-group]]:px-2 [&_[cmdk-input-wrapper]_svg]:h-5 [&_[cmdk-input-wrapper]_svg]:w-5 [&_[cmdk-input]]:h-12 [&_[cmdk-item]]:px-2 [&_[cmdk-item]]:py-3 [&_[cmdk-item]_svg]:h-5 [&_[cmdk-item]_svg]:w-5">
+          {children}
+        </Command>
+      </DialogContent>
+    </Dialog>
+  )
+}
+
+const CommandInput = React.forwardRef<
+  React.ElementRef<typeof CommandPrimitive.Input>,
+  React.ComponentPropsWithoutRef<typeof CommandPrimitive.Input>
+>(({ className, ...props }, ref) => (
+  <div className="flex items-center border-b px-3" cmdk-input-wrapper="">
+    <Search className="mr-2 h-4 w-4 shrink-0 opacity-50" />
+    <CommandPrimitive.Input
+      ref={ref}
+      className={cn(
+        'flex h-11 w-full rounded-md bg-transparent py-3 text-sm outline-none placeholder:text-muted-foreground disabled:cursor-not-allowed disabled:opacity-50',
+        className,
+      )}
+      {...props}
+    />
+  </div>
+))
+
+CommandInput.displayName = CommandPrimitive.Input.displayName
+
+const CommandList = React.forwardRef<
+  React.ElementRef<typeof CommandPrimitive.List>,
+  React.ComponentPropsWithoutRef<typeof CommandPrimitive.List>
+>(({ className, ...props }, ref) => (
+  <CommandPrimitive.List
+    ref={ref}
+    className={cn('max-h-[300px] overflow-y-auto overflow-x-hidden', className)}
+    {...props}
+  />
+))
+
+CommandList.displayName = CommandPrimitive.List.displayName
+
+const CommandEmpty = React.forwardRef<
+  React.ElementRef<typeof CommandPrimitive.Empty>,
+  React.ComponentPropsWithoutRef<typeof CommandPrimitive.Empty>
+>((props, ref) => (
+  <CommandPrimitive.Empty
+    ref={ref}
+    className="py-6 text-center text-sm"
+    {...props}
+  />
+))
+
+CommandEmpty.displayName = CommandPrimitive.Empty.displayName
+
+const CommandGroup = React.forwardRef<
+  React.ElementRef<typeof CommandPrimitive.Group>,
+  React.ComponentPropsWithoutRef<typeof CommandPrimitive.Group>
+>(({ className, ...props }, ref) => (
+  <CommandPrimitive.Group
+    ref={ref}
+    className={cn(
+      'overflow-hidden p-1 text-foreground [&_[cmdk-group-heading]]:px-2 [&_[cmdk-group-heading]]:py-1.5 [&_[cmdk-group-heading]]:text-xs [&_[cmdk-group-heading]]:font-medium [&_[cmdk-group-heading]]:text-muted-foreground',
+      className,
+    )}
+    {...props}
+  />
+))
+
+CommandGroup.displayName = CommandPrimitive.Group.displayName
+
+const CommandSeparator = React.forwardRef<
+  React.ElementRef<typeof CommandPrimitive.Separator>,
+  React.ComponentPropsWithoutRef<typeof CommandPrimitive.Separator>
+>(({ className, ...props }, ref) => (
+  <CommandPrimitive.Separator
+    ref={ref}
+    className={cn('-mx-1 h-px bg-border', className)}
+    {...props}
+  />
+))
+CommandSeparator.displayName = CommandPrimitive.Separator.displayName
+
+const CommandItem = React.forwardRef<
+  React.ElementRef<typeof CommandPrimitive.Item>,
+  React.ComponentPropsWithoutRef<typeof CommandPrimitive.Item>
+>(({ className, ...props }, ref) => (
+  <CommandPrimitive.Item
+    ref={ref}
+    className={cn(
+      "relative flex cursor-default gap-2 select-none items-center rounded-sm px-2 py-1.5 text-sm outline-none data-[disabled=true]:pointer-events-none data-[selected='true']:bg-accent data-[selected=true]:text-accent-foreground data-[disabled=true]:opacity-50 [&_svg]:pointer-events-none [&_svg]:size-4 [&_svg]:shrink-0",
+      className,
+    )}
+    {...props}
+  />
+))
+
+CommandItem.displayName = CommandPrimitive.Item.displayName
+
+const CommandShortcut = ({
+  className,
+  ...props
+}: React.HTMLAttributes<HTMLSpanElement>) => {
+  return (
+    <span
+      className={cn(
+        'ml-auto text-xs tracking-widest text-muted-foreground',
+        className,
+      )}
+      {...props}
+    />
+  )
+}
+CommandShortcut.displayName = 'CommandShortcut'
+
+export {
+  Command,
+  CommandDialog,
+  CommandInput,
+  CommandList,
+  CommandEmpty,
+  CommandGroup,
+  CommandItem,
+  CommandShortcut,
+  CommandSeparator,
+}
diff --git a/components/ui/context-menu.tsx b/components/ui/context-menu.tsx
new file mode 100644
index 0000000..e892f38
--- /dev/null
+++ b/components/ui/context-menu.tsx
@@ -0,0 +1,200 @@
+'use client'
+
+import * as React from 'react'
+import * as ContextMenuPrimitive from '@radix-ui/react-context-menu'
+import { Check, ChevronRight, Circle } from 'lucide-react'
+
+import { cn } from '@/lib/utils'
+
+const ContextMenu = ContextMenuPrimitive.Root
+
+const ContextMenuTrigger = ContextMenuPrimitive.Trigger
+
+const ContextMenuGroup = ContextMenuPrimitive.Group
+
+const ContextMenuPortal = ContextMenuPrimitive.Portal
+
+const ContextMenuSub = ContextMenuPrimitive.Sub
+
+const ContextMenuRadioGroup = ContextMenuPrimitive.RadioGroup
+
+const ContextMenuSubTrigger = React.forwardRef<
+  React.ElementRef<typeof ContextMenuPrimitive.SubTrigger>,
+  React.ComponentPropsWithoutRef<typeof ContextMenuPrimitive.SubTrigger> & {
+    inset?: boolean
+  }
+>(({ className, inset, children, ...props }, ref) => (
+  <ContextMenuPrimitive.SubTrigger
+    ref={ref}
+    className={cn(
+      'flex cursor-default select-none items-center rounded-sm px-2 py-1.5 text-sm outline-none focus:bg-accent focus:text-accent-foreground data-[state=open]:bg-accent data-[state=open]:text-accent-foreground',
+      inset && 'pl-8',
+      className,
+    )}
+    {...props}
+  >
+    {children}
+    <ChevronRight className="ml-auto h-4 w-4" />
+  </ContextMenuPrimitive.SubTrigger>
+))
+ContextMenuSubTrigger.displayName = ContextMenuPrimitive.SubTrigger.displayName
+
+const ContextMenuSubContent = React.forwardRef<
+  React.ElementRef<typeof ContextMenuPrimitive.SubContent>,
+  React.ComponentPropsWithoutRef<typeof ContextMenuPrimitive.SubContent>
+>(({ className, ...props }, ref) => (
+  <ContextMenuPrimitive.SubContent
+    ref={ref}
+    className={cn(
+      'z-50 min-w-[8rem] overflow-hidden rounded-md border bg-popover p-1 text-popover-foreground shadow-md data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2',
+      className,
+    )}
+    {...props}
+  />
+))
+ContextMenuSubContent.displayName = ContextMenuPrimitive.SubContent.displayName
+
+const ContextMenuContent = React.forwardRef<
+  React.ElementRef<typeof ContextMenuPrimitive.Content>,
+  React.ComponentPropsWithoutRef<typeof ContextMenuPrimitive.Content>
+>(({ className, ...props }, ref) => (
+  <ContextMenuPrimitive.Portal>
+    <ContextMenuPrimitive.Content
+      ref={ref}
+      className={cn(
+        'z-50 min-w-[8rem] overflow-hidden rounded-md border bg-popover p-1 text-popover-foreground shadow-md animate-in fade-in-80 data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2',
+        className,
+      )}
+      {...props}
+    />
+  </ContextMenuPrimitive.Portal>
+))
+ContextMenuContent.displayName = ContextMenuPrimitive.Content.displayName
+
+const ContextMenuItem = React.forwardRef<
+  React.ElementRef<typeof ContextMenuPrimitive.Item>,
+  React.ComponentPropsWithoutRef<typeof ContextMenuPrimitive.Item> & {
+    inset?: boolean
+  }
+>(({ className, inset, ...props }, ref) => (
+  <ContextMenuPrimitive.Item
+    ref={ref}
+    className={cn(
+      'relative flex cursor-default select-none items-center rounded-sm px-2 py-1.5 text-sm outline-none focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50',
+      inset && 'pl-8',
+      className,
+    )}
+    {...props}
+  />
+))
+ContextMenuItem.displayName = ContextMenuPrimitive.Item.displayName
+
+const ContextMenuCheckboxItem = React.forwardRef<
+  React.ElementRef<typeof ContextMenuPrimitive.CheckboxItem>,
+  React.ComponentPropsWithoutRef<typeof ContextMenuPrimitive.CheckboxItem>
+>(({ className, children, checked, ...props }, ref) => (
+  <ContextMenuPrimitive.CheckboxItem
+    ref={ref}
+    className={cn(
+      'relative flex cursor-default select-none items-center rounded-sm py-1.5 pl-8 pr-2 text-sm outline-none focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50',
+      className,
+    )}
+    checked={checked}
+    {...props}
+  >
+    <span className="absolute left-2 flex h-3.5 w-3.5 items-center justify-center">
+      <ContextMenuPrimitive.ItemIndicator>
+        <Check className="h-4 w-4" />
+      </ContextMenuPrimitive.ItemIndicator>
+    </span>
+    {children}
+  </ContextMenuPrimitive.CheckboxItem>
+))
+ContextMenuCheckboxItem.displayName =
+  ContextMenuPrimitive.CheckboxItem.displayName
+
+const ContextMenuRadioItem = React.forwardRef<
+  React.ElementRef<typeof ContextMenuPrimitive.RadioItem>,
+  React.ComponentPropsWithoutRef<typeof ContextMenuPrimitive.RadioItem>
+>(({ className, children, ...props }, ref) => (
+  <ContextMenuPrimitive.RadioItem
+    ref={ref}
+    className={cn(
+      'relative flex cursor-default select-none items-center rounded-sm py-1.5 pl-8 pr-2 text-sm outline-none focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50',
+      className,
+    )}
+    {...props}
+  >
+    <span className="absolute left-2 flex h-3.5 w-3.5 items-center justify-center">
+      <ContextMenuPrimitive.ItemIndicator>
+        <Circle className="h-2 w-2 fill-current" />
+      </ContextMenuPrimitive.ItemIndicator>
+    </span>
+    {children}
+  </ContextMenuPrimitive.RadioItem>
+))
+ContextMenuRadioItem.displayName = ContextMenuPrimitive.RadioItem.displayName
+
+const ContextMenuLabel = React.forwardRef<
+  React.ElementRef<typeof ContextMenuPrimitive.Label>,
+  React.ComponentPropsWithoutRef<typeof ContextMenuPrimitive.Label> & {
+    inset?: boolean
+  }
+>(({ className, inset, ...props }, ref) => (
+  <ContextMenuPrimitive.Label
+    ref={ref}
+    className={cn(
+      'px-2 py-1.5 text-sm font-semibold text-foreground',
+      inset && 'pl-8',
+      className,
+    )}
+    {...props}
+  />
+))
+ContextMenuLabel.displayName = ContextMenuPrimitive.Label.displayName
+
+const ContextMenuSeparator = React.forwardRef<
+  React.ElementRef<typeof ContextMenuPrimitive.Separator>,
+  React.ComponentPropsWithoutRef<typeof ContextMenuPrimitive.Separator>
+>(({ className, ...props }, ref) => (
+  <ContextMenuPrimitive.Separator
+    ref={ref}
+    className={cn('-mx-1 my-1 h-px bg-border', className)}
+    {...props}
+  />
+))
+ContextMenuSeparator.displayName = ContextMenuPrimitive.Separator.displayName
+
+const ContextMenuShortcut = ({
+  className,
+  ...props
+}: React.HTMLAttributes<HTMLSpanElement>) => {
+  return (
+    <span
+      className={cn(
+        'ml-auto text-xs tracking-widest text-muted-foreground',
+        className,
+      )}
+      {...props}
+    />
+  )
+}
+ContextMenuShortcut.displayName = 'ContextMenuShortcut'
+
+export {
+  ContextMenu,
+  ContextMenuTrigger,
+  ContextMenuContent,
+  ContextMenuItem,
+  ContextMenuCheckboxItem,
+  ContextMenuRadioItem,
+  ContextMenuLabel,
+  ContextMenuSeparator,
+  ContextMenuShortcut,
+  ContextMenuGroup,
+  ContextMenuPortal,
+  ContextMenuSub,
+  ContextMenuSubContent,
+  ContextMenuSubTrigger,
+  ContextMenuRadioGroup,
+}
diff --git a/components/ui/dialog.tsx b/components/ui/dialog.tsx
new file mode 100644
index 0000000..dc6bce6
--- /dev/null
+++ b/components/ui/dialog.tsx
@@ -0,0 +1,122 @@
+'use client'
+
+import * as React from 'react'
+import * as DialogPrimitive from '@radix-ui/react-dialog'
+import { X } from 'lucide-react'
+
+import { cn } from '@/lib/utils'
+
+const Dialog = DialogPrimitive.Root
+
+const DialogTrigger = DialogPrimitive.Trigger
+
+const DialogPortal = DialogPrimitive.Portal
+
+const DialogClose = DialogPrimitive.Close
+
+const DialogOverlay = React.forwardRef<
+  React.ElementRef<typeof DialogPrimitive.Overlay>,
+  React.ComponentPropsWithoutRef<typeof DialogPrimitive.Overlay>
+>(({ className, ...props }, ref) => (
+  <DialogPrimitive.Overlay
+    ref={ref}
+    className={cn(
+      'fixed inset-0 z-50 bg-black/80  data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0',
+      className,
+    )}
+    {...props}
+  />
+))
+DialogOverlay.displayName = DialogPrimitive.Overlay.displayName
+
+const DialogContent = React.forwardRef<
+  React.ElementRef<typeof DialogPrimitive.Content>,
+  React.ComponentPropsWithoutRef<typeof DialogPrimitive.Content>
+>(({ className, children, ...props }, ref) => (
+  <DialogPortal>
+    <DialogOverlay />
+    <DialogPrimitive.Content
+      ref={ref}
+      className={cn(
+        'fixed left-[50%] top-[50%] z-50 grid w-full max-w-lg translate-x-[-50%] translate-y-[-50%] gap-4 border bg-background p-6 shadow-lg duration-200 data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[state=closed]:slide-out-to-left-1/2 data-[state=closed]:slide-out-to-top-[48%] data-[state=open]:slide-in-from-left-1/2 data-[state=open]:slide-in-from-top-[48%] sm:rounded-lg',
+        className,
+      )}
+      {...props}
+    >
+      {children}
+      <DialogPrimitive.Close className="absolute right-4 top-4 rounded-sm opacity-70 ring-offset-background transition-opacity hover:opacity-100 focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2 disabled:pointer-events-none data-[state=open]:bg-accent data-[state=open]:text-muted-foreground">
+        <X className="h-4 w-4" />
+        <span className="sr-only">Close</span>
+      </DialogPrimitive.Close>
+    </DialogPrimitive.Content>
+  </DialogPortal>
+))
+DialogContent.displayName = DialogPrimitive.Content.displayName
+
+const DialogHeader = ({
+  className,
+  ...props
+}: React.HTMLAttributes<HTMLDivElement>) => (
+  <div
+    className={cn(
+      'flex flex-col space-y-1.5 text-center sm:text-left',
+      className,
+    )}
+    {...props}
+  />
+)
+DialogHeader.displayName = 'DialogHeader'
+
+const DialogFooter = ({
+  className,
+  ...props
+}: React.HTMLAttributes<HTMLDivElement>) => (
+  <div
+    className={cn(
+      'flex flex-col-reverse sm:flex-row sm:justify-end sm:space-x-2',
+      className,
+    )}
+    {...props}
+  />
+)
+DialogFooter.displayName = 'DialogFooter'
+
+const DialogTitle = React.forwardRef<
+  React.ElementRef<typeof DialogPrimitive.Title>,
+  React.ComponentPropsWithoutRef<typeof DialogPrimitive.Title>
+>(({ className, ...props }, ref) => (
+  <DialogPrimitive.Title
+    ref={ref}
+    className={cn(
+      'text-lg font-semibold leading-none tracking-tight',
+      className,
+    )}
+    {...props}
+  />
+))
+DialogTitle.displayName = DialogPrimitive.Title.displayName
+
+const DialogDescription = React.forwardRef<
+  React.ElementRef<typeof DialogPrimitive.Description>,
+  React.ComponentPropsWithoutRef<typeof DialogPrimitive.Description>
+>(({ className, ...props }, ref) => (
+  <DialogPrimitive.Description
+    ref={ref}
+    className={cn('text-sm text-muted-foreground', className)}
+    {...props}
+  />
+))
+DialogDescription.displayName = DialogPrimitive.Description.displayName
+
+export {
+  Dialog,
+  DialogPortal,
+  DialogOverlay,
+  DialogClose,
+  DialogTrigger,
+  DialogContent,
+  DialogHeader,
+  DialogFooter,
+  DialogTitle,
+  DialogDescription,
+}
diff --git a/components/ui/drawer.tsx b/components/ui/drawer.tsx
new file mode 100644
index 0000000..6e7c2d9
--- /dev/null
+++ b/components/ui/drawer.tsx
@@ -0,0 +1,118 @@
+'use client'
+
+import * as React from 'react'
+import { Drawer as DrawerPrimitive } from 'vaul'
+
+import { cn } from '@/lib/utils'
+
+const Drawer = ({
+  shouldScaleBackground = true,
+  ...props
+}: React.ComponentProps<typeof DrawerPrimitive.Root>) => (
+  <DrawerPrimitive.Root
+    shouldScaleBackground={shouldScaleBackground}
+    {...props}
+  />
+)
+Drawer.displayName = 'Drawer'
+
+const DrawerTrigger = DrawerPrimitive.Trigger
+
+const DrawerPortal = DrawerPrimitive.Portal
+
+const DrawerClose = DrawerPrimitive.Close
+
+const DrawerOverlay = React.forwardRef<
+  React.ElementRef<typeof DrawerPrimitive.Overlay>,
+  React.ComponentPropsWithoutRef<typeof DrawerPrimitive.Overlay>
+>(({ className, ...props }, ref) => (
+  <DrawerPrimitive.Overlay
+    ref={ref}
+    className={cn('fixed inset-0 z-50 bg-black/80', className)}
+    {...props}
+  />
+))
+DrawerOverlay.displayName = DrawerPrimitive.Overlay.displayName
+
+const DrawerContent = React.forwardRef<
+  React.ElementRef<typeof DrawerPrimitive.Content>,
+  React.ComponentPropsWithoutRef<typeof DrawerPrimitive.Content>
+>(({ className, children, ...props }, ref) => (
+  <DrawerPortal>
+    <DrawerOverlay />
+    <DrawerPrimitive.Content
+      ref={ref}
+      className={cn(
+        'fixed inset-x-0 bottom-0 z-50 mt-24 flex h-auto flex-col rounded-t-[10px] border bg-background',
+        className,
+      )}
+      {...props}
+    >
+      <div className="mx-auto mt-4 h-2 w-[100px] rounded-full bg-muted" />
+      {children}
+    </DrawerPrimitive.Content>
+  </DrawerPortal>
+))
+DrawerContent.displayName = 'DrawerContent'
+
+const DrawerHeader = ({
+  className,
+  ...props
+}: React.HTMLAttributes<HTMLDivElement>) => (
+  <div
+    className={cn('grid gap-1.5 p-4 text-center sm:text-left', className)}
+    {...props}
+  />
+)
+DrawerHeader.displayName = 'DrawerHeader'
+
+const DrawerFooter = ({
+  className,
+  ...props
+}: React.HTMLAttributes<HTMLDivElement>) => (
+  <div
+    className={cn('mt-auto flex flex-col gap-2 p-4', className)}
+    {...props}
+  />
+)
+DrawerFooter.displayName = 'DrawerFooter'
+
+const DrawerTitle = React.forwardRef<
+  React.ElementRef<typeof DrawerPrimitive.Title>,
+  React.ComponentPropsWithoutRef<typeof DrawerPrimitive.Title>
+>(({ className, ...props }, ref) => (
+  <DrawerPrimitive.Title
+    ref={ref}
+    className={cn(
+      'text-lg font-semibold leading-none tracking-tight',
+      className,
+    )}
+    {...props}
+  />
+))
+DrawerTitle.displayName = DrawerPrimitive.Title.displayName
+
+const DrawerDescription = React.forwardRef<
+  React.ElementRef<typeof DrawerPrimitive.Description>,
+  React.ComponentPropsWithoutRef<typeof DrawerPrimitive.Description>
+>(({ className, ...props }, ref) => (
+  <DrawerPrimitive.Description
+    ref={ref}
+    className={cn('text-sm text-muted-foreground', className)}
+    {...props}
+  />
+))
+DrawerDescription.displayName = DrawerPrimitive.Description.displayName
+
+export {
+  Drawer,
+  DrawerPortal,
+  DrawerOverlay,
+  DrawerTrigger,
+  DrawerClose,
+  DrawerContent,
+  DrawerHeader,
+  DrawerFooter,
+  DrawerTitle,
+  DrawerDescription,
+}
diff --git a/components/ui/dropdown-menu.tsx b/components/ui/dropdown-menu.tsx
new file mode 100644
index 0000000..a9b5997
--- /dev/null
+++ b/components/ui/dropdown-menu.tsx
@@ -0,0 +1,200 @@
+'use client'
+
+import * as React from 'react'
+import * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu'
+import { Check, ChevronRight, Circle } from 'lucide-react'
+
+import { cn } from '@/lib/utils'
+
+const DropdownMenu = DropdownMenuPrimitive.Root
+
+const DropdownMenuTrigger = DropdownMenuPrimitive.Trigger
+
+const DropdownMenuGroup = DropdownMenuPrimitive.Group
+
+const DropdownMenuPortal = DropdownMenuPrimitive.Portal
+
+const DropdownMenuSub = DropdownMenuPrimitive.Sub
+
+const DropdownMenuRadioGroup = DropdownMenuPrimitive.RadioGroup
+
+const DropdownMenuSubTrigger = React.forwardRef<
+  React.ElementRef<typeof DropdownMenuPrimitive.SubTrigger>,
+  React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.SubTrigger> & {
+    inset?: boolean
+  }
+>(({ className, inset, children, ...props }, ref) => (
+  <DropdownMenuPrimitive.SubTrigger
+    ref={ref}
+    className={cn(
+      'flex cursor-default gap-2 select-none items-center rounded-sm px-2 py-1.5 text-sm outline-none focus:bg-accent data-[state=open]:bg-accent [&_svg]:pointer-events-none [&_svg]:size-4 [&_svg]:shrink-0',
+      inset && 'pl-8',
+      className,
+    )}
+    {...props}
+  >
+    {children}
+    <ChevronRight className="ml-auto" />
+  </DropdownMenuPrimitive.SubTrigger>
+))
+DropdownMenuSubTrigger.displayName =
+  DropdownMenuPrimitive.SubTrigger.displayName
+
+const DropdownMenuSubContent = React.forwardRef<
+  React.ElementRef<typeof DropdownMenuPrimitive.SubContent>,
+  React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.SubContent>
+>(({ className, ...props }, ref) => (
+  <DropdownMenuPrimitive.SubContent
+    ref={ref}
+    className={cn(
+      'z-50 min-w-[8rem] overflow-hidden rounded-md border bg-popover p-1 text-popover-foreground shadow-lg data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2',
+      className,
+    )}
+    {...props}
+  />
+))
+DropdownMenuSubContent.displayName =
+  DropdownMenuPrimitive.SubContent.displayName
+
+const DropdownMenuContent = React.forwardRef<
+  React.ElementRef<typeof DropdownMenuPrimitive.Content>,
+  React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Content>
+>(({ className, sideOffset = 4, ...props }, ref) => (
+  <DropdownMenuPrimitive.Portal>
+    <DropdownMenuPrimitive.Content
+      ref={ref}
+      sideOffset={sideOffset}
+      className={cn(
+        'z-50 min-w-[8rem] overflow-hidden rounded-md border bg-popover p-1 text-popover-foreground shadow-md data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2',
+        className,
+      )}
+      {...props}
+    />
+  </DropdownMenuPrimitive.Portal>
+))
+DropdownMenuContent.displayName = DropdownMenuPrimitive.Content.displayName
+
+const DropdownMenuItem = React.forwardRef<
+  React.ElementRef<typeof DropdownMenuPrimitive.Item>,
+  React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Item> & {
+    inset?: boolean
+  }
+>(({ className, inset, ...props }, ref) => (
+  <DropdownMenuPrimitive.Item
+    ref={ref}
+    className={cn(
+      'relative flex cursor-default select-none items-center gap-2 rounded-sm px-2 py-1.5 text-sm outline-none transition-colors focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50 [&_svg]:pointer-events-none [&_svg]:size-4 [&_svg]:shrink-0',
+      inset && 'pl-8',
+      className,
+    )}
+    {...props}
+  />
+))
+DropdownMenuItem.displayName = DropdownMenuPrimitive.Item.displayName
+
+const DropdownMenuCheckboxItem = React.forwardRef<
+  React.ElementRef<typeof DropdownMenuPrimitive.CheckboxItem>,
+  React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.CheckboxItem>
+>(({ className, children, checked, ...props }, ref) => (
+  <DropdownMenuPrimitive.CheckboxItem
+    ref={ref}
+    className={cn(
+      'relative flex cursor-default select-none items-center rounded-sm py-1.5 pl-8 pr-2 text-sm outline-none transition-colors focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50',
+      className,
+    )}
+    checked={checked}
+    {...props}
+  >
+    <span className="absolute left-2 flex h-3.5 w-3.5 items-center justify-center">
+      <DropdownMenuPrimitive.ItemIndicator>
+        <Check className="h-4 w-4" />
+      </DropdownMenuPrimitive.ItemIndicator>
+    </span>
+    {children}
+  </DropdownMenuPrimitive.CheckboxItem>
+))
+DropdownMenuCheckboxItem.displayName =
+  DropdownMenuPrimitive.CheckboxItem.displayName
+
+const DropdownMenuRadioItem = React.forwardRef<
+  React.ElementRef<typeof DropdownMenuPrimitive.RadioItem>,
+  React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.RadioItem>
+>(({ className, children, ...props }, ref) => (
+  <DropdownMenuPrimitive.RadioItem
+    ref={ref}
+    className={cn(
+      'relative flex cursor-default select-none items-center rounded-sm py-1.5 pl-8 pr-2 text-sm outline-none transition-colors focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50',
+      className,
+    )}
+    {...props}
+  >
+    <span className="absolute left-2 flex h-3.5 w-3.5 items-center justify-center">
+      <DropdownMenuPrimitive.ItemIndicator>
+        <Circle className="h-2 w-2 fill-current" />
+      </DropdownMenuPrimitive.ItemIndicator>
+    </span>
+    {children}
+  </DropdownMenuPrimitive.RadioItem>
+))
+DropdownMenuRadioItem.displayName = DropdownMenuPrimitive.RadioItem.displayName
+
+const DropdownMenuLabel = React.forwardRef<
+  React.ElementRef<typeof DropdownMenuPrimitive.Label>,
+  React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Label> & {
+    inset?: boolean
+  }
+>(({ className, inset, ...props }, ref) => (
+  <DropdownMenuPrimitive.Label
+    ref={ref}
+    className={cn(
+      'px-2 py-1.5 text-sm font-semibold',
+      inset && 'pl-8',
+      className,
+    )}
+    {...props}
+  />
+))
+DropdownMenuLabel.displayName = DropdownMenuPrimitive.Label.displayName
+
+const DropdownMenuSeparator = React.forwardRef<
+  React.ElementRef<typeof DropdownMenuPrimitive.Separator>,
+  React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Separator>
+>(({ className, ...props }, ref) => (
+  <DropdownMenuPrimitive.Separator
+    ref={ref}
+    className={cn('-mx-1 my-1 h-px bg-muted', className)}
+    {...props}
+  />
+))
+DropdownMenuSeparator.displayName = DropdownMenuPrimitive.Separator.displayName
+
+const DropdownMenuShortcut = ({
+  className,
+  ...props
+}: React.HTMLAttributes<HTMLSpanElement>) => {
+  return (
+    <span
+      className={cn('ml-auto text-xs tracking-widest opacity-60', className)}
+      {...props}
+    />
+  )
+}
+DropdownMenuShortcut.displayName = 'DropdownMenuShortcut'
+
+export {
+  DropdownMenu,
+  DropdownMenuTrigger,
+  DropdownMenuContent,
+  DropdownMenuItem,
+  DropdownMenuCheckboxItem,
+  DropdownMenuRadioItem,
+  DropdownMenuLabel,
+  DropdownMenuSeparator,
+  DropdownMenuShortcut,
+  DropdownMenuGroup,
+  DropdownMenuPortal,
+  DropdownMenuSub,
+  DropdownMenuSubContent,
+  DropdownMenuSubTrigger,
+  DropdownMenuRadioGroup,
+}
diff --git a/components/ui/form.tsx b/components/ui/form.tsx
new file mode 100644
index 0000000..ed773f5
--- /dev/null
+++ b/components/ui/form.tsx
@@ -0,0 +1,178 @@
+'use client'
+
+import * as React from 'react'
+import * as LabelPrimitive from '@radix-ui/react-label'
+import { Slot } from '@radix-ui/react-slot'
+import {
+  Controller,
+  ControllerProps,
+  FieldPath,
+  FieldValues,
+  FormProvider,
+  useFormContext,
+} from 'react-hook-form'
+
+import { cn } from '@/lib/utils'
+import { Label } from '@/components/ui/label'
+
+const Form = FormProvider
+
+type FormFieldContextValue<
+  TFieldValues extends FieldValues = FieldValues,
+  TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>,
+> = {
+  name: TName
+}
+
+const FormFieldContext = React.createContext<FormFieldContextValue>(
+  {} as FormFieldContextValue,
+)
+
+const FormField = <
+  TFieldValues extends FieldValues = FieldValues,
+  TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>,
+>({
+  ...props
+}: ControllerProps<TFieldValues, TName>) => {
+  return (
+    <FormFieldContext.Provider value={{ name: props.name }}>
+      <Controller {...props} />
+    </FormFieldContext.Provider>
+  )
+}
+
+const useFormField = () => {
+  const fieldContext = React.useContext(FormFieldContext)
+  const itemContext = React.useContext(FormItemContext)
+  const { getFieldState, formState } = useFormContext()
+
+  const fieldState = getFieldState(fieldContext.name, formState)
+
+  if (!fieldContext) {
+    throw new Error('useFormField should be used within <FormField>')
+  }
+
+  const { id } = itemContext
+
+  return {
+    id,
+    name: fieldContext.name,
+    formItemId: `${id}-form-item`,
+    formDescriptionId: `${id}-form-item-description`,
+    formMessageId: `${id}-form-item-message`,
+    ...fieldState,
+  }
+}
+
+type FormItemContextValue = {
+  id: string
+}
+
+const FormItemContext = React.createContext<FormItemContextValue>(
+  {} as FormItemContextValue,
+)
+
+const FormItem = React.forwardRef<
+  HTMLDivElement,
+  React.HTMLAttributes<HTMLDivElement>
+>(({ className, ...props }, ref) => {
+  const id = React.useId()
+
+  return (
+    <FormItemContext.Provider value={{ id }}>
+      <div ref={ref} className={cn('space-y-2', className)} {...props} />
+    </FormItemContext.Provider>
+  )
+})
+FormItem.displayName = 'FormItem'
+
+const FormLabel = React.forwardRef<
+  React.ElementRef<typeof LabelPrimitive.Root>,
+  React.ComponentPropsWithoutRef<typeof LabelPrimitive.Root>
+>(({ className, ...props }, ref) => {
+  const { error, formItemId } = useFormField()
+
+  return (
+    <Label
+      ref={ref}
+      className={cn(error && 'text-destructive', className)}
+      htmlFor={formItemId}
+      {...props}
+    />
+  )
+})
+FormLabel.displayName = 'FormLabel'
+
+const FormControl = React.forwardRef<
+  React.ElementRef<typeof Slot>,
+  React.ComponentPropsWithoutRef<typeof Slot>
+>(({ ...props }, ref) => {
+  const { error, formItemId, formDescriptionId, formMessageId } = useFormField()
+
+  return (
+    <Slot
+      ref={ref}
+      id={formItemId}
+      aria-describedby={
+        !error
+          ? `${formDescriptionId}`
+          : `${formDescriptionId} ${formMessageId}`
+      }
+      aria-invalid={!!error}
+      {...props}
+    />
+  )
+})
+FormControl.displayName = 'FormControl'
+
+const FormDescription = React.forwardRef<
+  HTMLParagraphElement,
+  React.HTMLAttributes<HTMLParagraphElement>
+>(({ className, ...props }, ref) => {
+  const { formDescriptionId } = useFormField()
+
+  return (
+    <p
+      ref={ref}
+      id={formDescriptionId}
+      className={cn('text-sm text-muted-foreground', className)}
+      {...props}
+    />
+  )
+})
+FormDescription.displayName = 'FormDescription'
+
+const FormMessage = React.forwardRef<
+  HTMLParagraphElement,
+  React.HTMLAttributes<HTMLParagraphElement>
+>(({ className, children, ...props }, ref) => {
+  const { error, formMessageId } = useFormField()
+  const body = error ? String(error?.message) : children
+
+  if (!body) {
+    return null
+  }
+
+  return (
+    <p
+      ref={ref}
+      id={formMessageId}
+      className={cn('text-sm font-medium text-destructive', className)}
+      {...props}
+    >
+      {body}
+    </p>
+  )
+})
+FormMessage.displayName = 'FormMessage'
+
+export {
+  useFormField,
+  Form,
+  FormItem,
+  FormLabel,
+  FormControl,
+  FormDescription,
+  FormMessage,
+  FormField,
+}
diff --git a/components/ui/hover-card.tsx b/components/ui/hover-card.tsx
new file mode 100644
index 0000000..7b9302a
--- /dev/null
+++ b/components/ui/hover-card.tsx
@@ -0,0 +1,29 @@
+'use client'
+
+import * as React from 'react'
+import * as HoverCardPrimitive from '@radix-ui/react-hover-card'
+
+import { cn } from '@/lib/utils'
+
+const HoverCard = HoverCardPrimitive.Root
+
+const HoverCardTrigger = HoverCardPrimitive.Trigger
+
+const HoverCardContent = React.forwardRef<
+  React.ElementRef<typeof HoverCardPrimitive.Content>,
+  React.ComponentPropsWithoutRef<typeof HoverCardPrimitive.Content>
+>(({ className, align = 'center', sideOffset = 4, ...props }, ref) => (
+  <HoverCardPrimitive.Content
+    ref={ref}
+    align={align}
+    sideOffset={sideOffset}
+    className={cn(
+      'z-50 w-64 rounded-md border bg-popover p-4 text-popover-foreground shadow-md outline-none data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2',
+      className,
+    )}
+    {...props}
+  />
+))
+HoverCardContent.displayName = HoverCardPrimitive.Content.displayName
+
+export { HoverCard, HoverCardTrigger, HoverCardContent }
diff --git a/components/ui/input-otp.tsx b/components/ui/input-otp.tsx
new file mode 100644
index 0000000..daaf9f7
--- /dev/null
+++ b/components/ui/input-otp.tsx
@@ -0,0 +1,71 @@
+'use client'
+
+import * as React from 'react'
+import { OTPInput, OTPInputContext } from 'input-otp'
+import { Dot } from 'lucide-react'
+
+import { cn } from '@/lib/utils'
+
+const InputOTP = React.forwardRef<
+  React.ElementRef<typeof OTPInput>,
+  React.ComponentPropsWithoutRef<typeof OTPInput>
+>(({ className, containerClassName, ...props }, ref) => (
+  <OTPInput
+    ref={ref}
+    containerClassName={cn(
+      'flex items-center gap-2 has-[:disabled]:opacity-50',
+      containerClassName,
+    )}
+    className={cn('disabled:cursor-not-allowed', className)}
+    {...props}
+  />
+))
+InputOTP.displayName = 'InputOTP'
+
+const InputOTPGroup = React.forwardRef<
+  React.ElementRef<'div'>,
+  React.ComponentPropsWithoutRef<'div'>
+>(({ className, ...props }, ref) => (
+  <div ref={ref} className={cn('flex items-center', className)} {...props} />
+))
+InputOTPGroup.displayName = 'InputOTPGroup'
+
+const InputOTPSlot = React.forwardRef<
+  React.ElementRef<'div'>,
+  React.ComponentPropsWithoutRef<'div'> & { index: number }
+>(({ index, className, ...props }, ref) => {
+  const inputOTPContext = React.useContext(OTPInputContext)
+  const { char, hasFakeCaret, isActive } = inputOTPContext.slots[index]
+
+  return (
+    <div
+      ref={ref}
+      className={cn(
+        'relative flex h-10 w-10 items-center justify-center border-y border-r border-input text-sm transition-all first:rounded-l-md first:border-l last:rounded-r-md',
+        isActive && 'z-10 ring-2 ring-ring ring-offset-background',
+        className,
+      )}
+      {...props}
+    >
+      {char}
+      {hasFakeCaret && (
+        <div className="pointer-events-none absolute inset-0 flex items-center justify-center">
+          <div className="h-4 w-px animate-caret-blink bg-foreground duration-1000" />
+        </div>
+      )}
+    </div>
+  )
+})
+InputOTPSlot.displayName = 'InputOTPSlot'
+
+const InputOTPSeparator = React.forwardRef<
+  React.ElementRef<'div'>,
+  React.ComponentPropsWithoutRef<'div'>
+>(({ ...props }, ref) => (
+  <div ref={ref} role="separator" {...props}>
+    <Dot />
+  </div>
+))
+InputOTPSeparator.displayName = 'InputOTPSeparator'
+
+export { InputOTP, InputOTPGroup, InputOTPSlot, InputOTPSeparator }
diff --git a/components/ui/input.tsx b/components/ui/input.tsx
new file mode 100644
index 0000000..b508d5a
--- /dev/null
+++ b/components/ui/input.tsx
@@ -0,0 +1,22 @@
+import * as React from 'react'
+
+import { cn } from '@/lib/utils'
+
+const Input = React.forwardRef<HTMLInputElement, React.ComponentProps<'input'>>(
+  ({ className, type, ...props }, ref) => {
+    return (
+      <input
+        type={type}
+        className={cn(
+          'flex h-10 w-full rounded-md border border-input bg-background px-3 py-2 text-base ring-offset-background file:border-0 file:bg-transparent file:text-sm file:font-medium file:text-foreground placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50 md:text-sm',
+          className,
+        )}
+        ref={ref}
+        {...props}
+      />
+    )
+  },
+)
+Input.displayName = 'Input'
+
+export { Input }
diff --git a/components/ui/label.tsx b/components/ui/label.tsx
new file mode 100644
index 0000000..fb5c545
--- /dev/null
+++ b/components/ui/label.tsx
@@ -0,0 +1,26 @@
+'use client'
+
+import * as React from 'react'
+import * as LabelPrimitive from '@radix-ui/react-label'
+import { cva, type VariantProps } from 'class-variance-authority'
+
+import { cn } from '@/lib/utils'
+
+const labelVariants = cva(
+  'text-sm font-medium leading-none peer-disabled:cursor-not-allowed peer-disabled:opacity-70',
+)
+
+const Label = React.forwardRef<
+  React.ElementRef<typeof LabelPrimitive.Root>,
+  React.ComponentPropsWithoutRef<typeof LabelPrimitive.Root> &
+    VariantProps<typeof labelVariants>
+>(({ className, ...props }, ref) => (
+  <LabelPrimitive.Root
+    ref={ref}
+    className={cn(labelVariants(), className)}
+    {...props}
+  />
+))
+Label.displayName = LabelPrimitive.Root.displayName
+
+export { Label }
diff --git a/components/ui/menubar.tsx b/components/ui/menubar.tsx
new file mode 100644
index 0000000..93a11c1
--- /dev/null
+++ b/components/ui/menubar.tsx
@@ -0,0 +1,236 @@
+'use client'
+
+import * as React from 'react'
+import * as MenubarPrimitive from '@radix-ui/react-menubar'
+import { Check, ChevronRight, Circle } from 'lucide-react'
+
+import { cn } from '@/lib/utils'
+
+const MenubarMenu = MenubarPrimitive.Menu
+
+const MenubarGroup = MenubarPrimitive.Group
+
+const MenubarPortal = MenubarPrimitive.Portal
+
+const MenubarSub = MenubarPrimitive.Sub
+
+const MenubarRadioGroup = MenubarPrimitive.RadioGroup
+
+const Menubar = React.forwardRef<
+  React.ElementRef<typeof MenubarPrimitive.Root>,
+  React.ComponentPropsWithoutRef<typeof MenubarPrimitive.Root>
+>(({ className, ...props }, ref) => (
+  <MenubarPrimitive.Root
+    ref={ref}
+    className={cn(
+      'flex h-10 items-center space-x-1 rounded-md border bg-background p-1',
+      className,
+    )}
+    {...props}
+  />
+))
+Menubar.displayName = MenubarPrimitive.Root.displayName
+
+const MenubarTrigger = React.forwardRef<
+  React.ElementRef<typeof MenubarPrimitive.Trigger>,
+  React.ComponentPropsWithoutRef<typeof MenubarPrimitive.Trigger>
+>(({ className, ...props }, ref) => (
+  <MenubarPrimitive.Trigger
+    ref={ref}
+    className={cn(
+      'flex cursor-default select-none items-center rounded-sm px-3 py-1.5 text-sm font-medium outline-none focus:bg-accent focus:text-accent-foreground data-[state=open]:bg-accent data-[state=open]:text-accent-foreground',
+      className,
+    )}
+    {...props}
+  />
+))
+MenubarTrigger.displayName = MenubarPrimitive.Trigger.displayName
+
+const MenubarSubTrigger = React.forwardRef<
+  React.ElementRef<typeof MenubarPrimitive.SubTrigger>,
+  React.ComponentPropsWithoutRef<typeof MenubarPrimitive.SubTrigger> & {
+    inset?: boolean
+  }
+>(({ className, inset, children, ...props }, ref) => (
+  <MenubarPrimitive.SubTrigger
+    ref={ref}
+    className={cn(
+      'flex cursor-default select-none items-center rounded-sm px-2 py-1.5 text-sm outline-none focus:bg-accent focus:text-accent-foreground data-[state=open]:bg-accent data-[state=open]:text-accent-foreground',
+      inset && 'pl-8',
+      className,
+    )}
+    {...props}
+  >
+    {children}
+    <ChevronRight className="ml-auto h-4 w-4" />
+  </MenubarPrimitive.SubTrigger>
+))
+MenubarSubTrigger.displayName = MenubarPrimitive.SubTrigger.displayName
+
+const MenubarSubContent = React.forwardRef<
+  React.ElementRef<typeof MenubarPrimitive.SubContent>,
+  React.ComponentPropsWithoutRef<typeof MenubarPrimitive.SubContent>
+>(({ className, ...props }, ref) => (
+  <MenubarPrimitive.SubContent
+    ref={ref}
+    className={cn(
+      'z-50 min-w-[8rem] overflow-hidden rounded-md border bg-popover p-1 text-popover-foreground data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2',
+      className,
+    )}
+    {...props}
+  />
+))
+MenubarSubContent.displayName = MenubarPrimitive.SubContent.displayName
+
+const MenubarContent = React.forwardRef<
+  React.ElementRef<typeof MenubarPrimitive.Content>,
+  React.ComponentPropsWithoutRef<typeof MenubarPrimitive.Content>
+>(
+  (
+    { className, align = 'start', alignOffset = -4, sideOffset = 8, ...props },
+    ref,
+  ) => (
+    <MenubarPrimitive.Portal>
+      <MenubarPrimitive.Content
+        ref={ref}
+        align={align}
+        alignOffset={alignOffset}
+        sideOffset={sideOffset}
+        className={cn(
+          'z-50 min-w-[12rem] overflow-hidden rounded-md border bg-popover p-1 text-popover-foreground shadow-md data-[state=open]:animate-in data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2',
+          className,
+        )}
+        {...props}
+      />
+    </MenubarPrimitive.Portal>
+  ),
+)
+MenubarContent.displayName = MenubarPrimitive.Content.displayName
+
+const MenubarItem = React.forwardRef<
+  React.ElementRef<typeof MenubarPrimitive.Item>,
+  React.ComponentPropsWithoutRef<typeof MenubarPrimitive.Item> & {
+    inset?: boolean
+  }
+>(({ className, inset, ...props }, ref) => (
+  <MenubarPrimitive.Item
+    ref={ref}
+    className={cn(
+      'relative flex cursor-default select-none items-center rounded-sm px-2 py-1.5 text-sm outline-none focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50',
+      inset && 'pl-8',
+      className,
+    )}
+    {...props}
+  />
+))
+MenubarItem.displayName = MenubarPrimitive.Item.displayName
+
+const MenubarCheckboxItem = React.forwardRef<
+  React.ElementRef<typeof MenubarPrimitive.CheckboxItem>,
+  React.ComponentPropsWithoutRef<typeof MenubarPrimitive.CheckboxItem>
+>(({ className, children, checked, ...props }, ref) => (
+  <MenubarPrimitive.CheckboxItem
+    ref={ref}
+    className={cn(
+      'relative flex cursor-default select-none items-center rounded-sm py-1.5 pl-8 pr-2 text-sm outline-none focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50',
+      className,
+    )}
+    checked={checked}
+    {...props}
+  >
+    <span className="absolute left-2 flex h-3.5 w-3.5 items-center justify-center">
+      <MenubarPrimitive.ItemIndicator>
+        <Check className="h-4 w-4" />
+      </MenubarPrimitive.ItemIndicator>
+    </span>
+    {children}
+  </MenubarPrimitive.CheckboxItem>
+))
+MenubarCheckboxItem.displayName = MenubarPrimitive.CheckboxItem.displayName
+
+const MenubarRadioItem = React.forwardRef<
+  React.ElementRef<typeof MenubarPrimitive.RadioItem>,
+  React.ComponentPropsWithoutRef<typeof MenubarPrimitive.RadioItem>
+>(({ className, children, ...props }, ref) => (
+  <MenubarPrimitive.RadioItem
+    ref={ref}
+    className={cn(
+      'relative flex cursor-default select-none items-center rounded-sm py-1.5 pl-8 pr-2 text-sm outline-none focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50',
+      className,
+    )}
+    {...props}
+  >
+    <span className="absolute left-2 flex h-3.5 w-3.5 items-center justify-center">
+      <MenubarPrimitive.ItemIndicator>
+        <Circle className="h-2 w-2 fill-current" />
+      </MenubarPrimitive.ItemIndicator>
+    </span>
+    {children}
+  </MenubarPrimitive.RadioItem>
+))
+MenubarRadioItem.displayName = MenubarPrimitive.RadioItem.displayName
+
+const MenubarLabel = React.forwardRef<
+  React.ElementRef<typeof MenubarPrimitive.Label>,
+  React.ComponentPropsWithoutRef<typeof MenubarPrimitive.Label> & {
+    inset?: boolean
+  }
+>(({ className, inset, ...props }, ref) => (
+  <MenubarPrimitive.Label
+    ref={ref}
+    className={cn(
+      'px-2 py-1.5 text-sm font-semibold',
+      inset && 'pl-8',
+      className,
+    )}
+    {...props}
+  />
+))
+MenubarLabel.displayName = MenubarPrimitive.Label.displayName
+
+const MenubarSeparator = React.forwardRef<
+  React.ElementRef<typeof MenubarPrimitive.Separator>,
+  React.ComponentPropsWithoutRef<typeof MenubarPrimitive.Separator>
+>(({ className, ...props }, ref) => (
+  <MenubarPrimitive.Separator
+    ref={ref}
+    className={cn('-mx-1 my-1 h-px bg-muted', className)}
+    {...props}
+  />
+))
+MenubarSeparator.displayName = MenubarPrimitive.Separator.displayName
+
+const MenubarShortcut = ({
+  className,
+  ...props
+}: React.HTMLAttributes<HTMLSpanElement>) => {
+  return (
+    <span
+      className={cn(
+        'ml-auto text-xs tracking-widest text-muted-foreground',
+        className,
+      )}
+      {...props}
+    />
+  )
+}
+MenubarShortcut.displayname = 'MenubarShortcut'
+
+export {
+  Menubar,
+  MenubarMenu,
+  MenubarTrigger,
+  MenubarContent,
+  MenubarItem,
+  MenubarSeparator,
+  MenubarLabel,
+  MenubarCheckboxItem,
+  MenubarRadioGroup,
+  MenubarRadioItem,
+  MenubarPortal,
+  MenubarSubContent,
+  MenubarSubTrigger,
+  MenubarGroup,
+  MenubarSub,
+  MenubarShortcut,
+}
diff --git a/components/ui/navigation-menu.tsx b/components/ui/navigation-menu.tsx
new file mode 100644
index 0000000..38e337c
--- /dev/null
+++ b/components/ui/navigation-menu.tsx
@@ -0,0 +1,128 @@
+import * as React from 'react'
+import * as NavigationMenuPrimitive from '@radix-ui/react-navigation-menu'
+import { cva } from 'class-variance-authority'
+import { ChevronDown } from 'lucide-react'
+
+import { cn } from '@/lib/utils'
+
+const NavigationMenu = React.forwardRef<
+  React.ElementRef<typeof NavigationMenuPrimitive.Root>,
+  React.ComponentPropsWithoutRef<typeof NavigationMenuPrimitive.Root>
+>(({ className, children, ...props }, ref) => (
+  <NavigationMenuPrimitive.Root
+    ref={ref}
+    className={cn(
+      'relative z-10 flex max-w-max flex-1 items-center justify-center',
+      className,
+    )}
+    {...props}
+  >
+    {children}
+    <NavigationMenuViewport />
+  </NavigationMenuPrimitive.Root>
+))
+NavigationMenu.displayName = NavigationMenuPrimitive.Root.displayName
+
+const NavigationMenuList = React.forwardRef<
+  React.ElementRef<typeof NavigationMenuPrimitive.List>,
+  React.ComponentPropsWithoutRef<typeof NavigationMenuPrimitive.List>
+>(({ className, ...props }, ref) => (
+  <NavigationMenuPrimitive.List
+    ref={ref}
+    className={cn(
+      'group flex flex-1 list-none items-center justify-center space-x-1',
+      className,
+    )}
+    {...props}
+  />
+))
+NavigationMenuList.displayName = NavigationMenuPrimitive.List.displayName
+
+const NavigationMenuItem = NavigationMenuPrimitive.Item
+
+const navigationMenuTriggerStyle = cva(
+  'group inline-flex h-10 w-max items-center justify-center rounded-md bg-background px-4 py-2 text-sm font-medium transition-colors hover:bg-accent hover:text-accent-foreground focus:bg-accent focus:text-accent-foreground focus:outline-none disabled:pointer-events-none disabled:opacity-50 data-[active]:bg-accent/50 data-[state=open]:bg-accent/50',
+)
+
+const NavigationMenuTrigger = React.forwardRef<
+  React.ElementRef<typeof NavigationMenuPrimitive.Trigger>,
+  React.ComponentPropsWithoutRef<typeof NavigationMenuPrimitive.Trigger>
+>(({ className, children, ...props }, ref) => (
+  <NavigationMenuPrimitive.Trigger
+    ref={ref}
+    className={cn(navigationMenuTriggerStyle(), 'group', className)}
+    {...props}
+  >
+    {children}{' '}
+    <ChevronDown
+      className="relative top-[1px] ml-1 h-3 w-3 transition duration-200 group-data-[state=open]:rotate-180"
+      aria-hidden="true"
+    />
+  </NavigationMenuPrimitive.Trigger>
+))
+NavigationMenuTrigger.displayName = NavigationMenuPrimitive.Trigger.displayName
+
+const NavigationMenuContent = React.forwardRef<
+  React.ElementRef<typeof NavigationMenuPrimitive.Content>,
+  React.ComponentPropsWithoutRef<typeof NavigationMenuPrimitive.Content>
+>(({ className, ...props }, ref) => (
+  <NavigationMenuPrimitive.Content
+    ref={ref}
+    className={cn(
+      'left-0 top-0 w-full data-[motion^=from-]:animate-in data-[motion^=to-]:animate-out data-[motion^=from-]:fade-in data-[motion^=to-]:fade-out data-[motion=from-end]:slide-in-from-right-52 data-[motion=from-start]:slide-in-from-left-52 data-[motion=to-end]:slide-out-to-right-52 data-[motion=to-start]:slide-out-to-left-52 md:absolute md:w-auto ',
+      className,
+    )}
+    {...props}
+  />
+))
+NavigationMenuContent.displayName = NavigationMenuPrimitive.Content.displayName
+
+const NavigationMenuLink = NavigationMenuPrimitive.Link
+
+const NavigationMenuViewport = React.forwardRef<
+  React.ElementRef<typeof NavigationMenuPrimitive.Viewport>,
+  React.ComponentPropsWithoutRef<typeof NavigationMenuPrimitive.Viewport>
+>(({ className, ...props }, ref) => (
+  <div className={cn('absolute left-0 top-full flex justify-center')}>
+    <NavigationMenuPrimitive.Viewport
+      className={cn(
+        'origin-top-center relative mt-1.5 h-[var(--radix-navigation-menu-viewport-height)] w-full overflow-hidden rounded-md border bg-popover text-popover-foreground shadow-lg data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-90 md:w-[var(--radix-navigation-menu-viewport-width)]',
+        className,
+      )}
+      ref={ref}
+      {...props}
+    />
+  </div>
+))
+NavigationMenuViewport.displayName =
+  NavigationMenuPrimitive.Viewport.displayName
+
+const NavigationMenuIndicator = React.forwardRef<
+  React.ElementRef<typeof NavigationMenuPrimitive.Indicator>,
+  React.ComponentPropsWithoutRef<typeof NavigationMenuPrimitive.Indicator>
+>(({ className, ...props }, ref) => (
+  <NavigationMenuPrimitive.Indicator
+    ref={ref}
+    className={cn(
+      'top-full z-[1] flex h-1.5 items-end justify-center overflow-hidden data-[state=visible]:animate-in data-[state=hidden]:animate-out data-[state=hidden]:fade-out data-[state=visible]:fade-in',
+      className,
+    )}
+    {...props}
+  >
+    <div className="relative top-[60%] h-2 w-2 rotate-45 rounded-tl-sm bg-border shadow-md" />
+  </NavigationMenuPrimitive.Indicator>
+))
+NavigationMenuIndicator.displayName =
+  NavigationMenuPrimitive.Indicator.displayName
+
+export {
+  navigationMenuTriggerStyle,
+  NavigationMenu,
+  NavigationMenuList,
+  NavigationMenuItem,
+  NavigationMenuContent,
+  NavigationMenuTrigger,
+  NavigationMenuLink,
+  NavigationMenuIndicator,
+  NavigationMenuViewport,
+}
diff --git a/components/ui/pagination.tsx b/components/ui/pagination.tsx
new file mode 100644
index 0000000..dedf500
--- /dev/null
+++ b/components/ui/pagination.tsx
@@ -0,0 +1,117 @@
+import * as React from 'react'
+import { ChevronLeft, ChevronRight, MoreHorizontal } from 'lucide-react'
+
+import { cn } from '@/lib/utils'
+import { ButtonProps, buttonVariants } from '@/components/ui/button'
+
+const Pagination = ({ className, ...props }: React.ComponentProps<'nav'>) => (
+  <nav
+    role="navigation"
+    aria-label="pagination"
+    className={cn('mx-auto flex w-full justify-center', className)}
+    {...props}
+  />
+)
+Pagination.displayName = 'Pagination'
+
+const PaginationContent = React.forwardRef<
+  HTMLUListElement,
+  React.ComponentProps<'ul'>
+>(({ className, ...props }, ref) => (
+  <ul
+    ref={ref}
+    className={cn('flex flex-row items-center gap-1', className)}
+    {...props}
+  />
+))
+PaginationContent.displayName = 'PaginationContent'
+
+const PaginationItem = React.forwardRef<
+  HTMLLIElement,
+  React.ComponentProps<'li'>
+>(({ className, ...props }, ref) => (
+  <li ref={ref} className={cn('', className)} {...props} />
+))
+PaginationItem.displayName = 'PaginationItem'
+
+type PaginationLinkProps = {
+  isActive?: boolean
+} & Pick<ButtonProps, 'size'> &
+  React.ComponentProps<'a'>
+
+const PaginationLink = ({
+  className,
+  isActive,
+  size = 'icon',
+  ...props
+}: PaginationLinkProps) => (
+  <a
+    aria-current={isActive ? 'page' : undefined}
+    className={cn(
+      buttonVariants({
+        variant: isActive ? 'outline' : 'ghost',
+        size,
+      }),
+      className,
+    )}
+    {...props}
+  />
+)
+PaginationLink.displayName = 'PaginationLink'
+
+const PaginationPrevious = ({
+  className,
+  ...props
+}: React.ComponentProps<typeof PaginationLink>) => (
+  <PaginationLink
+    aria-label="Go to previous page"
+    size="default"
+    className={cn('gap-1 pl-2.5', className)}
+    {...props}
+  >
+    <ChevronLeft className="h-4 w-4" />
+    <span>Previous</span>
+  </PaginationLink>
+)
+PaginationPrevious.displayName = 'PaginationPrevious'
+
+const PaginationNext = ({
+  className,
+  ...props
+}: React.ComponentProps<typeof PaginationLink>) => (
+  <PaginationLink
+    aria-label="Go to next page"
+    size="default"
+    className={cn('gap-1 pr-2.5', className)}
+    {...props}
+  >
+    <span>Next</span>
+    <ChevronRight className="h-4 w-4" />
+  </PaginationLink>
+)
+PaginationNext.displayName = 'PaginationNext'
+
+const PaginationEllipsis = ({
+  className,
+  ...props
+}: React.ComponentProps<'span'>) => (
+  <span
+    aria-hidden
+    className={cn('flex h-9 w-9 items-center justify-center', className)}
+    {...props}
+  >
+    <MoreHorizontal className="h-4 w-4" />
+    <span className="sr-only">More pages</span>
+  </span>
+)
+PaginationEllipsis.displayName = 'PaginationEllipsis'
+
+export {
+  Pagination,
+  PaginationContent,
+  PaginationEllipsis,
+  PaginationItem,
+  PaginationLink,
+  PaginationNext,
+  PaginationPrevious,
+}
diff --git a/components/ui/popover.tsx b/components/ui/popover.tsx
new file mode 100644
index 0000000..ce5e43f
--- /dev/null
+++ b/components/ui/popover.tsx
@@ -0,0 +1,31 @@
+'use client'
+
+import * as React from 'react'
+import * as PopoverPrimitive from '@radix-ui/react-popover'
+
+import { cn } from '@/lib/utils'
+
+const Popover = PopoverPrimitive.Root
+
+const PopoverTrigger = PopoverPrimitive.Trigger
+
+const PopoverContent = React.forwardRef<
+  React.ElementRef<typeof PopoverPrimitive.Content>,
+  React.ComponentPropsWithoutRef<typeof PopoverPrimitive.Content>
+>(({ className, align = 'center', sideOffset = 4, ...props }, ref) => (
+  <PopoverPrimitive.Portal>
+    <PopoverPrimitive.Content
+      ref={ref}
+      align={align}
+      sideOffset={sideOffset}
+      className={cn(
+        'z-50 w-72 rounded-md border bg-popover p-4 text-popover-foreground shadow-md outline-none data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2',
+        className,
+      )}
+      {...props}
+    />
+  </PopoverPrimitive.Portal>
+))
+PopoverContent.displayName = PopoverPrimitive.Content.displayName
+
+export { Popover, PopoverTrigger, PopoverContent }
diff --git a/components/ui/progress.tsx b/components/ui/progress.tsx
new file mode 100644
index 0000000..0ad7b7a
--- /dev/null
+++ b/components/ui/progress.tsx
@@ -0,0 +1,28 @@
+'use client'
+
+import * as React from 'react'
+import * as ProgressPrimitive from '@radix-ui/react-progress'
+
+import { cn } from '@/lib/utils'
+
+const Progress = React.forwardRef<
+  React.ElementRef<typeof ProgressPrimitive.Root>,
+  React.ComponentPropsWithoutRef<typeof ProgressPrimitive.Root>
+>(({ className, value, ...props }, ref) => (
+  <ProgressPrimitive.Root
+    ref={ref}
+    className={cn(
+      'relative h-4 w-full overflow-hidden rounded-full bg-secondary',
+      className,
+    )}
+    {...props}
+  >
+    <ProgressPrimitive.Indicator
+      className="h-full w-full flex-1 bg-primary transition-all"
+      style={{ transform: `translateX(-${100 - (value || 0)}%)` }}
+    />
+  </ProgressPrimitive.Root>
+))
+Progress.displayName = ProgressPrimitive.Root.displayName
+
+export { Progress }
diff --git a/components/ui/radio-group.tsx b/components/ui/radio-group.tsx
new file mode 100644
index 0000000..5b536e9
--- /dev/null
+++ b/components/ui/radio-group.tsx
@@ -0,0 +1,44 @@
+'use client'
+
+import * as React from 'react'
+import * as RadioGroupPrimitive from '@radix-ui/react-radio-group'
+import { Circle } from 'lucide-react'
+
+import { cn } from '@/lib/utils'
+
+const RadioGroup = React.forwardRef<
+  React.ElementRef<typeof RadioGroupPrimitive.Root>,
+  React.ComponentPropsWithoutRef<typeof RadioGroupPrimitive.Root>
+>(({ className, ...props }, ref) => {
+  return (
+    <RadioGroupPrimitive.Root
+      className={cn('grid gap-2', className)}
+      {...props}
+      ref={ref}
+    />
+  )
+})
+RadioGroup.displayName = RadioGroupPrimitive.Root.displayName
+
+const RadioGroupItem = React.forwardRef<
+  React.ElementRef<typeof RadioGroupPrimitive.Item>,
+  React.ComponentPropsWithoutRef<typeof RadioGroupPrimitive.Item>
+>(({ className, ...props }, ref) => {
+  return (
+    <RadioGroupPrimitive.Item
+      ref={ref}
+      className={cn(
+        'aspect-square h-4 w-4 rounded-full border border-primary text-primary ring-offset-background focus:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50',
+        className,
+      )}
+      {...props}
+    >
+      <RadioGroupPrimitive.Indicator className="flex items-center justify-center">
+        <Circle className="h-2.5 w-2.5 fill-current text-current" />
+      </RadioGroupPrimitive.Indicator>
+    </RadioGroupPrimitive.Item>
+  )
+})
+RadioGroupItem.displayName = RadioGroupPrimitive.Item.displayName
+
+export { RadioGroup, RadioGroupItem }
diff --git a/components/ui/resizable.tsx b/components/ui/resizable.tsx
new file mode 100644
index 0000000..38d8d96
--- /dev/null
+++ b/components/ui/resizable.tsx
@@ -0,0 +1,45 @@
+'use client'
+
+import { GripVertical } from 'lucide-react'
+import * as ResizablePrimitive from 'react-resizable-panels'
+
+import { cn } from '@/lib/utils'
+
+const ResizablePanelGroup = ({
+  className,
+  ...props
+}: React.ComponentProps<typeof ResizablePrimitive.PanelGroup>) => (
+  <ResizablePrimitive.PanelGroup
+    className={cn(
+      'flex h-full w-full data-[panel-group-direction=vertical]:flex-col',
+      className,
+    )}
+    {...props}
+  />
+)
+
+const ResizablePanel = ResizablePrimitive.Panel
+
+const ResizableHandle = ({
+  withHandle,
+  className,
+  ...props
+}: React.ComponentProps<typeof ResizablePrimitive.PanelResizeHandle> & {
+  withHandle?: boolean
+}) => (
+  <ResizablePrimitive.PanelResizeHandle
+    className={cn(
+      'relative flex w-px items-center justify-center bg-border after:absolute after:inset-y-0 after:left-1/2 after:w-1 after:-translate-x-1/2 focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring focus-visible:ring-offset-1 data-[panel-group-direction=vertical]:h-px data-[panel-group-direction=vertical]:w-full data-[panel-group-direction=vertical]:after:left-0 data-[panel-group-direction=vertical]:after:h-1 data-[panel-group-direction=vertical]:after:w-full data-[panel-group-direction=vertical]:after:-translate-y-1/2 data-[panel-group-direction=vertical]:after:translate-x-0 [&[data-panel-group-direction=vertical]>div]:rotate-90',
+      className,
+    )}
+    {...props}
+  >
+    {withHandle && (
+      <div className="z-10 flex h-4 w-3 items-center justify-center rounded-sm border bg-border">
+        <GripVertical className="h-2.5 w-2.5" />
+      </div>
+    )}
+  </ResizablePrimitive.PanelResizeHandle>
+)
+
+export { ResizablePanelGroup, ResizablePanel, ResizableHandle }
diff --git a/components/ui/scroll-area.tsx b/components/ui/scroll-area.tsx
new file mode 100644
index 0000000..69f1f4e
--- /dev/null
+++ b/components/ui/scroll-area.tsx
@@ -0,0 +1,48 @@
+'use client'
+
+import * as React from 'react'
+import * as ScrollAreaPrimitive from '@radix-ui/react-scroll-area'
+
+import { cn } from '@/lib/utils'
+
+const ScrollArea = React.forwardRef<
+  React.ElementRef<typeof ScrollAreaPrimitive.Root>,
+  React.ComponentPropsWithoutRef<typeof ScrollAreaPrimitive.Root>
+>(({ className, children, ...props }, ref) => (
+  <ScrollAreaPrimitive.Root
+    ref={ref}
+    className={cn('relative overflow-hidden', className)}
+    {...props}
+  >
+    <ScrollAreaPrimitive.Viewport className="h-full w-full rounded-[inherit]">
+      {children}
+    </ScrollAreaPrimitive.Viewport>
+    <ScrollBar />
+    <ScrollAreaPrimitive.Corner />
+  </ScrollAreaPrimitive.Root>
+))
+ScrollArea.displayName = ScrollAreaPrimitive.Root.displayName
+
+const ScrollBar = React.forwardRef<
+  React.ElementRef<typeof ScrollAreaPrimitive.ScrollAreaScrollbar>,
+  React.ComponentPropsWithoutRef<typeof ScrollAreaPrimitive.ScrollAreaScrollbar>
+>(({ className, orientation = 'vertical', ...props }, ref) => (
+  <ScrollAreaPrimitive.ScrollAreaScrollbar
+    ref={ref}
+    orientation={orientation}
+    className={cn(
+      'flex touch-none select-none transition-colors',
+      orientation === 'vertical' &&
+        'h-full w-2.5 border-l border-l-transparent p-[1px]',
+      orientation === 'horizontal' &&
+        'h-2.5 flex-col border-t border-t-transparent p-[1px]',
+      className,
+    )}
+    {...props}
+  >
+    <ScrollAreaPrimitive.ScrollAreaThumb className="relative flex-1 rounded-full bg-border" />
+  </ScrollAreaPrimitive.ScrollAreaScrollbar>
+))
+ScrollBar.displayName = ScrollAreaPrimitive.ScrollAreaScrollbar.displayName
+
+export { ScrollArea, ScrollBar }
diff --git a/components/ui/select.tsx b/components/ui/select.tsx
new file mode 100644
index 0000000..266754e
--- /dev/null
+++ b/components/ui/select.tsx
@@ -0,0 +1,160 @@
+'use client'
+
+import * as React from 'react'
+import * as SelectPrimitive from '@radix-ui/react-select'
+import { Check, ChevronDown, ChevronUp } from 'lucide-react'
+
+import { cn } from '@/lib/utils'
+
+const Select = SelectPrimitive.Root
+
+const SelectGroup = SelectPrimitive.Group
+
+const SelectValue = SelectPrimitive.Value
+
+const SelectTrigger = React.forwardRef<
+  React.ElementRef<typeof SelectPrimitive.Trigger>,
+  React.ComponentPropsWithoutRef<typeof SelectPrimitive.Trigger>
+>(({ className, children, ...props }, ref) => (
+  <SelectPrimitive.Trigger
+    ref={ref}
+    className={cn(
+      'flex h-10 w-full items-center justify-between rounded-md border border-input bg-background px-3 py-2 text-sm ring-offset-background placeholder:text-muted-foreground focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50 [&>span]:line-clamp-1',
+      className,
+    )}
+    {...props}
+  >
+    {children}
+    <SelectPrimitive.Icon asChild>
+      <ChevronDown className="h-4 w-4 opacity-50" />
+    </SelectPrimitive.Icon>
+  </SelectPrimitive.Trigger>
+))
+SelectTrigger.displayName = SelectPrimitive.Trigger.displayName
+
+const SelectScrollUpButton = React.forwardRef<
+  React.ElementRef<typeof SelectPrimitive.ScrollUpButton>,
+  React.ComponentPropsWithoutRef<typeof SelectPrimitive.ScrollUpButton>
+>(({ className, ...props }, ref) => (
+  <SelectPrimitive.ScrollUpButton
+    ref={ref}
+    className={cn(
+      'flex cursor-default items-center justify-center py-1',
+      className,
+    )}
+    {...props}
+  >
+    <ChevronUp className="h-4 w-4" />
+  </SelectPrimitive.ScrollUpButton>
+))
+SelectScrollUpButton.displayName = SelectPrimitive.ScrollUpButton.displayName
+
+const SelectScrollDownButton = React.forwardRef<
+  React.ElementRef<typeof SelectPrimitive.ScrollDownButton>,
+  React.ComponentPropsWithoutRef<typeof SelectPrimitive.ScrollDownButton>
+>(({ className, ...props }, ref) => (
+  <SelectPrimitive.ScrollDownButton
+    ref={ref}
+    className={cn(
+      'flex cursor-default items-center justify-center py-1',
+      className,
+    )}
+    {...props}
+  >
+    <ChevronDown className="h-4 w-4" />
+  </SelectPrimitive.ScrollDownButton>
+))
+SelectScrollDownButton.displayName =
+  SelectPrimitive.ScrollDownButton.displayName
+
+const SelectContent = React.forwardRef<
+  React.ElementRef<typeof SelectPrimitive.Content>,
+  React.ComponentPropsWithoutRef<typeof SelectPrimitive.Content>
+>(({ className, children, position = 'popper', ...props }, ref) => (
+  <SelectPrimitive.Portal>
+    <SelectPrimitive.Content
+      ref={ref}
+      className={cn(
+        'relative z-50 max-h-96 min-w-[8rem] overflow-hidden rounded-md border bg-popover text-popover-foreground shadow-md data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2',
+        position === 'popper' &&
+          'data-[side=bottom]:translate-y-1 data-[side=left]:-translate-x-1 data-[side=right]:translate-x-1 data-[side=top]:-translate-y-1',
+        className,
+      )}
+      position={position}
+      {...props}
+    >
+      <SelectScrollUpButton />
+      <SelectPrimitive.Viewport
+        className={cn(
+          'p-1',
+          position === 'popper' &&
+            'h-[var(--radix-select-trigger-height)] w-full min-w-[var(--radix-select-trigger-width)]',
+        )}
+      >
+        {children}
+      </SelectPrimitive.Viewport>
+      <SelectScrollDownButton />
+    </SelectPrimitive.Content>
+  </SelectPrimitive.Portal>
+))
+SelectContent.displayName = SelectPrimitive.Content.displayName
+
+const SelectLabel = React.forwardRef<
+  React.ElementRef<typeof SelectPrimitive.Label>,
+  React.ComponentPropsWithoutRef<typeof SelectPrimitive.Label>
+>(({ className, ...props }, ref) => (
+  <SelectPrimitive.Label
+    ref={ref}
+    className={cn('py-1.5 pl-8 pr-2 text-sm font-semibold', className)}
+    {...props}
+  />
+))
+SelectLabel.displayName = SelectPrimitive.Label.displayName
+
+const SelectItem = React.forwardRef<
+  React.ElementRef<typeof SelectPrimitive.Item>,
+  React.ComponentPropsWithoutRef<typeof SelectPrimitive.Item>
+>(({ className, children, ...props }, ref) => (
+  <SelectPrimitive.Item
+    ref={ref}
+    className={cn(
+      'relative flex w-full cursor-default select-none items-center rounded-sm py-1.5 pl-8 pr-2 text-sm outline-none focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50',
+      className,
+    )}
+    {...props}
+  >
+    <span className="absolute left-2 flex h-3.5 w-3.5 items-center justify-center">
+      <SelectPrimitive.ItemIndicator>
+        <Check className="h-4 w-4" />
+      </SelectPrimitive.ItemIndicator>
+    </span>
+
+    <SelectPrimitive.ItemText>{children}</SelectPrimitive.ItemText>
+  </SelectPrimitive.Item>
+))
+SelectItem.displayName = SelectPrimitive.Item.displayName
+
+const SelectSeparator = React.forwardRef<
+  React.ElementRef<typeof SelectPrimitive.Separator>,
+  React.ComponentPropsWithoutRef<typeof SelectPrimitive.Separator>
+>(({ className, ...props }, ref) => (
+  <SelectPrimitive.Separator
+    ref={ref}
+    className={cn('-mx-1 my-1 h-px bg-muted', className)}
+    {...props}
+  />
+))
+SelectSeparator.displayName = SelectPrimitive.Separator.displayName
+
+export {
+  Select,
+  SelectGroup,
+  SelectValue,
+  SelectTrigger,
+  SelectContent,
+  SelectLabel,
+  SelectItem,
+  SelectSeparator,
+  SelectScrollUpButton,
+  SelectScrollDownButton,
+}
diff --git a/components/ui/separator.tsx b/components/ui/separator.tsx
new file mode 100644
index 0000000..7f6db44
--- /dev/null
+++ b/components/ui/separator.tsx
@@ -0,0 +1,31 @@
+'use client'
+
+import * as React from 'react'
+import * as SeparatorPrimitive from '@radix-ui/react-separator'
+
+import { cn } from '@/lib/utils'
+
+const Separator = React.forwardRef<
+  React.ElementRef<typeof SeparatorPrimitive.Root>,
+  React.ComponentPropsWithoutRef<typeof SeparatorPrimitive.Root>
+>(
+  (
+    { className, orientation = 'horizontal', decorative = true, ...props },
+    ref,
+  ) => (
+    <SeparatorPrimitive.Root
+      ref={ref}
+      decorative={decorative}
+      orientation={orientation}
+      className={cn(
+        'shrink-0 bg-border',
+        orientation === 'horizontal' ? 'h-[1px] w-full' : 'h-full w-[1px]',
+        className,
+      )}
+      {...props}
+    />
+  ),
+)
+Separator.displayName = SeparatorPrimitive.Root.displayName
+
+export { Separator }
diff --git a/components/ui/sheet.tsx b/components/ui/sheet.tsx
new file mode 100644
index 0000000..dc39db1
--- /dev/null
+++ b/components/ui/sheet.tsx
@@ -0,0 +1,141 @@
+'use client'
+
+import * as React from 'react'
+import * as SheetPrimitive from '@radix-ui/react-dialog'
+import { cva, type VariantProps } from 'class-variance-authority'
+import { X } from 'lucide-react'
+
+import { cn } from '@/lib/utils'
+
+const Sheet = SheetPrimitive.Root
+
+const SheetTrigger = SheetPrimitive.Trigger
+
+const SheetClose = SheetPrimitive.Close
+
+const SheetPortal = SheetPrimitive.Portal
+
+const SheetOverlay = React.forwardRef<
+  React.ElementRef<typeof SheetPrimitive.Overlay>,
+  React.ComponentPropsWithoutRef<typeof SheetPrimitive.Overlay>
+>(({ className, ...props }, ref) => (
+  <SheetPrimitive.Overlay
+    className={cn(
+      'fixed inset-0 z-50 bg-black/80  data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0',
+      className,
+    )}
+    {...props}
+    ref={ref}
+  />
+))
+SheetOverlay.displayName = SheetPrimitive.Overlay.displayName
+
+const sheetVariants = cva(
+  'fixed z-50 gap-4 bg-background p-6 shadow-lg transition ease-in-out data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:duration-300 data-[state=open]:duration-500',
+  {
+    variants: {
+      side: {
+        top: 'inset-x-0 top-0 border-b data-[state=closed]:slide-out-to-top data-[state=open]:slide-in-from-top',
+        bottom:
+          'inset-x-0 bottom-0 border-t data-[state=closed]:slide-out-to-bottom data-[state=open]:slide-in-from-bottom',
+        left: 'inset-y-0 left-0 h-full w-3/4 border-r data-[state=closed]:slide-out-to-left data-[state=open]:slide-in-from-left sm:max-w-sm',
+        right:
+          'inset-y-0 right-0 h-full w-3/4  border-l data-[state=closed]:slide-out-to-right data-[state=open]:slide-in-from-right sm:max-w-sm',
+      },
+    },
+    defaultVariants: {
+      side: 'right',
+    },
+  },
+)
+
+interface SheetContentProps
+  extends
+    React.ComponentPropsWithoutRef<typeof SheetPrimitive.Content>,
+    VariantProps<typeof sheetVariants> {}
+
+const SheetContent = React.forwardRef<
+  React.ElementRef<typeof SheetPrimitive.Content>,
+  SheetContentProps
+>(({ side = 'right', className, children, ...props }, ref) => (
+  <SheetPortal>
+    <SheetOverlay />
+    <SheetPrimitive.Content
+      ref={ref}
+      className={cn(sheetVariants({ side }), className)}
+      {...props}
+    >
+      {children}
+      <SheetPrimitive.Close className="absolute right-4 top-4 rounded-sm opacity-70 ring-offset-background transition-opacity hover:opacity-100 focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2 disabled:pointer-events-none data-[state=open]:bg-secondary">
+        <X className="h-4 w-4" />
+        <span className="sr-only">Close</span>
+      </SheetPrimitive.Close>
+    </SheetPrimitive.Content>
+  </SheetPortal>
+))
+SheetContent.displayName = SheetPrimitive.Content.displayName
+
+const SheetHeader = ({
+  className,
+  ...props
+}: React.HTMLAttributes<HTMLDivElement>) => (
+  <div
+    className={cn(
+      'flex flex-col space-y-2 text-center sm:text-left',
+      className,
+    )}
+    {...props}
+  />
+)
+SheetHeader.displayName = 'SheetHeader'
+
+const SheetFooter = ({
+  className,
+  ...props
+}: React.HTMLAttributes<HTMLDivElement>) => (
+  <div
+    className={cn(
+      'flex flex-col-reverse sm:flex-row sm:justify-end sm:space-x-2',
+      className,
+    )}
+    {...props}
+  />
+)
+SheetFooter.displayName = 'SheetFooter'
+
+const SheetTitle = React.forwardRef<
+  React.ElementRef<typeof SheetPrimitive.Title>,
+  React.ComponentPropsWithoutRef<typeof SheetPrimitive.Title>
+>(({ className, ...props }, ref) => (
+  <SheetPrimitive.Title
+    ref={ref}
+    className={cn('text-lg font-semibold text-foreground', className)}
+    {...props}
+  />
+))
+SheetTitle.displayName = SheetPrimitive.Title.displayName
+
+const SheetDescription = React.forwardRef<
+  React.ElementRef<typeof SheetPrimitive.Description>,
+  React.ComponentPropsWithoutRef<typeof SheetPrimitive.Description>
+>(({ className, ...props }, ref) => (
+  <SheetPrimitive.Description
+    ref={ref}
+    className={cn('text-sm text-muted-foreground', className)}
+    {...props}
+  />
+))
+SheetDescription.displayName = SheetPrimitive.Description.displayName
+
+export {
+  Sheet,
+  SheetPortal,
+  SheetOverlay,
+  SheetTrigger,
+  SheetClose,
+  SheetContent,
+  SheetHeader,
+  SheetFooter,
+  SheetTitle,
+  SheetDescription,
+}
diff --git a/components/ui/sidebar.tsx b/components/ui/sidebar.tsx
new file mode 100644
index 0000000..a0f6e01
--- /dev/null
+++ b/components/ui/sidebar.tsx
@@ -0,0 +1,771 @@
+'use client'
+
+import * as React from 'react'
+import { Slot } from '@radix-ui/react-slot'
+import { VariantProps, cva } from 'class-variance-authority'
+import { PanelLeft } from 'lucide-react'
+
+import { useIsMobile } from '@/hooks/use-mobile'
+import { cn } from '@/lib/utils'
+import { Button } from '@/components/ui/button'
+import { Input } from '@/components/ui/input'
+import { Separator } from '@/components/ui/separator'
+import { Sheet, SheetContent } from '@/components/ui/sheet'
+import { Skeleton } from '@/components/ui/skeleton'
+import {
+  Tooltip,
+  TooltipContent,
+  TooltipProvider,
+  TooltipTrigger,
+} from '@/components/ui/tooltip'
+
+const SIDEBAR_COOKIE_NAME = 'sidebar:state'
+const SIDEBAR_COOKIE_MAX_AGE = 60 * 60 * 24 * 7
+const SIDEBAR_WIDTH = '16rem'
+const SIDEBAR_WIDTH_MOBILE = '18rem'
+const SIDEBAR_WIDTH_ICON = '3rem'
+const SIDEBAR_KEYBOARD_SHORTCUT = 'b'
+
+type SidebarContext = {
+  state: 'expanded' | 'collapsed'
+  open: boolean
+  setOpen: (open: boolean) => void
+  openMobile: boolean
+  setOpenMobile: (open: boolean) => void
+  isMobile: boolean
+  toggleSidebar: () => void
+}
+
+const SidebarContext = React.createContext<SidebarContext | null>(null)
+
+function useSidebar() {
+  const context = React.useContext(SidebarContext)
+  if (!context) {
+    throw new Error('useSidebar must be used within a SidebarProvider.')
+  }
+
+  return context
+}
+
+const SidebarProvider = React.forwardRef<
+  HTMLDivElement,
+  React.ComponentProps<'div'> & {
+    defaultOpen?: boolean
+    open?: boolean
+    onOpenChange?: (open: boolean) => void
+  }
+>(
+  (
+    {
+      defaultOpen = true,
+      open: openProp,
+      onOpenChange: setOpenProp,
+      className,
+      style,
+      children,
+      ...props
+    },
+    ref,
+  ) => {
+    const isMobile = useIsMobile()
+    const [openMobile, setOpenMobile] = React.useState(false)
+
+    // This is the internal state of the sidebar.
+    // We use openProp and setOpenProp for control from outside the component.
+    const [_open, _setOpen] = React.useState(defaultOpen)
+    const open = openProp ?? _open
+    const setOpen = React.useCallback(
+      (value: boolean | ((value: boolean) => boolean)) => {
+        const openState = typeof value === 'function' ? value(open) : value
+        if (setOpenProp) {
+          setOpenProp(openState)
+        } else {
+          _setOpen(openState)
+        }
+
+        // This sets the cookie to keep the sidebar state.
+        document.cookie = `${SIDEBAR_COOKIE_NAME}=${openState}; path=/; max-age=${SIDEBAR_COOKIE_MAX_AGE}`
+      },
+      [setOpenProp, open],
+    )
+
+    // Helper to toggle the sidebar.
+    const toggleSidebar = React.useCallback(() => {
+      return isMobile
+        ? setOpenMobile((open) => !open)
+        : setOpen((open) => !open)
+    }, [isMobile, setOpen, setOpenMobile])
+
+    // Adds a keyboard shortcut to toggle the sidebar.
+    React.useEffect(() => {
+      const handleKeyDown = (event: KeyboardEvent) => {
+        if (
+          event.key === SIDEBAR_KEYBOARD_SHORTCUT &&
+          (event.metaKey || event.ctrlKey)
+        ) {
+          event.preventDefault()
+          toggleSidebar()
+        }
+      }
+
+      window.addEventListener('keydown', handleKeyDown)
+      return () => window.removeEventListener('keydown', handleKeyDown)
+    }, [toggleSidebar])
+
+    // We add a state so that we can do data-state="expanded" or "collapsed".
+    // This makes it easier to style the sidebar with Tailwind classes.
+    const state = open ? 'expanded' : 'collapsed'
+
+    const contextValue = React.useMemo<SidebarContext>(
+      () => ({
+        state,
+        open,
+        setOpen,
+        isMobile,
+        openMobile,
+        setOpenMobile,
+        toggleSidebar,
+      }),
+      [
+        state,
+        open,
+        setOpen,
+        isMobile,
+        openMobile,
+        setOpenMobile,
+        toggleSidebar,
+      ],
+    )
+
+    return (
+      <SidebarContext.Provider value={contextValue}>
+        <TooltipProvider delayDuration={0}>
+          <div
+            style={
+              {
+                '--sidebar-width': SIDEBAR_WIDTH,
+                '--sidebar-width-icon': SIDEBAR_WIDTH_ICON,
+                ...style,
+              } as React.CSSProperties
+            }
+            className={cn(
+              'group/sidebar-wrapper flex min-h-svh w-full has-[[data-variant=inset]]:bg-sidebar',
+              className,
+            )}
+            ref={ref}
+            {...props}
+          >
+            {children}
+          </div>
+        </TooltipProvider>
+      </SidebarContext.Provider>
+    )
+  },
+)
+SidebarProvider.displayName = 'SidebarProvider'
+
+const Sidebar = React.forwardRef<
+  HTMLDivElement,
+  React.ComponentProps<'div'> & {
+    side?: 'left' | 'right'
+    variant?: 'sidebar' | 'floating' | 'inset'
+    collapsible?: 'offcanvas' | 'icon' | 'none'
+  }
+>(
+  (
+    {
+      side = 'left',
+      variant = 'sidebar',
+      collapsible = 'offcanvas',
+      className,
+      children,
+      ...props
+    },
+    ref,
+  ) => {
+    const { isMobile, state, openMobile, setOpenMobile } = useSidebar()
+
+    if (collapsible === 'none') {
+      return (
+        <div
+          className={cn(
+            'flex h-full w-[--sidebar-width] flex-col bg-sidebar text-sidebar-foreground',
+            className,
+          )}
+          ref={ref}
+          {...props}
+        >
+          {children}
+        </div>
+      )
+    }
+
+    if (isMobile) {
+      return (
+        <Sheet open={openMobile} onOpenChange={setOpenMobile} {...props}>
+          <SheetContent
+            data-sidebar="sidebar"
+            data-mobile="true"
+            className="w-[--sidebar-width] bg-sidebar p-0 text-sidebar-foreground [&>button]:hidden"
+            style={
+              {
+                '--sidebar-width': SIDEBAR_WIDTH_MOBILE,
+              } as React.CSSProperties
+            }
+            side={side}
+          >
+            <div className="flex h-full w-full flex-col">{children}</div>
+          </SheetContent>
+        </Sheet>
+      )
+    }
+
+    return (
+      <div
+        ref={ref}
+        className="group peer hidden md:block text-sidebar-foreground"
+        data-state={state}
+        data-collapsible={state === 'collapsed' ? collapsible : ''}
+        data-variant={variant}
+        data-side={side}
+      >
+        {/* This is what handles the sidebar gap on desktop */}
+        <div
+          className={cn(
+            'duration-200 relative h-svh w-[--sidebar-width] bg-transparent transition-[width] ease-linear',
+            'group-data-[collapsible=offcanvas]:w-0',
+            'group-data-[side=right]:rotate-180',
+            variant === 'floating' || variant === 'inset'
+              ? 'group-data-[collapsible=icon]:w-[calc(var(--sidebar-width-icon)_+_theme(spacing.4))]'
+              : 'group-data-[collapsible=icon]:w-[--sidebar-width-icon]',
+          )}
+        />
+        <div
+          className={cn(
+            'duration-200 fixed inset-y-0 z-10 hidden h-svh w-[--sidebar-width] transition-[left,right,width] ease-linear md:flex',
+            side === 'left'
+              ? 'left-0 group-data-[collapsible=offcanvas]:left-[calc(var(--sidebar-width)*-1)]'
+              : 'right-0 group-data-[collapsible=offcanvas]:right-[calc(var(--sidebar-width)*-1)]',
+            // Adjust the padding for floating and inset variants.
+            variant === 'floating' || variant === 'inset'
+              ? 'p-2 group-data-[collapsible=icon]:w-[calc(var(--sidebar-width-icon)_+_theme(spacing.4)_+2px)]'
+              : 'group-data-[collapsible=icon]:w-[--sidebar-width-icon] group-data-[side=left]:border-r group-data-[side=right]:border-l',
+            className,
+          )}
+          {...props}
+        >
+          <div
+            data-sidebar="sidebar"
+            className="flex h-full w-full flex-col bg-sidebar group-data-[variant=floating]:rounded-lg group-data-[variant=floating]:border group-data-[variant=floating]:border-sidebar-border group-data-[variant=floating]:shadow"
+          >
+            {children}
+          </div>
+        </div>
+      </div>
+    )
+  },
+)
+Sidebar.displayName = 'Sidebar'
+
+const SidebarTrigger = React.forwardRef<
+  React.ElementRef<typeof Button>,
+  React.ComponentProps<typeof Button>
+>(({ className, onClick, ...props }, ref) => {
+  const { toggleSidebar } = useSidebar()
+
+  return (
+    <Button
+      ref={ref}
+      data-sidebar="trigger"
+      variant="ghost"
+      size="icon"
+      className={cn('h-7 w-7', className)}
+      onClick={(event) => {
+        onClick?.(event)
+        toggleSidebar()
+      }}
+      {...props}
+    >
+      <PanelLeft />
+      <span className="sr-only">Toggle Sidebar</span>
+    </Button>
+  )
+})
+SidebarTrigger.displayName = 'SidebarTrigger'
+
+const SidebarRail = React.forwardRef<
+  HTMLButtonElement,
+  React.ComponentProps<'button'>
+>(({ className, ...props }, ref) => {
+  const { toggleSidebar } = useSidebar()
+
+  return (
+    <button
+      ref={ref}
+      data-sidebar="rail"
+      aria-label="Toggle Sidebar"
+      tabIndex={-1}
+      onClick={toggleSidebar}
+      title="Toggle Sidebar"
+      className={cn(
+        'absolute inset-y-0 z-20 hidden w-4 -translate-x-1/2 transition-all ease-linear after:absolute after:inset-y-0 after:left-1/2 after:w-[2px] hover:after:bg-sidebar-border group-data-[side=left]:-right-4 group-data-[side=right]:left-0 sm:flex',
+        '[[data-side=left]_&]:cursor-w-resize [[data-side=right]_&]:cursor-e-resize',
+        '[[data-side=left][data-state=collapsed]_&]:cursor-e-resize [[data-side=right][data-state=collapsed]_&]:cursor-w-resize',
+        'group-data-[collapsible=offcanvas]:translate-x-0 group-data-[collapsible=offcanvas]:after:left-full group-data-[collapsible=offcanvas]:hover:bg-sidebar',
+        '[[data-side=left][data-collapsible=offcanvas]_&]:-right-2',
+        '[[data-side=right][data-collapsible=offcanvas]_&]:-left-2',
+        className,
+      )}
+      {...props}
+    />
+  )
+})
+SidebarRail.displayName = 'SidebarRail'
+
+const SidebarInset = React.forwardRef<
+  HTMLDivElement,
+  React.ComponentProps<'main'>
+>(({ className, ...props }, ref) => {
+  return (
+    <main
+      ref={ref}
+      className={cn(
+        'relative flex min-h-svh flex-1 flex-col bg-background',
+        'peer-data-[variant=inset]:min-h-[calc(100svh-theme(spacing.4))] md:peer-data-[variant=inset]:m-2 md:peer-data-[state=collapsed]:peer-data-[variant=inset]:ml-2 md:peer-data-[variant=inset]:ml-0 md:peer-data-[variant=inset]:rounded-xl md:peer-data-[variant=inset]:shadow',
+        className,
+      )}
+      {...props}
+    />
+  )
+})
+SidebarInset.displayName = 'SidebarInset'
+
+const SidebarInput = React.forwardRef<
+  React.ElementRef<typeof Input>,
+  React.ComponentProps<typeof Input>
+>(({ className, ...props }, ref) => {
+  return (
+    <Input
+      ref={ref}
+      data-sidebar="input"
+      className={cn(
+        'h-8 w-full bg-background shadow-none focus-visible:ring-2 focus-visible:ring-sidebar-ring',
+        className,
+      )}
+      {...props}
+    />
+  )
+})
+SidebarInput.displayName = 'SidebarInput'
+
+const SidebarHeader = React.forwardRef<
+  HTMLDivElement,
+  React.ComponentProps<'div'>
+>(({ className, ...props }, ref) => {
+  return (
+    <div
+      ref={ref}
+      data-sidebar="header"
+      className={cn('flex flex-col gap-2 p-2', className)}
+      {...props}
+    />
+  )
+})
+SidebarHeader.displayName = 'SidebarHeader'
+
+const SidebarFooter = React.forwardRef<
+  HTMLDivElement,
+  React.ComponentProps<'div'>
+>(({ className, ...props }, ref) => {
+  return (
+    <div
+      ref={ref}
+      data-sidebar="footer"
+      className={cn('flex flex-col gap-2 p-2', className)}
+      {...props}
+    />
+  )
+})
+SidebarFooter.displayName = 'SidebarFooter'
+
+const SidebarSeparator = React.forwardRef<
+  React.ElementRef<typeof Separator>,
+  React.ComponentProps<typeof Separator>
+>(({ className, ...props }, ref) => {
+  return (
+    <Separator
+      ref={ref}
+      data-sidebar="separator"
+      className={cn('mx-2 w-auto bg-sidebar-border', className)}
+      {...props}
+    />
+  )
+})
+SidebarSeparator.displayName = 'SidebarSeparator'
+
+const SidebarContent = React.forwardRef<
+  HTMLDivElement,
+  React.ComponentProps<'div'>
+>(({ className, ...props }, ref) => {
+  return (
+    <div
+      ref={ref}
+      data-sidebar="content"
+      className={cn(
+        'flex min-h-0 flex-1 flex-col gap-2 overflow-auto group-data-[collapsible=icon]:overflow-hidden',
+        className,
+      )}
+      {...props}
+    />
+  )
+})
+SidebarContent.displayName = 'SidebarContent'
+
+const SidebarGroup = React.forwardRef<
+  HTMLDivElement,
+  React.ComponentProps<'div'>
+>(({ className, ...props }, ref) => {
+  return (
+    <div
+      ref={ref}
+      data-sidebar="group"
+      className={cn('relative flex w-full min-w-0 flex-col p-2', className)}
+      {...props}
+    />
+  )
+})
+SidebarGroup.displayName = 'SidebarGroup'
+
+const SidebarGroupLabel = React.forwardRef<
+  HTMLDivElement,
+  React.ComponentProps<'div'> & { asChild?: boolean }
+>(({ className, asChild = false, ...props }, ref) => {
+  const Comp = asChild ? Slot : 'div'
+
+  return (
+    <Comp
+      ref={ref}
+      data-sidebar="group-label"
+      className={cn(
+        'duration-200 flex h-8 shrink-0 items-center rounded-md px-2 text-xs font-medium text-sidebar-foreground/70 outline-none ring-sidebar-ring transition-[margin,opa] ease-linear focus-visible:ring-2 [&>svg]:size-4 [&>svg]:shrink-0',
+        'group-data-[collapsible=icon]:-mt-8 group-data-[collapsible=icon]:opacity-0',
+        className,
+      )}
+      {...props}
+    />
+  )
+})
+SidebarGroupLabel.displayName = 'SidebarGroupLabel'
+
+const SidebarGroupAction = React.forwardRef<
+  HTMLButtonElement,
+  React.ComponentProps<'button'> & { asChild?: boolean }
+>(({ className, asChild = false, ...props }, ref) => {
+  const Comp = asChild ? Slot : 'button'
+
+  return (
+    <Comp
+      ref={ref}
+      data-sidebar="group-action"
+      className={cn(
+        'absolute right-3 top-3.5 flex aspect-square w-5 items-center justify-center rounded-md p-0 text-sidebar-foreground outline-none ring-sidebar-ring transition-transform hover:bg-sidebar-accent hover:text-sidebar-accent-foreground focus-visible:ring-2 [&>svg]:size-4 [&>svg]:shrink-0',
+        // Increases the hit area of the button on mobile.
+        'after:absolute after:-inset-2 after:md:hidden',
+        'group-data-[collapsible=icon]:hidden',
+        className,
+      )}
+      {...props}
+    />
+  )
+})
+SidebarGroupAction.displayName = 'SidebarGroupAction'
+
+const SidebarGroupContent = React.forwardRef<
+  HTMLDivElement,
+  React.ComponentProps<'div'>
+>(({ className, ...props }, ref) => (
+  <div
+    ref={ref}
+    data-sidebar="group-content"
+    className={cn('w-full text-sm', className)}
+    {...props}
+  />
+))
+SidebarGroupContent.displayName = 'SidebarGroupContent'
+
+const SidebarMenu = React.forwardRef<
+  HTMLUListElement,
+  React.ComponentProps<'ul'>
+>(({ className, ...props }, ref) => (
+  <ul
+    ref={ref}
+    data-sidebar="menu"
+    className={cn('flex w-full min-w-0 flex-col gap-1', className)}
+    {...props}
+  />
+))
+SidebarMenu.displayName = 'SidebarMenu'
+
+const SidebarMenuItem = React.forwardRef<
+  HTMLLIElement,
+  React.ComponentProps<'li'>
+>(({ className, ...props }, ref) => (
+  <li
+    ref={ref}
+    data-sidebar="menu-item"
+    className={cn('group/menu-item relative', className)}
+    {...props}
+  />
+))
+SidebarMenuItem.displayName = 'SidebarMenuItem'
+
+const sidebarMenuButtonVariants = cva(
+  'peer/menu-button flex w-full items-center gap-2 overflow-hidden rounded-md p-2 text-left text-sm outline-none ring-sidebar-ring transition-[width,height,padding] hover:bg-sidebar-accent hover:text-sidebar-accent-foreground focus-visible:ring-2 active:bg-sidebar-accent active:text-sidebar-accent-foreground disabled:pointer-events-none disabled:opacity-50 group-has-[[data-sidebar=menu-action]]/menu-item:pr-8 aria-disabled:pointer-events-none aria-disabled:opacity-50 data-[active=true]:bg-sidebar-accent data-[active=true]:font-medium data-[active=true]:text-sidebar-accent-foreground data-[state=open]:hover:bg-sidebar-accent data-[state=open]:hover:text-sidebar-accent-foreground group-data-[collapsible=icon]:!size-8 group-data-[collapsible=icon]:!p-2 [&>span:last-child]:truncate [&>svg]:size-4 [&>svg]:shrink-0',
+  {
+    variants: {
+      variant: {
+        default: 'hover:bg-sidebar-accent hover:text-sidebar-accent-foreground',
+        outline:
+          'bg-background shadow-[0_0_0_1px_hsl(var(--sidebar-border))] hover:bg-sidebar-accent hover:text-sidebar-accent-foreground hover:shadow-[0_0_0_1px_hsl(var(--sidebar-accent))]',
+      },
+      size: {
+        default: 'h-8 text-sm',
+        sm: 'h-7 text-xs',
+        lg: 'h-12 text-sm group-data-[collapsible=icon]:!p-0',
+      },
+    },
+    defaultVariants: {
+      variant: 'default',
+      size: 'default',
+    },
+  },
+)
+
+const SidebarMenuButton = React.forwardRef<
+  HTMLButtonElement,
+  React.ComponentProps<'button'> & {
+    asChild?: boolean
+    isActive?: boolean
+    tooltip?: string | React.ComponentProps<typeof TooltipContent>
+  } & VariantProps<typeof sidebarMenuButtonVariants>
+>(
+  (
+    {
+      asChild = false,
+      isActive = false,
+      variant = 'default',
+      size = 'default',
+      tooltip,
+      className,
+      ...props
+    },
+    ref,
+  ) => {
+    const Comp = asChild ? Slot : 'button'
+    const { isMobile, state } = useSidebar()
+
+    const button = (
+      <Comp
+        ref={ref}
+        data-sidebar="menu-button"
+        data-size={size}
+        data-active={isActive}
+        className={cn(sidebarMenuButtonVariants({ variant, size }), className)}
+        {...props}
+      />
+    )
+
+    if (!tooltip) {
+      return button
+    }
+
+    if (typeof tooltip === 'string') {
+      tooltip = {
+        children: tooltip,
+      }
+    }
+
+    return (
+      <Tooltip>
+        <TooltipTrigger asChild>{button}</TooltipTrigger>
+        <TooltipContent
+          side="right"
+          align="center"
+          hidden={state !== 'collapsed' || isMobile}
+          {...tooltip}
+        />
+      </Tooltip>
+    )
+  },
+)
+SidebarMenuButton.displayName = 'SidebarMenuButton'
+
+const SidebarMenuAction = React.forwardRef<
+  HTMLButtonElement,
+  React.ComponentProps<'button'> & {
+    asChild?: boolean
+    showOnHover?: boolean
+  }
+>(({ className, asChild = false, showOnHover = false, ...props }, ref) => {
+  const Comp = asChild ? Slot : 'button'
+
+  return (
+    <Comp
+      ref={ref}
+      data-sidebar="menu-action"
+      className={cn(
+        'absolute right-1 top-1.5 flex aspect-square w-5 items-center justify-center rounded-md p-0 text-sidebar-foreground outline-none ring-sidebar-ring transition-transform hover:bg-sidebar-accent hover:text-sidebar-accent-foreground focus-visible:ring-2 peer-hover/menu-button:text-sidebar-accent-foreground [&>svg]:size-4 [&>svg]:shrink-0',
+        // Increases the hit area of the button on mobile.
+        'after:absolute after:-inset-2 after:md:hidden',
+        'peer-data-[size=sm]/menu-button:top-1',
+        'peer-data-[size=default]/menu-button:top-1.5',
+        'peer-data-[size=lg]/menu-button:top-2.5',
+        'group-data-[collapsible=icon]:hidden',
+        showOnHover &&
+          'group-focus-within/menu-item:opacity-100 group-hover/menu-item:opacity-100 data-[state=open]:opacity-100 peer-data-[active=true]/menu-button:text-sidebar-accent-foreground md:opacity-0',
+        className,
+      )}
+      {...props}
+    />
+  )
+})
+SidebarMenuAction.displayName = 'SidebarMenuAction'
+
+const SidebarMenuBadge = React.forwardRef<
+  HTMLDivElement,
+  React.ComponentProps<'div'>
+>(({ className, ...props }, ref) => (
+  <div
+    ref={ref}
+    data-sidebar="menu-badge"
+    className={cn(
+      'absolute right-1 flex h-5 min-w-5 items-center justify-center rounded-md px-1 text-xs font-medium tabular-nums text-sidebar-foreground select-none pointer-events-none',
+      'peer-hover/menu-button:text-sidebar-accent-foreground peer-data-[active=true]/menu-button:text-sidebar-accent-foreground',
+      'peer-data-[size=sm]/menu-button:top-1',
+      'peer-data-[size=default]/menu-button:top-1.5',
+      'peer-data-[size=lg]/menu-button:top-2.5',
+      'group-data-[collapsible=icon]:hidden',
+      className,
+    )}
+    {...props}
+  />
+))
+SidebarMenuBadge.displayName = 'SidebarMenuBadge'
+
+const SidebarMenuSkeleton = React.forwardRef<
+  HTMLDivElement,
+  React.ComponentProps<'div'> & {
+    showIcon?: boolean
+  }
+>(({ className, showIcon = false, ...props }, ref) => {
+  // Random width between 50 to 90%.
+  const width = React.useMemo(() => {
+    return `${Math.floor(Math.random() * 40) + 50}%`
+  }, [])
+
+  return (
+    <div
+      ref={ref}
+      data-sidebar="menu-skeleton"
+      className={cn('rounded-md h-8 flex gap-2 px-2 items-center', className)}
+      {...props}
+    >
+      {showIcon && (
+        <Skeleton
+          className="size-4 rounded-md"
+          data-sidebar="menu-skeleton-icon"
+        />
+      )}
+      <Skeleton
+        className="h-4 flex-1 max-w-[--skeleton-width]"
+        data-sidebar="menu-skeleton-text"
+        style={
+          {
+            '--skeleton-width': width,
+          } as React.CSSProperties
+        }
+      />
+    </div>
+  )
+})
+SidebarMenuSkeleton.displayName = 'SidebarMenuSkeleton'
+
+const SidebarMenuSub = React.forwardRef<
+  HTMLUListElement,
+  React.ComponentProps<'ul'>
+>(({ className, ...props }, ref) => (
+  <ul
+    ref={ref}
+    data-sidebar="menu-sub"
+    className={cn(
+      'mx-3.5 flex min-w-0 translate-x-px flex-col gap-1 border-l border-sidebar-border px-2.5 py-0.5',
+      'group-data-[collapsible=icon]:hidden',
+      className,
+    )}
+    {...props}
+  />
+))
+SidebarMenuSub.displayName = 'SidebarMenuSub'
+
+const SidebarMenuSubItem = React.forwardRef<
+  HTMLLIElement,
+  React.ComponentProps<'li'>
+>(({ ...props }, ref) => <li ref={ref} {...props} />)
+SidebarMenuSubItem.displayName = 'SidebarMenuSubItem'
+
+const SidebarMenuSubButton = React.forwardRef<
+  HTMLAnchorElement,
+  React.ComponentProps<'a'> & {
+    asChild?: boolean
+    size?: 'sm' | 'md'
+    isActive?: boolean
+  }
+>(({ asChild = false, size = 'md', isActive, className, ...props }, ref) => {
+  const Comp = asChild ? Slot : 'a'
+
+  return (
+    <Comp
+      ref={ref}
+      data-sidebar="menu-sub-button"
+      data-size={size}
+      data-active={isActive}
+      className={cn(
+        'flex h-7 min-w-0 -translate-x-px items-center gap-2 overflow-hidden rounded-md px-2 text-sidebar-foreground outline-none ring-sidebar-ring hover:bg-sidebar-accent hover:text-sidebar-accent-foreground focus-visible:ring-2 active:bg-sidebar-accent active:text-sidebar-accent-foreground disabled:pointer-events-none disabled:opacity-50 aria-disabled:pointer-events-none aria-disabled:opacity-50 [&>span:last-child]:truncate [&>svg]:size-4 [&>svg]:shrink-0 [&>svg]:text-sidebar-accent-foreground',
+        'data-[active=true]:bg-sidebar-accent data-[active=true]:text-sidebar-accent-foreground',
+        size === 'sm' && 'text-xs',
+        size === 'md' && 'text-sm',
+        'group-data-[collapsible=icon]:hidden',
+        className,
+      )}
+      {...props}
+    />
+  )
+})
+SidebarMenuSubButton.displayName = 'SidebarMenuSubButton'
+
+export {
+  Sidebar,
+  SidebarContent,
+  SidebarFooter,
+  SidebarGroup,
+  SidebarGroupAction,
+  SidebarGroupContent,
+  SidebarGroupLabel,
+  SidebarHeader,
+  SidebarInput,
+  SidebarInset,
+  SidebarMenu,
+  SidebarMenuAction,
+  SidebarMenuBadge,
+  SidebarMenuButton,
+  SidebarMenuItem,
+  SidebarMenuSkeleton,
+  SidebarMenuSub,
+  SidebarMenuSubButton,
+  SidebarMenuSubItem,
+  SidebarProvider,
+  SidebarRail,
+  SidebarSeparator,
+  SidebarTrigger,
+  useSidebar,
+}
diff --git a/components/ui/skeleton.tsx b/components/ui/skeleton.tsx
new file mode 100644
index 0000000..c23a30d
--- /dev/null
+++ b/components/ui/skeleton.tsx
@@ -0,0 +1,15 @@
+import { cn } from '@/lib/utils'
+
+function Skeleton({
+  className,
+  ...props
+}: React.HTMLAttributes<HTMLDivElement>) {
+  return (
+    <div
+      className={cn('animate-pulse rounded-md bg-muted', className)}
+      {...props}
+    />
+  )
+}
+
+export { Skeleton }
diff --git a/components/ui/slider.tsx b/components/ui/slider.tsx
new file mode 100644
index 0000000..8ee2132
--- /dev/null
+++ b/components/ui/slider.tsx
@@ -0,0 +1,28 @@
+'use client'
+
+import * as React from 'react'
+import * as SliderPrimitive from '@radix-ui/react-slider'
+
+import { cn } from '@/lib/utils'
+
+const Slider = React.forwardRef<
+  React.ElementRef<typeof SliderPrimitive.Root>,
+  React.ComponentPropsWithoutRef<typeof SliderPrimitive.Root>
+>(({ className, ...props }, ref) => (
+  <SliderPrimitive.Root
+    ref={ref}
+    className={cn(
+      'relative flex w-full touch-none select-none items-center',
+      className,
+    )}
+    {...props}
+  >
+    <SliderPrimitive.Track className="relative h-2 w-full grow overflow-hidden rounded-full bg-secondary">
+      <SliderPrimitive.Range className="absolute h-full bg-primary" />
+    </SliderPrimitive.Track>
+    <SliderPrimitive.Thumb className="block h-5 w-5 rounded-full border-2 border-primary bg-background ring-offset-background transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50" />
+  </SliderPrimitive.Root>
+))
+Slider.displayName = SliderPrimitive.Root.displayName
+
+export { Slider }
diff --git a/components/ui/sonner.tsx b/components/ui/sonner.tsx
new file mode 100644
index 0000000..595cff5
--- /dev/null
+++ b/components/ui/sonner.tsx
@@ -0,0 +1,31 @@
+'use client'
+
+import { useTheme } from 'next-themes'
+import { Toaster as Sonner } from 'sonner'
+
+type ToasterProps = React.ComponentProps<typeof Sonner>
+
+const Toaster = ({ ...props }: ToasterProps) => {
+  const { theme = 'system' } = useTheme()
+
+  return (
+    <Sonner
+      theme={theme as ToasterProps['theme']}
+      className="toaster group"
+      toastOptions={{
+        classNames: {
+          toast:
+            'group toast group-[.toaster]:bg-background group-[.toaster]:text-foreground group-[.toaster]:border-border group-[.toaster]:shadow-lg',
+          description: 'group-[.toast]:text-muted-foreground',
+          actionButton:
+            'group-[.toast]:bg-primary group-[.toast]:text-primary-foreground',
+          cancelButton:
+            'group-[.toast]:bg-muted group-[.toast]:text-muted-foreground',
+        },
+      }}
+      {...props}
+    />
+  )
+}
+
+export { Toaster }
diff --git a/components/ui/switch.tsx b/components/ui/switch.tsx
new file mode 100644
index 0000000..4ffe97a
--- /dev/null
+++ b/components/ui/switch.tsx
@@ -0,0 +1,29 @@
+'use client'
+
+import * as React from 'react'
+import * as SwitchPrimitives from '@radix-ui/react-switch'
+
+import { cn } from '@/lib/utils'
+
+const Switch = React.forwardRef<
+  React.ElementRef<typeof SwitchPrimitives.Root>,
+  React.ComponentPropsWithoutRef<typeof SwitchPrimitives.Root>
+>(({ className, ...props }, ref) => (
+  <SwitchPrimitives.Root
+    className={cn(
+      'peer inline-flex h-6 w-11 shrink-0 cursor-pointer items-center rounded-full border-2 border-transparent transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 focus-visible:ring-offset-background disabled:cursor-not-allowed disabled:opacity-50 data-[state=checked]:bg-primary data-[state=unchecked]:bg-input',
+      className,
+    )}
+    {...props}
+    ref={ref}
+  >
+    <SwitchPrimitives.Thumb
+      className={cn(
+        'pointer-events-none block h-5 w-5 rounded-full bg-background shadow-lg ring-0 transition-transform data-[state=checked]:translate-x-5 data-[state=unchecked]:translate-x-0',
+      )}
+    />
+  </SwitchPrimitives.Root>
+))
+Switch.displayName = SwitchPrimitives.Root.displayName
+
+export { Switch }
diff --git a/components/ui/table.tsx b/components/ui/table.tsx
new file mode 100644
index 0000000..97ef8eb
--- /dev/null
+++ b/components/ui/table.tsx
@@ -0,0 +1,117 @@
+import * as React from 'react'
+
+import { cn } from '@/lib/utils'
+
+const Table = React.forwardRef<
+  HTMLTableElement,
+  React.HTMLAttributes<HTMLTableElement>
+>(({ className, ...props }, ref) => (
+  <div className="relative w-full overflow-auto">
+    <table
+      ref={ref}
+      className={cn('w-full caption-bottom text-sm', className)}
+      {...props}
+    />
+  </div>
+))
+Table.displayName = 'Table'
+
+const TableHeader = React.forwardRef<
+  HTMLTableSectionElement,
+  React.HTMLAttributes<HTMLTableSectionElement>
+>(({ className, ...props }, ref) => (
+  <thead ref={ref} className={cn('[&_tr]:border-b', className)} {...props} />
+))
+TableHeader.displayName = 'TableHeader'
+
+const TableBody = React.forwardRef<
+  HTMLTableSectionElement,
+  React.HTMLAttributes<HTMLTableSectionElement>
+>(({ className, ...props }, ref) => (
+  <tbody
+    ref={ref}
+    className={cn('[&_tr:last-child]:border-0', className)}
+    {...props}
+  />
+))
+TableBody.displayName = 'TableBody'
+
+const TableFooter = React.forwardRef<
+  HTMLTableSectionElement,
+  React.HTMLAttributes<HTMLTableSectionElement>
+>(({ className, ...props }, ref) => (
+  <tfoot
+    ref={ref}
+    className={cn(
+      'border-t bg-muted/50 font-medium [&>tr]:last:border-b-0',
+      className,
+    )}
+    {...props}
+  />
+))
+TableFooter.displayName = 'TableFooter'
+
+const TableRow = React.forwardRef<
+  HTMLTableRowElement,
+  React.HTMLAttributes<HTMLTableRowElement>
+>(({ className, ...props }, ref) => (
+  <tr
+    ref={ref}
+    className={cn(
+      'border-b transition-colors hover:bg-muted/50 data-[state=selected]:bg-muted',
+      className,
+    )}
+    {...props}
+  />
+))
+TableRow.displayName = 'TableRow'
+
+const TableHead = React.forwardRef<
+  HTMLTableCellElement,
+  React.ThHTMLAttributes<HTMLTableCellElement>
+>(({ className, ...props }, ref) => (
+  <th
+    ref={ref}
+    className={cn(
+      'h-12 px-4 text-left align-middle font-medium text-muted-foreground [&:has([role=checkbox])]:pr-0',
+      className,
+    )}
+    {...props}
+  />
+))
+TableHead.displayName = 'TableHead'
+
+const TableCell = React.forwardRef<
+  HTMLTableCellElement,
+  React.TdHTMLAttributes<HTMLTableCellElement>
+>(({ className, ...props }, ref) => (
+  <td
+    ref={ref}
+    className={cn('p-4 align-middle [&:has([role=checkbox])]:pr-0', className)}
+    {...props}
+  />
+))
+TableCell.displayName = 'TableCell'
+
+const TableCaption = React.forwardRef<
+  HTMLTableCaptionElement,
+  React.HTMLAttributes<HTMLTableCaptionElement>
+>(({ className, ...props }, ref) => (
+  <caption
+    ref={ref}
+    className={cn('mt-4 text-sm text-muted-foreground', className)}
+    {...props}
+  />
+))
+TableCaption.displayName = 'TableCaption'
+
+export {
+  Table,
+  TableHeader,
+  TableBody,
+  TableFooter,
+  TableHead,
+  TableRow,
+  TableCell,
+  TableCaption,
+}
diff --git a/components/ui/tabs.tsx b/components/ui/tabs.tsx
new file mode 100644
index 0000000..03caf14
--- /dev/null
+++ b/components/ui/tabs.tsx
@@ -0,0 +1,55 @@
+'use client'
+
+import * as React from 'react'
+import * as TabsPrimitive from '@radix-ui/react-tabs'
+
+import { cn } from '@/lib/utils'
+
+const Tabs = TabsPrimitive.Root
+
+const TabsList = React.forwardRef<
+  React.ElementRef<typeof TabsPrimitive.List>,
+  React.ComponentPropsWithoutRef<typeof TabsPrimitive.List>
+>(({ className, ...props }, ref) => (
+  <TabsPrimitive.List
+    ref={ref}
+    className={cn(
+      'inline-flex h-10 items-center justify-center rounded-md bg-muted p-1 text-muted-foreground',
+      className,
+    )}
+    {...props}
+  />
+))
+TabsList.displayName = TabsPrimitive.List.displayName
+
+const TabsTrigger = React.forwardRef<
+  React.ElementRef<typeof TabsPrimitive.Trigger>,
+  React.ComponentPropsWithoutRef<typeof TabsPrimitive.Trigger>
+>(({ className, ...props }, ref) => (
+  <TabsPrimitive.Trigger
+    ref={ref}
+    className={cn(
+      'inline-flex items-center justify-center whitespace-nowrap rounded-sm px-3 py-1.5 text-sm font-medium ring-offset-background transition-all focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50 data-[state=active]:bg-background data-[state=active]:text-foreground data-[state=active]:shadow-sm',
+      className,
+    )}
+    {...props}
+  />
+))
+TabsTrigger.displayName = TabsPrimitive.Trigger.displayName
+
+const TabsContent = React.forwardRef<
+  React.ElementRef<typeof TabsPrimitive.Content>,
+  React.ComponentPropsWithoutRef<typeof TabsPrimitive.Content>
+>(({ className, ...props }, ref) => (
+  <TabsPrimitive.Content
+    ref={ref}
+    className={cn(
+      'mt-2 ring-offset-background focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2',
+      className,
+    )}
+    {...props}
+  />
+))
+TabsContent.displayName = TabsPrimitive.Content.displayName
+
+export { Tabs, TabsList, TabsTrigger, TabsContent }
diff --git a/components/ui/textarea.tsx b/components/ui/textarea.tsx
new file mode 100644
index 0000000..0960463
--- /dev/null
+++ b/components/ui/textarea.tsx
@@ -0,0 +1,22 @@
+import * as React from 'react'
+
+import { cn } from '@/lib/utils'
+
+const Textarea = React.forwardRef<
+  HTMLTextAreaElement,
+  React.ComponentProps<'textarea'>
+>(({ className, ...props }, ref) => {
+  return (
+    <textarea
+      className={cn(
+        'flex min-h-[80px] w-full rounded-md border border-input bg-background px-3 py-2 text-base ring-offset-background placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50 md:text-sm',
+        className,
+      )}
+      ref={ref}
+      {...props}
+    />
+  )
+})
+Textarea.displayName = 'Textarea'
+
+export { Textarea }
diff --git a/components/ui/toast.tsx b/components/ui/toast.tsx
new file mode 100644
index 0000000..40eedf5
--- /dev/null
+++ b/components/ui/toast.tsx
@@ -0,0 +1,129 @@
+'use client'
+
+import * as React from 'react'
+import * as ToastPrimitives from '@radix-ui/react-toast'
+import { cva, type VariantProps } from 'class-variance-authority'
+import { X } from 'lucide-react'
+
+import { cn } from '@/lib/utils'
+
+const ToastProvider = ToastPrimitives.Provider
+
+const ToastViewport = React.forwardRef<
+  React.ElementRef<typeof ToastPrimitives.Viewport>,
+  React.ComponentPropsWithoutRef<typeof ToastPrimitives.Viewport>
+>(({ className, ...props }, ref) => (
+  <ToastPrimitives.Viewport
+    ref={ref}
+    className={cn(
+      'fixed top-0 z-[100] flex max-h-screen w-full flex-col-reverse p-4 sm:bottom-0 sm:right-0 sm:top-auto sm:flex-col md:max-w-[420px]',
+      className,
+    )}
+    {...props}
+  />
+))
+ToastViewport.displayName = ToastPrimitives.Viewport.displayName
+
+const toastVariants = cva(
+  'group pointer-events-auto relative flex w-full items-center justify-between space-x-4 overflow-hidden rounded-md border p-6 pr-8 shadow-lg transition-all data-[swipe=cancel]:translate-x-0 data-[swipe=end]:translate-x-[var(--radix-toast-swipe-end-x)] data-[swipe=move]:translate-x-[var(--radix-toast-swipe-move-x)] data-[swipe=move]:transition-none data-[state=open]:animate-in data-[state=closed]:animate-out data-[swipe=end]:animate-out data-[state=closed]:fade-out-80 data-[state=closed]:slide-out-to-right-full data-[state=open]:slide-in-from-top-full data-[state=open]:sm:slide-in-from-bottom-full',
+  {
+    variants: {
+      variant: {
+        default: 'border bg-background text-foreground',
+        destructive:
+          'destructive group border-destructive bg-destructive text-destructive-foreground',
+      },
+    },
+    defaultVariants: {
+      variant: 'default',
+    },
+  },
+)
+
+const Toast = React.forwardRef<
+  React.ElementRef<typeof ToastPrimitives.Root>,
+  React.ComponentPropsWithoutRef<typeof ToastPrimitives.Root> &
+    VariantProps<typeof toastVariants>
+>(({ className, variant, ...props }, ref) => {
+  return (
+    <ToastPrimitives.Root
+      ref={ref}
+      className={cn(toastVariants({ variant }), className)}
+      {...props}
+    />
+  )
+})
+Toast.displayName = ToastPrimitives.Root.displayName
+
+const ToastAction = React.forwardRef<
+  React.ElementRef<typeof ToastPrimitives.Action>,
+  React.ComponentPropsWithoutRef<typeof ToastPrimitives.Action>
+>(({ className, ...props }, ref) => (
+  <ToastPrimitives.Action
+    ref={ref}
+    className={cn(
+      'inline-flex h-8 shrink-0 items-center justify-center rounded-md border bg-transparent px-3 text-sm font-medium ring-offset-background transition-colors hover:bg-secondary focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2 disabled:pointer-events-none disabled:opacity-50 group-[.destructive]:border-muted/40 group-[.destructive]:hover:border-destructive/30 group-[.destructive]:hover:bg-destructive group-[.destructive]:hover:text-destructive-foreground group-[.destructive]:focus:ring-destructive',
+      className,
+    )}
+    {...props}
+  />
+))
+ToastAction.displayName = ToastPrimitives.Action.displayName
+
+const ToastClose = React.forwardRef<
+  React.ElementRef<typeof ToastPrimitives.Close>,
+  React.ComponentPropsWithoutRef<typeof ToastPrimitives.Close>
+>(({ className, ...props }, ref) => (
+  <ToastPrimitives.Close
+    ref={ref}
+    className={cn(
+      'absolute right-2 top-2 rounded-md p-1 text-foreground/50 opacity-0 transition-opacity hover:text-foreground focus:opacity-100 focus:outline-none focus:ring-2 group-hover:opacity-100 group-[.destructive]:text-red-300 group-[.destructive]:hover:text-red-50 group-[.destructive]:focus:ring-red-400 group-[.destructive]:focus:ring-offset-red-600',
+      className,
+    )}
+    toast-close=""
+    {...props}
+  >
+    <X className="h-4 w-4" />
+  </ToastPrimitives.Close>
+))
+ToastClose.displayName = ToastPrimitives.Close.displayName
+
+const ToastTitle = React.forwardRef<
+  React.ElementRef<typeof ToastPrimitives.Title>,
+  React.ComponentPropsWithoutRef<typeof ToastPrimitives.Title>
+>(({ className, ...props }, ref) => (
+  <ToastPrimitives.Title
+    ref={ref}
+    className={cn('text-sm font-semibold', className)}
+    {...props}
+  />
+))
+ToastTitle.displayName = ToastPrimitives.Title.displayName
+
+const ToastDescription = React.forwardRef<
+  React.ElementRef<typeof ToastPrimitives.Description>,
+  React.ComponentPropsWithoutRef<typeof ToastPrimitives.Description>
+>(({ className, ...props }, ref) => (
+  <ToastPrimitives.Description
+    ref={ref}
+    className={cn('text-sm opacity-90', className)}
+    {...props}
+  />
+))
+ToastDescription.displayName = ToastPrimitives.Description.displayName
+
+type ToastProps = React.ComponentPropsWithoutRef<typeof Toast>
+
+type ToastActionElement = React.ReactElement<typeof ToastAction>
+
+export {
+  type ToastProps,
+  type ToastActionElement,
+  ToastProvider,
+  ToastViewport,
+  Toast,
+  ToastTitle,
+  ToastDescription,
+  ToastClose,
+  ToastAction,
+}
diff --git a/components/ui/toaster.tsx b/components/ui/toaster.tsx
new file mode 100644
index 0000000..3b91885
--- /dev/null
+++ b/components/ui/toaster.tsx
@@ -0,0 +1,35 @@
+'use client'
+
+import { useToast } from '@/hooks/use-toast'
+import {
+  Toast,
+  ToastClose,
+  ToastDescription,
+  ToastProvider,
+  ToastTitle,
+  ToastViewport,
+} from '@/components/ui/toast'
+
+export function Toaster() {
+  const { toasts } = useToast()
+
+  return (
+    <ToastProvider>
+      {toasts.map(function ({ id, title, description, action, ...props }) {
+        return (
+          <Toast key={id} {...props}>
+            <div className="grid gap-1">
+              {title && <ToastTitle>{title}</ToastTitle>}
+              {description && (
+                <ToastDescription>{description}</ToastDescription>
+              )}
+            </div>
+            {action}
+            <ToastClose />
+          </Toast>
+        )
+      })}
+      <ToastViewport />
+    </ToastProvider>
+  )
+}
diff --git a/components/ui/toggle-group.tsx b/components/ui/toggle-group.tsx
new file mode 100644
index 0000000..70f3e99
--- /dev/null
+++ b/components/ui/toggle-group.tsx
@@ -0,0 +1,61 @@
+'use client'
+
+import * as React from 'react'
+import * as ToggleGroupPrimitive from '@radix-ui/react-toggle-group'
+import { type VariantProps } from 'class-variance-authority'
+
+import { cn } from '@/lib/utils'
+import { toggleVariants } from '@/components/ui/toggle'
+
+const ToggleGroupContext = React.createContext<
+  VariantProps<typeof toggleVariants>
+>({
+  size: 'default',
+  variant: 'default',
+})
+
+const ToggleGroup = React.forwardRef<
+  React.ElementRef<typeof ToggleGroupPrimitive.Root>,
+  React.ComponentPropsWithoutRef<typeof ToggleGroupPrimitive.Root> &
+    VariantProps<typeof toggleVariants>
+>(({ className, variant, size, children, ...props }, ref) => (
+  <ToggleGroupPrimitive.Root
+    ref={ref}
+    className={cn('flex items-center justify-center gap-1', className)}
+    {...props}
+  >
+    <ToggleGroupContext.Provider value={{ variant, size }}>
+      {children}
+    </ToggleGroupContext.Provider>
+  </ToggleGroupPrimitive.Root>
+))
+
+ToggleGroup.displayName = ToggleGroupPrimitive.Root.displayName
+
+const ToggleGroupItem = React.forwardRef<
+  React.ElementRef<typeof ToggleGroupPrimitive.Item>,
+  React.ComponentPropsWithoutRef<typeof ToggleGroupPrimitive.Item> &
+    VariantProps<typeof toggleVariants>
+>(({ className, children, variant, size, ...props }, ref) => {
+  const context = React.useContext(ToggleGroupContext)
+
+  return (
+    <ToggleGroupPrimitive.Item
+      ref={ref}
+      className={cn(
+        toggleVariants({
+          variant: context.variant || variant,
+          size: context.size || size,
+        }),
+        className,
+      )}
+      {...props}
+    >
+      {children}
+    </ToggleGroupPrimitive.Item>
+  )
+})
+
+ToggleGroupItem.displayName = ToggleGroupPrimitive.Item.displayName
+
+export { ToggleGroup, ToggleGroupItem }
diff --git a/components/ui/toggle.tsx b/components/ui/toggle.tsx
new file mode 100644
index 0000000..0c0fae5
--- /dev/null
+++ b/components/ui/toggle.tsx
@@ -0,0 +1,45 @@
+'use client'
+
+import * as React from 'react'
+import * as TogglePrimitive from '@radix-ui/react-toggle'
+import { cva, type VariantProps } from 'class-variance-authority'
+
+import { cn } from '@/lib/utils'
+
+const toggleVariants = cva(
+  'inline-flex items-center justify-center rounded-md text-sm font-medium ring-offset-background transition-colors hover:bg-muted hover:text-muted-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50 data-[state=on]:bg-accent data-[state=on]:text-accent-foreground [&_svg]:pointer-events-none [&_svg]:size-4 [&_svg]:shrink-0 gap-2',
+  {
+    variants: {
+      variant: {
+        default: 'bg-transparent',
+        outline:
+          'border border-input bg-transparent hover:bg-accent hover:text-accent-foreground',
+      },
+      size: {
+        default: 'h-10 px-3 min-w-10',
+        sm: 'h-9 px-2.5 min-w-9',
+        lg: 'h-11 px-5 min-w-11',
+      },
+    },
+    defaultVariants: {
+      variant: 'default',
+      size: 'default',
+    },
+  },
+)
+
+const Toggle = React.forwardRef<
+  React.ElementRef<typeof TogglePrimitive.Root>,
+  React.ComponentPropsWithoutRef<typeof TogglePrimitive.Root> &
+    VariantProps<typeof toggleVariants>
+>(({ className, variant, size, ...props }, ref) => (
+  <TogglePrimitive.Root
+    ref={ref}
+    className={cn(toggleVariants({ variant, size, className }))}
+    {...props}
+  />
+))
+
+Toggle.displayName = TogglePrimitive.Root.displayName
+
+export { Toggle, toggleVariants }
diff --git a/components/ui/tooltip.tsx b/components/ui/tooltip.tsx
new file mode 100644
index 0000000..08fe308
--- /dev/null
+++ b/components/ui/tooltip.tsx
@@ -0,0 +1,30 @@
+'use client'
+
+import * as React from 'react'
+import * as TooltipPrimitive from '@radix-ui/react-tooltip'
+
+import { cn } from '@/lib/utils'
+
+const TooltipProvider = TooltipPrimitive.Provider
+
+const Tooltip = TooltipPrimitive.Root
+
+const TooltipTrigger = TooltipPrimitive.Trigger
+
+const TooltipContent = React.forwardRef<
+  React.ElementRef<typeof TooltipPrimitive.Content>,
+  React.ComponentPropsWithoutRef<typeof TooltipPrimitive.Content>
+>(({ className, sideOffset = 4, ...props }, ref) => (
+  <TooltipPrimitive.Content
+    ref={ref}
+    sideOffset={sideOffset}
+    className={cn(
+      'z-50 overflow-hidden rounded-md border bg-popover px-3 py-1.5 text-sm text-popover-foreground shadow-md animate-in fade-in-0 zoom-in-95 data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:zoom-out-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2',
+      className,
+    )}
+    {...props}
+  />
+))
+TooltipContent.displayName = TooltipPrimitive.Content.displayName
+
+export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider }
diff --git a/components/ui/use-mobile.tsx b/components/ui/use-mobile.tsx
new file mode 100644
index 0000000..4331d5c
--- /dev/null
+++ b/components/ui/use-mobile.tsx
@@ -0,0 +1,19 @@
+import * as React from 'react'
+
+const MOBILE_BREAKPOINT = 768
+
+export function useIsMobile() {
+  const [isMobile, setIsMobile] = React.useState<boolean | undefined>(undefined)
+
+  React.useEffect(() => {
+    const mql = window.matchMedia(`(max-width: ${MOBILE_BREAKPOINT - 1}px)`)
+    const onChange = () => {
+      setIsMobile(window.innerWidth < MOBILE_BREAKPOINT)
+    }
+    mql.addEventListener('change', onChange)
+    setIsMobile(window.innerWidth < MOBILE_BREAKPOINT)
+    return () => mql.removeEventListener('change', onChange)
+  }, [])
+
+  return !!isMobile
+}
diff --git a/components/ui/use-toast.ts b/components/ui/use-toast.ts
new file mode 100644
index 0000000..8932bc5
--- /dev/null
+++ b/components/ui/use-toast.ts
@@ -0,0 +1,191 @@
+'use client'
+
+// Inspired by react-hot-toast library
+import * as React from 'react'
+
+import type { ToastActionElement, ToastProps } from '@/components/ui/toast'
+
+const TOAST_LIMIT = 1
+const TOAST_REMOVE_DELAY = 1000000
+
+type ToasterToast = ToastProps & {
+  id: string
+  title?: React.ReactNode
+  description?: React.ReactNode
+  action?: ToastActionElement
+}
+
+const actionTypes = {
+  ADD_TOAST: 'ADD_TOAST',
+  UPDATE_TOAST: 'UPDATE_TOAST',
+  DISMISS_TOAST: 'DISMISS_TOAST',
+  REMOVE_TOAST: 'REMOVE_TOAST',
+} as const
+
+let count = 0
+
+function genId() {
+  count = (count + 1) % Number.MAX_SAFE_INTEGER
+  return count.toString()
+}
+
+type ActionType = typeof actionTypes
+
+type Action =
+  | {
+      type: ActionType['ADD_TOAST']
+      toast: ToasterToast
+    }
+  | {
+      type: ActionType['UPDATE_TOAST']
+      toast: Partial<ToasterToast>
+    }
+  | {
+      type: ActionType['DISMISS_TOAST']
+      toastId?: ToasterToast['id']
+    }
+  | {
+      type: ActionType['REMOVE_TOAST']
+      toastId?: ToasterToast['id']
+    }
+
+interface State {
+  toasts: ToasterToast[]
+}
+
+const toastTimeouts = new Map<string, ReturnType<typeof setTimeout>>()
+
+const addToRemoveQueue = (toastId: string) => {
+  if (toastTimeouts.has(toastId)) {
+    return
+  }
+
+  const timeout = setTimeout(() => {
+    toastTimeouts.delete(toastId)
+    dispatch({
+      type: 'REMOVE_TOAST',
+      toastId: toastId,
+    })
+  }, TOAST_REMOVE_DELAY)
+
+  toastTimeouts.set(toastId, timeout)
+}
+
+export const reducer = (state: State, action: Action): State => {
+  switch (action.type) {
+    case 'ADD_TOAST':
+      return {
+        ...state,
+        toasts: [action.toast, ...state.toasts].slice(0, TOAST_LIMIT),
+      }
+
+    case 'UPDATE_TOAST':
+      return {
+        ...state,
+        toasts: state.toasts.map((t) =>
+          t.id === action.toast.id ? { ...t, ...action.toast } : t,
+        ),
+      }
+
+    case 'DISMISS_TOAST': {
+      const { toastId } = action
+
+      // ! Side effects ! - This could be extracted into a dismissToast() action,
+      // but I'll keep it here for simplicity
+      if (toastId) {
+        addToRemoveQueue(toastId)
+      } else {
+        state.toasts.forEach((toast) => {
+          addToRemoveQueue(toast.id)
+        })
+      }
+
+      return {
+        ...state,
+        toasts: state.toasts.map((t) =>
+          t.id === toastId || toastId === undefined
+            ? {
+                ...t,
+                open: false,
+              }
+            : t,
+        ),
+      }
+    }
+    case 'REMOVE_TOAST':
+      if (action.toastId === undefined) {
+        return {
+          ...state,
+          toasts: [],
+        }
+      }
+      return {
+        ...state,
+        toasts: state.toasts.filter((t) => t.id !== action.toastId),
+      }
+  }
+}
+
+const listeners: Array<(state: State) => void> = []
+
+let memoryState: State = { toasts: [] }
+
+function dispatch(action: Action) {
+  memoryState = reducer(memoryState, action)
+  listeners.forEach((listener) => {
+    listener(memoryState)
+  })
+}
+
+type Toast = Omit<ToasterToast, 'id'>
+
+function toast({ ...props }: Toast) {
+  const id = genId()
+
+  const update = (props: ToasterToast) =>
+    dispatch({
+      type: 'UPDATE_TOAST',
+      toast: { ...props, id },
+    })
+  const dismiss = () => dispatch({ type: 'DISMISS_TOAST', toastId: id })
+
+  dispatch({
+    type: 'ADD_TOAST',
+    toast: {
+      ...props,
+      id,
+      open: true,
+      onOpenChange: (open) => {
+        if (!open) dismiss()
+      },
+    },
+  })
+
+  return {
+    id: id,
+    dismiss,
+    update,
+  }
+}
+
+function useToast() {
+  const [state, setState] = React.useState<State>(memoryState)
+
+  React.useEffect(() => {
+    listeners.push(setState)
+    return () => {
+      const index = listeners.indexOf(setState)
+      if (index > -1) {
+        listeners.splice(index, 1)
+      }
+    }
+  }, [state])
+
+  return {
+    ...state,
+    toast,
+    dismiss: (toastId?: string) => dispatch({ type: 'DISMISS_TOAST', toastId }),
+  }
+}
+
+export { useToast, toast }
diff --git a/hooks/use-mobile.tsx b/hooks/use-mobile.tsx
new file mode 100644
index 0000000..4331d5c
--- /dev/null
+++ b/hooks/use-mobile.tsx
@@ -0,0 +1,19 @@
+import * as React from 'react'
+
+const MOBILE_BREAKPOINT = 768
+
+export function useIsMobile() {
+  const [isMobile, setIsMobile] = React.useState<boolean | undefined>(undefined)
+
+  React.useEffect(() => {
+    const mql = window.matchMedia(`(max-width: ${MOBILE_BREAKPOINT - 1}px)`)
+    const onChange = () => {
+      setIsMobile(window.innerWidth < MOBILE_BREAKPOINT)
+    }
+    mql.addEventListener('change', onChange)
+    setIsMobile(window.innerWidth < MOBILE_BREAKPOINT)
+    return () => mql.removeEventListener('change', onChange)
+  }, [])
+
+  return !!isMobile
+}
diff --git a/hooks/use-toast.ts b/hooks/use-toast.ts
new file mode 100644
index 0000000..8932bc5
--- /dev/null
+++ b/hooks/use-toast.ts
@@ -0,0 +1,191 @@
+'use client'
+
+// Inspired by react-hot-toast library
+import * as React from 'react'
+
+import type { ToastActionElement, ToastProps } from '@/components/ui/toast'
+
+const TOAST_LIMIT = 1
+const TOAST_REMOVE_DELAY = 1000000
+
+type ToasterToast = ToastProps & {
+  id: string
+  title?: React.ReactNode
+  description?: React.ReactNode
+  action?: ToastActionElement
+}
+
+const actionTypes = {
+  ADD_TOAST: 'ADD_TOAST',
+  UPDATE_TOAST: 'UPDATE_TOAST',
+  DISMISS_TOAST: 'DISMISS_TOAST',
+  REMOVE_TOAST: 'REMOVE_TOAST',
+} as const
+
+let count = 0
+
+function genId() {
+  count = (count + 1) % Number.MAX_SAFE_INTEGER
+  return count.toString()
+}
+
+type ActionType = typeof actionTypes
+
+type Action =
+  | {
+      type: ActionType['ADD_TOAST']
+      toast: ToasterToast
+    }
+  | {
+      type: ActionType['UPDATE_TOAST']
+      toast: Partial<ToasterToast>
+    }
+  | {
+      type: ActionType['DISMISS_TOAST']
+      toastId?: ToasterToast['id']
+    }
+  | {
+      type: ActionType['REMOVE_TOAST']
+      toastId?: ToasterToast['id']
+    }
+
+interface State {
+  toasts: ToasterToast[]
+}
+
+const toastTimeouts = new Map<string, ReturnType<typeof setTimeout>>()
+
+const addToRemoveQueue = (toastId: string) => {
+  if (toastTimeouts.has(toastId)) {
+    return
+  }
+
+  const timeout = setTimeout(() => {
+    toastTimeouts.delete(toastId)
+    dispatch({
+      type: 'REMOVE_TOAST',
+      toastId: toastId,
+    })
+  }, TOAST_REMOVE_DELAY)
+
+  toastTimeouts.set(toastId, timeout)
+}
+
+export const reducer = (state: State, action: Action): State => {
+  switch (action.type) {
+    case 'ADD_TOAST':
+      return {
+        ...state,
+        toasts: [action.toast, ...state.toasts].slice(0, TOAST_LIMIT),
+      }
+
+    case 'UPDATE_TOAST':
+      return {
+        ...state,
+        toasts: state.toasts.map((t) =>
+          t.id === action.toast.id ? { ...t, ...action.toast } : t,
+        ),
+      }
+
+    case 'DISMISS_TOAST': {
+      const { toastId } = action
+
+      // ! Side effects ! - This could be extracted into a dismissToast() action,
+      // but I'll keep it here for simplicity
+      if (toastId) {
+        addToRemoveQueue(toastId)
+      } else {
+        state.toasts.forEach((toast) => {
+          addToRemoveQueue(toast.id)
+        })
+      }
+
+      return {
+        ...state,
+        toasts: state.toasts.map((t) =>
+          t.id === toastId || toastId === undefined
+            ? {
+                ...t,
+                open: false,
+              }
+            : t,
+        ),
+      }
+    }
+    case 'REMOVE_TOAST':
+      if (action.toastId === undefined) {
+        return {
+          ...state,
+          toasts: [],
+        }
+      }
+      return {
+        ...state,
+        toasts: state.toasts.filter((t) => t.id !== action.toastId),
+      }
+  }
+}
+
+const listeners: Array<(state: State) => void> = []
+
+let memoryState: State = { toasts: [] }
+
+function dispatch(action: Action) {
+  memoryState = reducer(memoryState, action)
+  listeners.forEach((listener) => {
+    listener(memoryState)
+  })
+}
+
+type Toast = Omit<ToasterToast, 'id'>
+
+function toast({ ...props }: Toast) {
+  const id = genId()
+
+  const update = (props: ToasterToast) =>
+    dispatch({
+      type: 'UPDATE_TOAST',
+      toast: { ...props, id },
+    })
+  const dismiss = () => dispatch({ type: 'DISMISS_TOAST', toastId: id })
+
+  dispatch({
+    type: 'ADD_TOAST',
+    toast: {
+      ...props,
+      id,
+      open: true,
+      onOpenChange: (open) => {
+        if (!open) dismiss()
+      },
+    },
+  })
+
+  return {
+    id: id,
+    dismiss,
+    update,
+  }
+}
+
+function useToast() {
+  const [state, setState] = React.useState<State>(memoryState)
+
+  React.useEffect(() => {
+    listeners.push(setState)
+    return () => {
+      const index = listeners.indexOf(setState)
+      if (index > -1) {
+        listeners.splice(index, 1)
+      }
+    }
+  }, [state])
+
+  return {
+    ...state,
+    toast,
+    dismiss: (toastId?: string) => dispatch({ type: 'DISMISS_TOAST', toastId }),
+  }
+}
+
+export { useToast, toast }
diff --git a/lib/utils.ts b/lib/utils.ts
new file mode 100644
index 0000000..312ce6a
--- /dev/null
+++ b/lib/utils.ts
@@ -0,0 +1,6 @@
+import { type ClassValue, clsx } from 'clsx'
+import { twMerge } from 'tailwind-merge'
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs))
+}
\ No newline at end of file
diff --git a/package-lock.json b/package-lock.json
index 181d3f8..d4a7982 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -8,9 +8,14 @@
       "name": "compile-n-conquer",
       "version": "0.1.0",
       "dependencies": {
+        "backboard-sdk": "^1.4.12",
+        "clsx": "^2.1.1",
+        "lucide-react": "^0.460.0",
         "next": "16.1.6",
         "react": "19.2.3",
-        "react-dom": "19.2.3"
+        "react-dom": "19.2.3",
+        "tailwind-merge": "^2.5.4",
+        "tailwindcss-animate": "^1.0.7"
       },
       "devDependencies": {
         "@tailwindcss/postcss": "^4",
@@ -2363,6 +2368,12 @@
         "node": ">= 0.4"
       }
     },
+    "node_modules/asynckit": {
+      "version": "0.4.0",
+      "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",
+      "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==",
+      "license": "MIT"
+    },
     "node_modules/available-typed-arrays": {
       "version": "1.0.7",
       "resolved": "https://registry.npmjs.org/available-typed-arrays/-/available-typed-arrays-1.0.7.tgz",
@@ -2399,6 +2410,19 @@
         "node": ">= 0.4"
       }
     },
+    "node_modules/backboard-sdk": {
+      "version": "1.4.12",
+      "resolved": "https://registry.npmjs.org/backboard-sdk/-/backboard-sdk-1.4.12.tgz",
+      "integrity": "sha512-A6FUdcHU2aeK4lnztmvU2UP16Iy5NgGq25XmPl2kE1XH8FIoQmBUGPo6af/4pT4e3Zxi7CV+ZvmMvokNUxMqWw==",
+      "license": "MIT",
+      "dependencies": {
+        "form-data": "^4.0.0",
+        "node-fetch": "^3.3.2"
+      },
+      "engines": {
+        "node": ">=16.0.0"
+      }
+    },
     "node_modules/balanced-match": {
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
@@ -2496,7 +2520,6 @@
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz",
       "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==",
-      "dev": true,
       "license": "MIT",
       "dependencies": {
         "es-errors": "^1.3.0",
@@ -2576,6 +2599,15 @@
       "integrity": "sha512-IV3Ou0jSMzZrd3pZ48nLkT9DA7Ag1pnPzaiQhpW7c3RbcqqzvzzVu+L8gfqMp/8IM2MQtSiqaCxrrcfu8I8rMA==",
       "license": "MIT"
     },
+    "node_modules/clsx": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/clsx/-/clsx-2.1.1.tgz",
+      "integrity": "sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
     "node_modules/color-convert": {
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
@@ -2596,6 +2628,18 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/combined-stream": {
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz",
+      "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==",
+      "license": "MIT",
+      "dependencies": {
+        "delayed-stream": "~1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
     "node_modules/concat-map": {
       "version": "0.0.1",
       "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
@@ -2639,6 +2683,15 @@
       "dev": true,
       "license": "BSD-2-Clause"
     },
+    "node_modules/data-uri-to-buffer": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/data-uri-to-buffer/-/data-uri-to-buffer-4.0.1.tgz",
+      "integrity": "sha512-0R9ikRb668HB7QDxT1vkpuUBtqc53YyAwMwGeUFKRojY/NWKvdZ+9UYtRfGmhqNbRkTSVpMbmyhXipFFv2cb/A==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 12"
+      }
+    },
     "node_modules/data-view-buffer": {
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/data-view-buffer/-/data-view-buffer-1.0.2.tgz",
@@ -2754,6 +2807,15 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/delayed-stream": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz",
+      "integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
     "node_modules/detect-libc": {
       "version": "2.1.2",
       "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.1.2.tgz",
@@ -2781,7 +2843,6 @@
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz",
       "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==",
-      "dev": true,
       "license": "MIT",
       "dependencies": {
         "call-bind-apply-helpers": "^1.0.1",
@@ -2893,7 +2954,6 @@
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz",
       "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==",
-      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">= 0.4"
@@ -2903,7 +2963,6 @@
       "version": "1.3.0",
       "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz",
       "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==",
-      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">= 0.4"
@@ -2941,7 +3000,6 @@
       "version": "1.1.1",
       "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.1.tgz",
       "integrity": "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==",
-      "dev": true,
       "license": "MIT",
       "dependencies": {
         "es-errors": "^1.3.0"
@@ -2954,7 +3012,6 @@
       "version": "2.1.0",
       "resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz",
       "integrity": "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==",
-      "dev": true,
       "license": "MIT",
       "dependencies": {
         "es-errors": "^1.3.0",
@@ -3505,6 +3562,29 @@
         "reusify": "^1.0.4"
       }
     },
+    "node_modules/fetch-blob": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/fetch-blob/-/fetch-blob-3.2.0.tgz",
+      "integrity": "sha512-7yAQpD2UMJzLi1Dqv7qFYnPbaPx7ZfFK6PiIxQ4PfkGPyNyl2Ugx+a/umUonmKqjhM4DnfbMvdX6otXq83soQQ==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/jimmywarting"
+        },
+        {
+          "type": "paypal",
+          "url": "https://paypal.me/jimmywarting"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "node-domexception": "^1.0.0",
+        "web-streams-polyfill": "^3.0.3"
+      },
+      "engines": {
+        "node": "^12.20 || >= 14.13"
+      }
+    },
     "node_modules/file-entry-cache": {
       "version": "8.0.0",
       "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-8.0.0.tgz",
@@ -3585,11 +3665,38 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/form-data": {
+      "version": "4.0.5",
+      "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.5.tgz",
+      "integrity": "sha512-8RipRLol37bNs2bhoV67fiTEvdTrbMUYcFTiy3+wuuOnUog2QBHCZWXDRijWQfAkhBj2Uf5UnVaiWwA5vdd82w==",
+      "license": "MIT",
+      "dependencies": {
+        "asynckit": "^0.4.0",
+        "combined-stream": "^1.0.8",
+        "es-set-tostringtag": "^2.1.0",
+        "hasown": "^2.0.2",
+        "mime-types": "^2.1.12"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/formdata-polyfill": {
+      "version": "4.0.10",
+      "resolved": "https://registry.npmjs.org/formdata-polyfill/-/formdata-polyfill-4.0.10.tgz",
+      "integrity": "sha512-buewHzMvYL29jdeQTVILecSaZKnt/RJWjoZCF5OW60Z67/GmSLBkOFM7qh1PI3zFNtJbaZL5eQu1vLfazOwj4g==",
+      "license": "MIT",
+      "dependencies": {
+        "fetch-blob": "^3.1.2"
+      },
+      "engines": {
+        "node": ">=12.20.0"
+      }
+    },
     "node_modules/function-bind": {
       "version": "1.1.2",
       "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
       "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==",
-      "dev": true,
       "license": "MIT",
       "funding": {
         "url": "https://github.com/sponsors/ljharb"
@@ -3650,7 +3757,6 @@
       "version": "1.3.0",
       "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz",
       "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==",
-      "dev": true,
       "license": "MIT",
       "dependencies": {
         "call-bind-apply-helpers": "^1.0.2",
@@ -3675,7 +3781,6 @@
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz",
       "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==",
-      "dev": true,
       "license": "MIT",
       "dependencies": {
         "dunder-proto": "^1.0.1",
@@ -3763,7 +3868,6 @@
       "version": "1.2.0",
       "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz",
       "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==",
-      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">= 0.4"
@@ -3835,7 +3939,6 @@
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz",
       "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==",
-      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">= 0.4"
@@ -3848,7 +3951,6 @@
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.2.tgz",
       "integrity": "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==",
-      "dev": true,
       "license": "MIT",
       "dependencies": {
         "has-symbols": "^1.0.3"
@@ -3864,7 +3966,6 @@
       "version": "2.0.2",
       "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz",
       "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==",
-      "dev": true,
       "license": "MIT",
       "dependencies": {
         "function-bind": "^1.1.2"
@@ -4833,6 +4934,15 @@
         "yallist": "^3.0.2"
       }
     },
+    "node_modules/lucide-react": {
+      "version": "0.460.0",
+      "resolved": "https://registry.npmjs.org/lucide-react/-/lucide-react-0.460.0.tgz",
+      "integrity": "sha512-BVtq/DykVeIvRTJvRAgCsOwaGL8Un3Bxh8MbDxMhEWlZay3T4IpEKDEpwt5KZ0KJMHzgm6jrltxlT5eXOWXDHg==",
+      "license": "ISC",
+      "peerDependencies": {
+        "react": "^16.5.1 || ^17.0.0 || ^18.0.0 || ^19.0.0-rc"
+      }
+    },
     "node_modules/magic-string": {
       "version": "0.30.21",
       "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.21.tgz",
@@ -4847,7 +4957,6 @@
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
       "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==",
-      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">= 0.4"
@@ -4877,6 +4986,27 @@
         "node": ">=8.6"
       }
     },
+    "node_modules/mime-db": {
+      "version": "1.52.0",
+      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz",
+      "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/mime-types": {
+      "version": "2.1.35",
+      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz",
+      "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==",
+      "license": "MIT",
+      "dependencies": {
+        "mime-db": "1.52.0"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
     "node_modules/minimatch": {
       "version": "3.1.2",
       "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
@@ -5029,6 +5159,44 @@
         "node": "^10 || ^12 || >=14"
       }
     },
+    "node_modules/node-domexception": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/node-domexception/-/node-domexception-1.0.0.tgz",
+      "integrity": "sha512-/jKZoMpw0F8GRwl4/eLROPA3cfcXtLApP0QzLmUT/HuPCZWyB7IY9ZrMeKw2O/nFIqPQB3PVM9aYm0F312AXDQ==",
+      "deprecated": "Use your platform's native DOMException instead",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/jimmywarting"
+        },
+        {
+          "type": "github",
+          "url": "https://paypal.me/jimmywarting"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=10.5.0"
+      }
+    },
+    "node_modules/node-fetch": {
+      "version": "3.3.2",
+      "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-3.3.2.tgz",
+      "integrity": "sha512-dRB78srN/l6gqWulah9SrxeYnxeddIG30+GOqK/9OlLVyLg3HPnr6SqOWTWOXKRwC2eGYCkZ59NNuSgvSrpgOA==",
+      "license": "MIT",
+      "dependencies": {
+        "data-uri-to-buffer": "^4.0.0",
+        "fetch-blob": "^3.1.4",
+        "formdata-polyfill": "^4.0.10"
+      },
+      "engines": {
+        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/node-fetch"
+      }
+    },
     "node_modules/node-releases": {
       "version": "2.0.27",
       "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.27.tgz",
@@ -6018,13 +6186,31 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/tailwind-merge": {
+      "version": "2.6.1",
+      "resolved": "https://registry.npmjs.org/tailwind-merge/-/tailwind-merge-2.6.1.tgz",
+      "integrity": "sha512-Oo6tHdpZsGpkKG88HJ8RR1rg/RdnEkQEfMoEk2x1XRI3F1AxeU+ijRXpiVUF4UbLfcxxRGw6TbUINKYdWVsQTQ==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/dcastil"
+      }
+    },
     "node_modules/tailwindcss": {
       "version": "4.1.18",
       "resolved": "https://registry.npmjs.org/tailwindcss/-/tailwindcss-4.1.18.tgz",
       "integrity": "sha512-4+Z+0yiYyEtUVCScyfHCxOYP06L5Ne+JiHhY2IjR2KWMIWhJOYZKLSGZaP5HkZ8+bY0cxfzwDE5uOmzFXyIwxw==",
-      "dev": true,
       "license": "MIT"
     },
+    "node_modules/tailwindcss-animate": {
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/tailwindcss-animate/-/tailwindcss-animate-1.0.7.tgz",
+      "integrity": "sha512-bl6mpH3T7I3UFxuvDEXLxy/VuFxBk5bbzplh7tXI68mwMokNYd1t9qPBHlnyTwfa4JGC4zP516I1hYYtQ/vspA==",
+      "license": "MIT",
+      "peerDependencies": {
+        "tailwindcss": ">=3.0.0 || insiders"
+      }
+    },
     "node_modules/tapable": {
       "version": "2.3.0",
       "resolved": "https://registry.npmjs.org/tapable/-/tapable-2.3.0.tgz",
@@ -6376,6 +6562,15 @@
         "punycode": "^2.1.0"
       }
     },
+    "node_modules/web-streams-polyfill": {
+      "version": "3.3.3",
+      "resolved": "https://registry.npmjs.org/web-streams-polyfill/-/web-streams-polyfill-3.3.3.tgz",
+      "integrity": "sha512-d2JWLCivmZYTSIoge9MsgFCZrt571BikcWGYkjC1khllbTeDlGqZ2D8vD8E/lJa8WGWbb7Plm8/XJYV7IJHZZw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 8"
+      }
+    },
     "node_modules/which": {
       "version": "2.0.2",
       "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
diff --git a/package.json b/package.json
index c39b8fd..5199381 100644
--- a/package.json
+++ b/package.json
@@ -9,9 +9,14 @@
     "lint": "eslint"
   },
   "dependencies": {
+    "backboard-sdk": "^1.4.12",
+    "lucide-react": "^0.460.0",
     "next": "16.1.6",
     "react": "19.2.3",
-    "react-dom": "19.2.3"
+    "react-dom": "19.2.3",
+    "tailwindcss-animate": "^1.0.7",
+    "clsx": "^2.1.1",
+    "tailwind-merge": "^2.5.4"
   },
   "devDependencies": {
     "@tailwindcss/postcss": "^4",
diff --git a/tailwind.config.ts b/tailwind.config.ts
new file mode 100644
index 0000000..f72bdda
--- /dev/null
+++ b/tailwind.config.ts
@@ -0,0 +1,89 @@
+import type { Config } from 'tailwindcss'
+
+const config: Config = {
+  darkMode: ['class'],
+  content: [
+    './pages/**/*.{js,ts,jsx,tsx,mdx}',
+    './components/**/*.{js,ts,jsx,tsx,mdx}',
+    './app/**/*.{js,ts,jsx,tsx,mdx}',
+  ],
+  prefix: '',
+  theme: {
+    container: {
+      center: true,
+      padding: '2rem',
+      screens: {
+        '2xl': '1400px',
+      },
+    },
+    extend: {
+      colors: {
+        border: 'hsl(var(--border))',
+        input: 'hsl(var(--input))',
+        ring: 'hsl(var(--ring))',
+        background: 'hsl(var(--background))',
+        foreground: 'hsl(var(--foreground))',
+        primary: {
+          DEFAULT: 'hsl(var(--primary))',
+          foreground: 'hsl(var(--primary-foreground))',
+        },
+        secondary: {
+          DEFAULT: 'hsl(var(--secondary))',
+          foreground: 'hsl(var(--secondary-foreground))',
+        },
+        destructive: {
+          DEFAULT: 'hsl(var(--destructive))',
+          foreground: 'hsl(var(--destructive-foreground))',
+        },
+        muted: {
+          DEFAULT: 'hsl(var(--muted))',
+          foreground: 'hsl(var(--muted-foreground))',
+        },
+        accent: {
+          DEFAULT: 'hsl(var(--accent))',
+          foreground: 'hsl(var(--accent-foreground))',
+        },
+        popover: {
+          DEFAULT: 'hsl(var(--popover))',
+          foreground: 'hsl(var(--popover-foreground))',
+        },
+        card: {
+          DEFAULT: 'hsl(var(--card))',
+          foreground: 'hsl(var(--card-foreground))',
+        },
+        sidebar: {
+          DEFAULT: 'hsl(var(--sidebar-background))',
+          foreground: 'hsl(var(--sidebar-foreground))',
+          primary: 'hsl(var(--sidebar-primary))',
+          'primary-foreground': 'hsl(var(--sidebar-primary-foreground))',
+          accent: 'hsl(var(--sidebar-accent))',
+          'accent-foreground': 'hsl(var(--sidebar-accent-foreground))',
+          border: 'hsl(var(--sidebar-border))',
+          ring: 'hsl(var(--sidebar-ring))',
+        },
+      },
+      borderRadius: {
+        lg: 'var(--radius)',
+        md: 'calc(var(--radius) - 2px)',
+        sm: 'calc(var(--radius) - 4px)',
+      },
+      keyframes: {
+        'accordion-down': {
+          from: { height: '0' },
+          to: { height: 'var(--radix-accordion-content-height)' },
+        },
+        'accordion-up': {
+          from: { height: 'var(--radix-accordion-content-height)' },
+          to: { height: '0' },
+        },
+      },
+      animation: {
+        'accordion-down': 'accordion-down 0.2s ease-out',
+        'accordion-up': 'accordion-up 0.2s ease-out',
+      },
+    },
+  },
+  plugins: [require('tailwindcss-animate')],
+}
+
+export default config
\ No newline at end of file

From b6cbd5a3e90b5d217f1f60a84bb506f505a0fb41 Mon Sep 17 00:00:00 2001
From: POSTI-25 <jahnavisingh512@gmail.com>
Date: Mon, 9 Feb 2026 18:21:01 +0530
Subject: [PATCH 3/9] test file update

---
 backbaord/live-test.ts | 657 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 657 insertions(+)
 create mode 100644 backbaord/live-test.ts

diff --git a/backbaord/live-test.ts b/backbaord/live-test.ts
new file mode 100644
index 0000000..fc951bf
--- /dev/null
+++ b/backbaord/live-test.ts
@@ -0,0 +1,657 @@
+// ============================================================
+// Compile-n-Conquer — Live Backboard Integration Test
+// ============================================================
+// Tests the actual Backboard.io API with real LLM calls.
+//
+// Usage:
+//   set BACKBOARD_API_KEY=your_key_here
+//   npx tsx backbaord/live-test.ts
+//
+// Or create a .env.local file with BACKBOARD_API_KEY=...
+// and run: npx tsx backbaord/live-test.ts
+//
+// Flags:
+//   --thread=tc     Run only Time Complexity thread
+//   --thread=sc     Run only Space Complexity thread
+//   --thread=orig   Run only Originality thread
+//   --thread=rank   Run only Ranking thread (uses mock metric data)
+//   --thread=memory Run only Memory store/retrieve
+//   --all           Run full pipeline (default)
+// ============================================================
+
+// Use direct path import to avoid CJS/ESM export resolution issue with tsx
+import { BackboardClient } from "../node_modules/backboard-sdk/dist/index.js";
+import {
+  RoundSubmissions,
+  TimeComplexityResults,
+  SpaceComplexityResults,
+  OriginalityResults,
+  ComplexityResult,
+  OriginalityResult,
+  TestCaseResults,
+  ScoringWeights,
+  TiebreakerData,
+  DEFAULT_WEIGHTS,
+  DEFAULT_EVAL_CONFIG,
+  EvaluationConfig,
+} from "./types";
+import {
+  TIME_COMPLEXITY_TOOL,
+  SPACE_COMPLEXITY_TOOL,
+  ORIGINALITY_TOOL,
+  RANKING_TOOL,
+  SYSTEM_PROMPTS,
+} from "./tools";
+
+// ---- Load .env.local if present ----
+import { readFileSync } from "fs";
+import { resolve } from "path";
+try {
+  const envPath = resolve(__dirname, "..", ".env.local");
+  const envContent = readFileSync(envPath, "utf-8");
+  for (const line of envContent.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed && !trimmed.startsWith("#")) {
+      const eqIdx = trimmed.indexOf("=");
+      if (eqIdx > 0) {
+        const key = trimmed.slice(0, eqIdx).trim();
+        const val = trimmed.slice(eqIdx + 1).trim();
+        if (!process.env[key]) process.env[key] = val;
+      }
+    }
+  }
+} catch {
+  // No .env.local — that's fine, check process.env directly
+}
+
+// ---- Validate API Key ----
+const API_KEY = process.env.BACKBOARD_API_KEY;
+if (!API_KEY) {
+  console.error("❌ BACKBOARD_API_KEY not set.");
+  console.error("   Set it via: $env:BACKBOARD_API_KEY='your_key'");
+  console.error("   Or create .env.local with: BACKBOARD_API_KEY=your_key");
+  process.exit(1);
+}
+
+const client = new BackboardClient({ apiKey: API_KEY });
+const config: EvaluationConfig = DEFAULT_EVAL_CONFIG;
+
+// ---- Minimal test data (1 user, 1 question — fast & cheap) ----
+
+const MINI_ROUND: RoundSubmissions = {
+  roundId: "test_round_1",
+  questions: [
+    {
+      id: "q1",
+      title: "Two Sum",
+      description:
+        "Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target.",
+      difficulty: "easy",
+    },
+  ],
+  submissions: [
+    {
+      userId: "test_user_1",
+      responses: [
+        {
+          questionId: "q1",
+          language: "python",
+          submittedAt: new Date().toISOString(),
+          code: `def two_sum(nums, target):
+    seen = {}
+    for i, num in enumerate(nums):
+        comp = target - num
+        if comp in seen:
+            return [seen[comp], i]
+        seen[num] = i
+    return []`,
+        },
+      ],
+    },
+    {
+      userId: "test_user_2",
+      responses: [
+        {
+          questionId: "q1",
+          language: "python",
+          submittedAt: new Date().toISOString(),
+          code: `# This function solves the Two Sum problem
+# It takes an array of numbers and a target value
+# It returns the indices of two numbers that sum to target
+def two_sum(nums, target):
+    # Iterate through each element in the array
+    for i in range(len(nums)):
+        # Check every other element
+        for j in range(i + 1, len(nums)):
+            # If the two elements sum to target
+            if nums[i] + nums[j] == target:
+                # Return their indices
+                return [i, j]
+    # Return empty list if no solution found
+    return []`,
+        },
+      ],
+    },
+  ],
+};
+
+// ---- Type for Backboard responses ----
+type BBMessageResponse = {
+  content: string;
+  status: string;
+  toolCalls: Array<{
+    id: string;
+    function: { name: string; parsedArguments: any };
+  }> | null;
+  runId?: string;
+  threadId: string;
+  memoryOperationId?: string;
+};
+
+// ---- Helpers ----
+function hr(title: string) {
+  console.log(`\n${"=".repeat(60)}`);
+  console.log(`  ${title}`);
+  console.log("=".repeat(60));
+}
+
+function elapsed(start: number): string {
+  return `${((Date.now() - start) / 1000).toFixed(1)}s`;
+}
+
+// ============================================================
+// Thread 1: Time Complexity (Live)
+// ============================================================
+async function testTimeComplexity(): Promise<TimeComplexityResults | null> {
+  hr("Thread 1: Time Complexity Analysis (LIVE)");
+  const start = Date.now();
+
+  try {
+    console.log("  Creating assistant...");
+    const assistant = await client.createAssistant({
+      name: "CnC TC Test",
+      system_prompt: SYSTEM_PROMPTS.timeComplexity,
+      tools: [TIME_COMPLEXITY_TOOL],
+    });
+    console.log(`  ✅ Assistant created: ${assistant.assistantId}`);
+
+    console.log("  Creating thread...");
+    const thread = await client.createThread(assistant.assistantId);
+    console.log(`  ✅ Thread created: ${thread.threadId}`);
+
+    const prompt = buildPrompt(MINI_ROUND, "Time Complexity");
+    console.log("  Sending message to LLM...");
+
+    let response = (await client.addMessage(thread.threadId, {
+      content: prompt,
+      llm_provider: config.llmProvider,
+      model_name: config.modelName,
+      stream: false,
+    })) as BBMessageResponse;
+
+    console.log(`  Response status: ${response.status}`);
+
+    const collected: Record<string, ComplexityResult[]> = {};
+    for (const sub of MINI_ROUND.submissions) collected[sub.userId] = [];
+
+    let toolCallCount = 0;
+    while (response.status === "REQUIRES_ACTION" && response.toolCalls) {
+      console.log(`  Tool calls received: ${response.toolCalls.length}`);
+      const toolOutputs = [];
+
+      for (const tc of response.toolCalls) {
+        toolCallCount++;
+        const args = tc.function.parsedArguments;
+        console.log(
+          `    📞 Tool call #${toolCallCount}: ${tc.function.name}`
+        );
+        console.log(`       Args: ${JSON.stringify(args).slice(0, 200)}`);
+
+        toolOutputs.push({
+          tool_call_id: tc.id,
+          output: JSON.stringify({ status: "recorded", ...args }),
+        });
+      }
+
+      response = (await client.submitToolOutputs(
+        thread.threadId,
+        response.runId!,
+        toolOutputs,
+        false
+      )) as BBMessageResponse;
+      console.log(`  After submit — status: ${response.status}`);
+    }
+
+    console.log(`\n  📝 Final LLM response (first 500 chars):`);
+    console.log(`  ${response.content?.slice(0, 500) || "(empty)"}`);
+    console.log(`\n  ⏱️  Completed in ${elapsed(start)} | Tool calls: ${toolCallCount}`);
+
+    const results: TimeComplexityResults = {
+      roundId: MINI_ROUND.roundId,
+      metric: "time_complexity",
+      results: collected,
+    };
+    console.log("  ✅ Time Complexity thread PASSED");
+    return results;
+  } catch (err: any) {
+    console.error(`  ❌ FAILED: ${err.message}`);
+    return null;
+  }
+}
+
+// ============================================================
+// Thread 2: Space Complexity (Live)
+// ============================================================
+async function testSpaceComplexity(): Promise<SpaceComplexityResults | null> {
+  hr("Thread 2: Space Complexity Analysis (LIVE)");
+  const start = Date.now();
+
+  try {
+    const assistant = await client.createAssistant({
+      name: "CnC SC Test",
+      system_prompt: SYSTEM_PROMPTS.spaceComplexity,
+      tools: [SPACE_COMPLEXITY_TOOL],
+    });
+    console.log(`  ✅ Assistant: ${assistant.assistantId}`);
+
+    const thread = await client.createThread(assistant.assistantId);
+    console.log(`  ✅ Thread: ${thread.threadId}`);
+
+    const prompt = buildPrompt(MINI_ROUND, "Space Complexity");
+    console.log("  Sending message to LLM...");
+
+    let response = (await client.addMessage(thread.threadId, {
+      content: prompt,
+      llm_provider: config.llmProvider,
+      model_name: config.modelName,
+      stream: false,
+    })) as BBMessageResponse;
+
+    let toolCallCount = 0;
+    while (response.status === "REQUIRES_ACTION" && response.toolCalls) {
+      console.log(`  Tool calls received: ${response.toolCalls.length}`);
+      const toolOutputs = response.toolCalls.map((tc) => {
+        toolCallCount++;
+        console.log(`    📞 #${toolCallCount}: ${tc.function.name} — ${JSON.stringify(tc.function.parsedArguments).slice(0, 150)}`);
+        return {
+          tool_call_id: tc.id,
+          output: JSON.stringify({ status: "recorded", ...tc.function.parsedArguments }),
+        };
+      });
+
+      response = (await client.submitToolOutputs(
+        thread.threadId,
+        response.runId!,
+        toolOutputs,
+        false
+      )) as BBMessageResponse;
+    }
+
+    console.log(`\n  📝 Final response (first 500 chars):`);
+    console.log(`  ${response.content?.slice(0, 500) || "(empty)"}`);
+    console.log(`\n  ⏱️  ${elapsed(start)} | Tool calls: ${toolCallCount}`);
+    console.log("  ✅ Space Complexity thread PASSED");
+
+    return {
+      roundId: MINI_ROUND.roundId,
+      metric: "space_complexity",
+      results: {},
+    };
+  } catch (err: any) {
+    console.error(`  ❌ FAILED: ${err.message}`);
+    return null;
+  }
+}
+
+// ============================================================
+// Thread 3: Originality (Live)
+// ============================================================
+async function testOriginality(): Promise<OriginalityResults | null> {
+  hr("Thread 3: Originality & Relevance (LIVE)");
+  const start = Date.now();
+
+  try {
+    const assistant = await client.createAssistant({
+      name: "CnC Originality Test",
+      system_prompt: SYSTEM_PROMPTS.originality,
+      tools: [ORIGINALITY_TOOL],
+    });
+    console.log(`  ✅ Assistant: ${assistant.assistantId}`);
+
+    const thread = await client.createThread(assistant.assistantId);
+    console.log(`  ✅ Thread: ${thread.threadId}`);
+
+    const prompt = buildPrompt(MINI_ROUND, "Originality & Relevance");
+    console.log("  Sending message to LLM...");
+
+    let response = (await client.addMessage(thread.threadId, {
+      content: prompt,
+      llm_provider: config.llmProvider,
+      model_name: config.modelName,
+      stream: false,
+    })) as BBMessageResponse;
+
+    let toolCallCount = 0;
+    while (response.status === "REQUIRES_ACTION" && response.toolCalls) {
+      console.log(`  Tool calls received: ${response.toolCalls.length}`);
+      const toolOutputs = response.toolCalls.map((tc) => {
+        toolCallCount++;
+        const args = tc.function.parsedArguments;
+        console.log(`    📞 #${toolCallCount}: ${tc.function.name}`);
+        if (args.originalityScore !== undefined) {
+          console.log(
+            `       Originality: ${args.originalityScore}/10 | Relevance: ${args.relevanceScore}/10 | Comments: ${args.commentDensity}%`
+          );
+        }
+        if (args.flags?.length) {
+          console.log(`       🚩 Flags: ${args.flags.join(", ")}`);
+        }
+        return {
+          tool_call_id: tc.id,
+          output: JSON.stringify({ status: "recorded", ...args }),
+        };
+      });
+
+      response = (await client.submitToolOutputs(
+        thread.threadId,
+        response.runId!,
+        toolOutputs,
+        false
+      )) as BBMessageResponse;
+    }
+
+    console.log(`\n  📝 Final response (first 500 chars):`);
+    console.log(`  ${response.content?.slice(0, 500) || "(empty)"}`);
+    console.log(`\n  ⏱️  ${elapsed(start)} | Tool calls: ${toolCallCount}`);
+    console.log("  ✅ Originality thread PASSED");
+
+    return {
+      roundId: MINI_ROUND.roundId,
+      metric: "originality",
+      results: {},
+    };
+  } catch (err: any) {
+    console.error(`  ❌ FAILED: ${err.message}`);
+    return null;
+  }
+}
+
+// ============================================================
+// Thread 4: Ranking (Live — uses mock metric data)
+// ============================================================
+async function testRanking() {
+  hr("Thread 4: Final Ranking Aggregation (LIVE)");
+  const start = Date.now();
+
+  // Use mock metric data so this thread can run independently
+  const mockTC: TimeComplexityResults = {
+    roundId: "test_round_1",
+    metric: "time_complexity",
+    results: {
+      test_user_1: [{ questionId: "q1", complexity: "O(n)", score: 95, reasoning: "Hash map single pass" }],
+      test_user_2: [{ questionId: "q1", complexity: "O(n²)", score: 40, reasoning: "Brute force nested loops" }],
+    },
+  };
+  const mockSC: SpaceComplexityResults = {
+    roundId: "test_round_1",
+    metric: "space_complexity",
+    results: {
+      test_user_1: [{ questionId: "q1", complexity: "O(n)", score: 80, reasoning: "Hash map" }],
+      test_user_2: [{ questionId: "q1", complexity: "O(1)", score: 100, reasoning: "No extra space" }],
+    },
+  };
+  const mockOrig: OriginalityResults = {
+    roundId: "test_round_1",
+    metric: "originality",
+    results: {
+      test_user_1: [{ questionId: "q1", originalityScore: 9, relevanceScore: 10, commentDensity: 0, flags: [], reasoning: "Clean code" }],
+      test_user_2: [{ questionId: "q1", originalityScore: 3, relevanceScore: 9, commentDensity: 55, flags: ["excessive_comments"], reasoning: "AI-generated" }],
+    },
+  };
+  const testCases: TestCaseResults = {
+    test_user_1: { passed: 9, total: 10 },
+    test_user_2: { passed: 7, total: 10 },
+  };
+  const tiebreaker: TiebreakerData = {
+    test_user_1: 120000,
+    test_user_2: 180000,
+  };
+
+  try {
+    const assistant = await client.createAssistant({
+      name: "CnC Ranking Test",
+      system_prompt: SYSTEM_PROMPTS.ranking,
+      tools: [RANKING_TOOL],
+    });
+    console.log(`  ✅ Assistant: ${assistant.assistantId}`);
+
+    const thread = await client.createThread(assistant.assistantId);
+    console.log(`  ✅ Thread: ${thread.threadId}`);
+
+    const prompt = `Compute the final ranking for round test_round_1.
+
+Use the compute_final_ranking tool with:
+- timeComplexityResults: ${JSON.stringify(mockTC)}
+- spaceComplexityResults: ${JSON.stringify(mockSC)}
+- originalityResults: ${JSON.stringify(mockOrig)}
+- testCaseResults: ${JSON.stringify(testCases)}
+- weights: ${JSON.stringify(DEFAULT_WEIGHTS)}
+- tiebreakerData: ${JSON.stringify(tiebreaker)}
+
+Produce a final ranking with full score breakdowns.`;
+
+    console.log("  Sending message to LLM...");
+    let response = (await client.addMessage(thread.threadId, {
+      content: prompt,
+      llm_provider: config.llmProvider,
+      model_name: config.modelName,
+      stream: false,
+    })) as BBMessageResponse;
+
+    let toolCallCount = 0;
+    while (response.status === "REQUIRES_ACTION" && response.toolCalls) {
+      console.log(`  Tool calls received: ${response.toolCalls.length}`);
+      const toolOutputs = response.toolCalls.map((tc) => {
+        toolCallCount++;
+        console.log(`    📞 #${toolCallCount}: ${tc.function.name}`);
+        return {
+          tool_call_id: tc.id,
+          output: JSON.stringify({ status: "computed", message: "Rankings computed successfully" }),
+        };
+      });
+
+      response = (await client.submitToolOutputs(
+        thread.threadId,
+        response.runId!,
+        toolOutputs,
+        false
+      )) as BBMessageResponse;
+    }
+
+    console.log(`\n  📝 Final response (first 800 chars):`);
+    console.log(`  ${response.content?.slice(0, 800) || "(empty)"}`);
+    console.log(`\n  ⏱️  ${elapsed(start)} | Tool calls: ${toolCallCount}`);
+    console.log("  ✅ Ranking thread PASSED");
+  } catch (err: any) {
+    console.error(`  ❌ FAILED: ${err.message}`);
+  }
+}
+
+// ============================================================
+// Memory: Store & Retrieve (Live)
+// ============================================================
+async function testMemory() {
+  hr("Memory: Store & Retrieve Player Profile (LIVE)");
+  const start = Date.now();
+
+  try {
+    // Store
+    console.log("  Creating memory assistant...");
+    const assistant = await client.createAssistant({
+      name: "CnC Memory Test",
+      system_prompt: SYSTEM_PROMPTS.memory,
+    });
+    console.log(`  ✅ Assistant: ${assistant.assistantId}`);
+
+    const storeThread = await client.createThread(assistant.assistantId);
+    console.log(`  ✅ Store thread: ${storeThread.threadId}`);
+
+    const storeMsg = `
+Player Profile Update:
+
+User: test_user_live
+Current Tier: intermediate
+Average Score: 58.5
+
+Round History (last 3):
+- Round r1: Score 52, Rank #3
+- Round r2: Score 61, Rank #2
+- Round r3: Score 63, Rank #1
+
+Common Errors: Off-by-one errors, forgetting edge cases
+Preferred Algorithms: Binary Search, Hash Maps
+
+Remember this profile for personalized coaching.
+`;
+
+    console.log("  Storing player memory...");
+    const storeResponse = (await client.addMessage(storeThread.threadId, {
+      content: storeMsg,
+      memory: "Auto",
+      stream: false,
+    })) as BBMessageResponse;
+
+    console.log(`  Store response (first 300 chars): ${storeResponse.content?.slice(0, 300)}`);
+    console.log(`  Memory operation ID: ${storeResponse.memoryOperationId || "N/A"}`);
+
+    // Retrieve
+    const retrieveThread = await client.createThread(assistant.assistantId);
+    console.log(`\n  ✅ Retrieve thread: ${retrieveThread.threadId}`);
+    console.log("  Querying memory for test_user_live...");
+
+    const retrieveResponse = (await client.addMessage(retrieveThread.threadId, {
+      content:
+        "What do you remember about user test_user_live? What is their skill tier, common errors, and what coaching would you recommend?",
+      memory: "Auto",
+      stream: false,
+    })) as BBMessageResponse;
+
+    console.log(`\n  📝 Memory recall (first 600 chars):`);
+    console.log(`  ${retrieveResponse.content?.slice(0, 600) || "(empty)"}`);
+    console.log(`\n  ⏱️  ${elapsed(start)}`);
+    console.log("  ✅ Memory store/retrieve PASSED");
+  } catch (err: any) {
+    console.error(`  ❌ FAILED: ${err.message}`);
+  }
+}
+
+// ============================================================
+// Connectivity Check
+// ============================================================
+async function testConnection() {
+  hr("Connection Test");
+  try {
+    console.log("  Testing Backboard API connectivity...");
+    const assistant = await client.createAssistant({
+      name: "CnC Ping",
+      system_prompt: "Reply with 'pong'",
+    });
+    console.log(`  ✅ Connected! Assistant ID: ${assistant.assistantId}`);
+
+    const thread = await client.createThread(assistant.assistantId);
+    console.log(`  ✅ Thread created: ${thread.threadId}`);
+
+    const response = (await client.addMessage(thread.threadId, {
+      content: "ping",
+      llm_provider: config.llmProvider,
+      model_name: config.modelName,
+      stream: false,
+    })) as BBMessageResponse;
+
+    console.log(`  ✅ LLM responded: "${response.content?.slice(0, 100)}"`);
+    return true;
+  } catch (err: any) {
+    console.error(`  ❌ Connection failed: ${err.message}`);
+    return false;
+  }
+}
+
+// ---- Prompt builder (same logic as evaluation.ts) ----
+function buildPrompt(round: RoundSubmissions, label: string): string {
+  let p = `## Round: ${round.roundId} — ${label} Analysis\n\n`;
+  p += `### Questions:\n`;
+  for (const q of round.questions) {
+    p += `- **${q.id}** (${q.difficulty}): ${q.title}\n  ${q.description}\n\n`;
+  }
+  p += `### Submissions:\n\n`;
+  for (const sub of round.submissions) {
+    p += `#### User: ${sub.userId}\n`;
+    for (const resp of sub.responses) {
+      const q = round.questions.find((q) => q.id === resp.questionId);
+      p += `**Question ${resp.questionId}** (${resp.language}):\n`;
+      p += "```\n" + resp.code + "\n```\n\n";
+      p += `Call the tool for this submission with questionContext: "${q?.description || q?.title || resp.questionId}"\n\n`;
+    }
+  }
+  p += `\nAnalyze ALL submissions above. Call the tool once per submission.\n`;
+  return p;
+}
+
+// ============================================================
+// Main Runner
+// ============================================================
+async function main() {
+  const args = process.argv.slice(2);
+  const threadFlag = args.find((a) => a.startsWith("--thread="))?.split("=")[1];
+
+  console.log("\n🏟️  Compile-n-Conquer — Live Backboard Integration Test");
+  console.log(`   API Key: ${API_KEY!.slice(0, 8)}...${API_KEY!.slice(-4)}`);
+  console.log(`   Provider: ${config.llmProvider} / ${config.modelName}`);
+  console.log(`   Test scope: ${threadFlag || "all"}\n`);
+
+  // Always test connection first
+  const connected = await testConnection();
+  if (!connected) {
+    console.error("\n❌ Cannot reach Backboard API. Check your API key.");
+    process.exit(1);
+  }
+
+  const results: Record<string, boolean> = {};
+
+  if (!threadFlag || threadFlag === "all" || threadFlag === "tc") {
+    const r = await testTimeComplexity();
+    results["Time Complexity"] = r !== null;
+  }
+
+  if (!threadFlag || threadFlag === "all" || threadFlag === "sc") {
+    const r = await testSpaceComplexity();
+    results["Space Complexity"] = r !== null;
+  }
+
+  if (!threadFlag || threadFlag === "all" || threadFlag === "orig") {
+    const r = await testOriginality();
+    results["Originality"] = r !== null;
+  }
+
+  if (!threadFlag || threadFlag === "all" || threadFlag === "rank") {
+    await testRanking();
+    results["Ranking"] = true; // if it throws, catch sets it
+  }
+
+  if (!threadFlag || threadFlag === "all" || threadFlag === "memory") {
+    await testMemory();
+    results["Memory"] = true;
+  }
+
+  // Summary
+  hr("SUMMARY");
+  for (const [name, pass] of Object.entries(results)) {
+    console.log(`  ${pass ? "✅" : "❌"} ${name}`);
+  }
+  console.log("");
+}
+
+main().catch((err) => {
+  console.error("Fatal error:", err);
+  process.exit(1);
+});

From ebebc2e44d52de170445babc43ecd88fb506c653 Mon Sep 17 00:00:00 2001
From: AdityaVKochar <adityavardhankochar@gmail.com>
Date: Mon, 9 Feb 2026 22:59:04 +0530
Subject: [PATCH 4/9] prisma is fucked

---
 .gitignore                                    |    2 +
 app/api/auth/me/route.ts                      |   58 +
 app/api/auth/signin/route.ts                  |   83 +
 app/api/auth/signup/route.ts                  |   94 +
 app/api/execute/route.ts                      |   55 +
 app/api/match/[matchId]/evaluate/route.ts     |  198 ++
 app/api/match/[matchId]/route.ts              |  126 +
 app/api/match/[matchId]/submit/route.ts       |  149 ++
 app/api/questions/route.ts                    |   87 +
 app/api/queue/route.ts                        |  218 ++
 app/auth/page.tsx                             |  161 +-
 lib/auth.ts                                   |   65 +
 lib/db.ts                                     |    7 +
 lib/piston.ts                                 |   88 +
 package-lock.json                             | 1045 +++++++-
 package.json                                  |   19 +-
 prisma.config.ts                              |   14 +
 prisma/generated/prisma/browser.ts            |   54 +
 prisma/generated/prisma/client.ts             |   76 +
 prisma/generated/prisma/commonInputTypes.ts   |  660 +++++
 prisma/generated/prisma/enums.ts              |   49 +
 prisma/generated/prisma/internal/class.ts     |  252 ++
 .../prisma/internal/prismaNamespace.ts        | 1422 ++++++++++
 .../prisma/internal/prismaNamespaceBrowser.ts |  227 ++
 prisma/generated/prisma/models.ts             |   18 +
 prisma/generated/prisma/models/Match.ts       | 1770 ++++++++++++
 prisma/generated/prisma/models/MatchPlayer.ts | 1573 +++++++++++
 .../generated/prisma/models/MatchQuestion.ts  | 1469 ++++++++++
 prisma/generated/prisma/models/Question.ts    | 1650 ++++++++++++
 prisma/generated/prisma/models/QueueEntry.ts  | 1315 +++++++++
 prisma/generated/prisma/models/Submission.ts  | 2377 +++++++++++++++++
 prisma/generated/prisma/models/User.ts        | 1918 +++++++++++++
 prisma/schema.prisma                          |  195 ++
 prisma/seed.ts                                |  207 ++
 34 files changed, 17633 insertions(+), 68 deletions(-)
 create mode 100644 app/api/auth/me/route.ts
 create mode 100644 app/api/auth/signin/route.ts
 create mode 100644 app/api/auth/signup/route.ts
 create mode 100644 app/api/execute/route.ts
 create mode 100644 app/api/match/[matchId]/evaluate/route.ts
 create mode 100644 app/api/match/[matchId]/route.ts
 create mode 100644 app/api/match/[matchId]/submit/route.ts
 create mode 100644 app/api/questions/route.ts
 create mode 100644 app/api/queue/route.ts
 create mode 100644 lib/auth.ts
 create mode 100644 lib/db.ts
 create mode 100644 lib/piston.ts
 create mode 100644 prisma.config.ts
 create mode 100644 prisma/generated/prisma/browser.ts
 create mode 100644 prisma/generated/prisma/client.ts
 create mode 100644 prisma/generated/prisma/commonInputTypes.ts
 create mode 100644 prisma/generated/prisma/enums.ts
 create mode 100644 prisma/generated/prisma/internal/class.ts
 create mode 100644 prisma/generated/prisma/internal/prismaNamespace.ts
 create mode 100644 prisma/generated/prisma/internal/prismaNamespaceBrowser.ts
 create mode 100644 prisma/generated/prisma/models.ts
 create mode 100644 prisma/generated/prisma/models/Match.ts
 create mode 100644 prisma/generated/prisma/models/MatchPlayer.ts
 create mode 100644 prisma/generated/prisma/models/MatchQuestion.ts
 create mode 100644 prisma/generated/prisma/models/Question.ts
 create mode 100644 prisma/generated/prisma/models/QueueEntry.ts
 create mode 100644 prisma/generated/prisma/models/Submission.ts
 create mode 100644 prisma/generated/prisma/models/User.ts
 create mode 100644 prisma/schema.prisma
 create mode 100644 prisma/seed.ts

diff --git a/.gitignore b/.gitignore
index 5ef6a52..62fcee8 100644
--- a/.gitignore
+++ b/.gitignore
@@ -39,3 +39,5 @@ yarn-error.log*
 # typescript
 *.tsbuildinfo
 next-env.d.ts
+
+/lib/generated/prisma
diff --git a/app/api/auth/me/route.ts b/app/api/auth/me/route.ts
new file mode 100644
index 0000000..b877060
--- /dev/null
+++ b/app/api/auth/me/route.ts
@@ -0,0 +1,58 @@
+// ============================================================
+// POST /api/auth/signout — Clear auth cookie
+// GET  /api/auth/me — Get current user from JWT
+// ============================================================
+
+import { NextRequest, NextResponse } from "next/server";
+import { prisma } from "@/lib/db";
+import { getUserFromRequest } from "@/lib/auth";
+
+export async function GET(req: NextRequest) {
+  const payload = getUserFromRequest(req);
+
+  if (!payload) {
+    return NextResponse.json({ error: "Not authenticated" }, { status: 401 });
+  }
+
+  try {
+    const user = await prisma.user.findUnique({
+      where: { id: payload.userId },
+      select: {
+        id: true,
+        username: true,
+        email: true,
+        displayName: true,
+        skillTier: true,
+        elo: true,
+        totalWins: true,
+        totalMatches: true,
+        createdAt: true,
+      },
+    });
+
+    if (!user) {
+      return NextResponse.json({ error: "User not found" }, { status: 404 });
+    }
+
+    return NextResponse.json({ user });
+  } catch (error) {
+    console.error("Me error:", error);
+    return NextResponse.json(
+      { error: "Internal server error" },
+      { status: 500 }
+    );
+  }
+}
+
+export async function POST(req: NextRequest) {
+  // Sign out: clear the cookie
+  const response = NextResponse.json({ success: true });
+  response.cookies.set("token", "", {
+    httpOnly: true,
+    secure: process.env.NODE_ENV === "production",
+    sameSite: "lax",
+    maxAge: 0,
+    path: "/",
+  });
+  return response;
+}
diff --git a/app/api/auth/signin/route.ts b/app/api/auth/signin/route.ts
new file mode 100644
index 0000000..234c8e1
--- /dev/null
+++ b/app/api/auth/signin/route.ts
@@ -0,0 +1,83 @@
+// ============================================================
+// POST /api/auth/signin — Login with username/email + password
+// ============================================================
+
+import { NextRequest, NextResponse } from "next/server";
+import { prisma } from "@/lib/db";
+import { verifyPassword, signToken } from "@/lib/auth";
+
+export async function POST(req: NextRequest) {
+  try {
+    const body = await req.json();
+    const { login, password } = body;
+
+    // login can be username or email
+    if (!login || !password) {
+      return NextResponse.json(
+        { error: "login (username or email) and password are required" },
+        { status: 400 }
+      );
+    }
+
+    // Find user by email or username
+    const user = await prisma.user.findFirst({
+      where: {
+        OR: [{ email: login }, { username: login }],
+      },
+    });
+
+    if (!user) {
+      return NextResponse.json(
+        { error: "Invalid credentials" },
+        { status: 401 }
+      );
+    }
+
+    // Verify password
+    const valid = await verifyPassword(password, user.passwordHash);
+    if (!valid) {
+      return NextResponse.json(
+        { error: "Invalid credentials" },
+        { status: 401 }
+      );
+    }
+
+    // Sign JWT
+    const token = signToken({
+      userId: user.id,
+      username: user.username,
+      email: user.email,
+    });
+
+    const response = NextResponse.json({
+      user: {
+        id: user.id,
+        username: user.username,
+        email: user.email,
+        displayName: user.displayName,
+        skillTier: user.skillTier,
+        elo: user.elo,
+        totalWins: user.totalWins,
+        totalMatches: user.totalMatches,
+      },
+      token,
+    });
+
+    // Also set as httpOnly cookie
+    response.cookies.set("token", token, {
+      httpOnly: true,
+      secure: process.env.NODE_ENV === "production",
+      sameSite: "lax",
+      maxAge: 60 * 60 * 24 * 7,
+      path: "/",
+    });
+
+    return response;
+  } catch (error) {
+    console.error("Signin error:", error);
+    return NextResponse.json(
+      { error: "Internal server error" },
+      { status: 500 }
+    );
+  }
+}
diff --git a/app/api/auth/signup/route.ts b/app/api/auth/signup/route.ts
new file mode 100644
index 0000000..2c7fb1a
--- /dev/null
+++ b/app/api/auth/signup/route.ts
@@ -0,0 +1,94 @@
+// ============================================================
+// POST /api/auth/signup — Register a new user
+// ============================================================
+
+import { NextRequest, NextResponse } from "next/server";
+import { prisma } from "@/lib/db";
+import { hashPassword, signToken } from "@/lib/auth";
+
+export async function POST(req: NextRequest) {
+  try {
+    const body = await req.json();
+    const { username, email, password, displayName } = body;
+
+    // Validate required fields
+    if (!username || !email || !password) {
+      return NextResponse.json(
+        { error: "username, email, and password are required" },
+        { status: 400 }
+      );
+    }
+
+    if (password.length < 6) {
+      return NextResponse.json(
+        { error: "Password must be at least 6 characters" },
+        { status: 400 }
+      );
+    }
+
+    // Check if user already exists
+    const existing = await prisma.user.findFirst({
+      where: {
+        OR: [{ email }, { username }],
+      },
+    });
+
+    if (existing) {
+      const field = existing.email === email ? "email" : "username";
+      return NextResponse.json(
+        { error: `A user with that ${field} already exists` },
+        { status: 409 }
+      );
+    }
+
+    // Create user
+    const passwordHash = await hashPassword(password);
+    const user = await prisma.user.create({
+      data: {
+        username,
+        email,
+        passwordHash,
+        displayName: displayName || username,
+      },
+    });
+
+    // Sign JWT
+    const token = signToken({
+      userId: user.id,
+      username: user.username,
+      email: user.email,
+    });
+
+    const response = NextResponse.json(
+      {
+        user: {
+          id: user.id,
+          username: user.username,
+          email: user.email,
+          displayName: user.displayName,
+          skillTier: user.skillTier,
+          elo: user.elo,
+        },
+        token,
+      },
+      { status: 201 }
+    );
+
+    // Also set as httpOnly cookie
+    response.cookies.set("token", token, {
+      httpOnly: true,
+      secure: process.env.NODE_ENV === "production",
+      sameSite: "lax",
+      maxAge: 60 * 60 * 24 * 7, // 7 days
+      path: "/",
+    });
+
+    return response;
+  } catch (error) {
+    console.error("Signup error:", error);
+    return NextResponse.json(
+      { error: "Internal server error" },
+      { status: 500 }
+    );
+  }
+}
diff --git a/app/api/execute/route.ts b/app/api/execute/route.ts
new file mode 100644
index 0000000..9ffeddd
--- /dev/null
+++ b/app/api/execute/route.ts
@@ -0,0 +1,55 @@
+// ============================================================
+// POST /api/execute — Run code via Piston (standalone, no match)
+// GET /api/execute — Get available runtimes
+// ============================================================
+// Useful for testing code before submitting in a match.
+
+import { NextRequest, NextResponse } from "next/server";
+import { getUserFromRequest } from "@/lib/auth";
+import { runCode, getRuntimes } from "@/lib/piston";
+
+export async function POST(req: NextRequest) {
+  const payload = getUserFromRequest(req);
+  if (!payload) {
+    return NextResponse.json({ error: "Not authenticated" }, { status: 401 });
+  }
+
+  try {
+    const body = await req.json();
+    const { language, code, stdin = "" } = body;
+
+    if (!language || !code) {
+      return NextResponse.json(
+        { error: "language and code are required" },
+        { status: 400 }
+      );
+    }
+
+    const result = await runCode(language, code, stdin);
+
+    return NextResponse.json({
+      stdout: result.run.stdout,
+      stderr: result.run.stderr,
+      exitCode: result.run.code,
+      output: result.run.output,
+    });
+  } catch (error: any) {
+    console.error("Execute error:", error);
+    return NextResponse.json(
+      { error: error.message || "Execution failed" },
+      { status: 500 }
+    );
+  }
+}
+
+export async function GET() {
+  try {
+    const runtimes = await getRuntimes();
+    return NextResponse.json({ runtimes });
+  } catch (error: any) {
+    return NextResponse.json(
+      { error: error.message || "Failed to fetch runtimes" },
+      { status: 500 }
+    );
+  }
+}
diff --git a/app/api/match/[matchId]/evaluate/route.ts b/app/api/match/[matchId]/evaluate/route.ts
new file mode 100644
index 0000000..431ea7a
--- /dev/null
+++ b/app/api/match/[matchId]/evaluate/route.ts
@@ -0,0 +1,198 @@
+// ============================================================
+// POST /api/match/[matchId]/evaluate — Trigger LLM evaluation
+// ============================================================
+// Called when all players have submitted (or time is up).
+// Runs the Backboard evaluation pipeline and updates rankings.
+
+import { NextRequest, NextResponse } from "next/server";
+import { prisma } from "@/lib/db";
+import { getUserFromRequest } from "@/lib/auth";
+
+export async function POST(
+  req: NextRequest,
+  { params }: { params: Promise<{ matchId: string }> }
+) {
+  const payload = getUserFromRequest(req);
+  if (!payload) {
+    return NextResponse.json({ error: "Not authenticated" }, { status: 401 });
+  }
+
+  const { matchId } = await params;
+
+  try {
+    // Get match with all data needed for evaluation
+    const match = await prisma.match.findUnique({
+      where: { id: matchId },
+      include: {
+        players: { include: { user: true } },
+        questions: { include: { question: true } },
+        submissions: true,
+      },
+    });
+
+    if (!match) {
+      return NextResponse.json({ error: "Match not found" }, { status: 404 });
+    }
+
+    if (match.status !== "IN_PROGRESS") {
+      return NextResponse.json(
+        { error: `Match is ${match.status}, cannot evaluate` },
+        { status: 400 }
+      );
+    }
+
+    // Transition to EVALUATING
+    await prisma.match.update({
+      where: { id: matchId },
+      data: { status: "EVALUATING" },
+    });
+
+    // Build the RoundSubmissions payload for Backboard
+    const roundSubmissions = {
+      roundId: matchId,
+      questions: match.questions.map((mq) => ({
+        id: mq.question.id,
+        title: mq.question.title,
+        description: mq.question.description,
+        difficulty: mq.question.difficulty.toLowerCase() as "easy" | "medium" | "hard",
+      })),
+      submissions: match.players.map((player) => ({
+        userId: player.userId,
+        responses: match.submissions
+          .filter((s) => s.userId === player.userId)
+          .map((s) => ({
+            questionId: s.questionId,
+            code: s.code,
+            language: s.language,
+            submittedAt: s.submittedAt.toISOString(),
+          })),
+      })),
+    };
+
+    // For now, compute rankings based on test case results
+    // The full Backboard LLM pipeline can be triggered async
+    const playerScores = match.players.map((player) => {
+      const playerSubmissions = match.submissions.filter(
+        (s) => s.userId === player.userId
+      );
+
+      // Calculate average test pass rate
+      const totalPassed = playerSubmissions.reduce(
+        (sum, s) => sum + s.testsPassed,
+        0
+      );
+      const totalTests = playerSubmissions.reduce(
+        (sum, s) => sum + s.testsTotal,
+        0
+      );
+      const passRate = totalTests > 0 ? totalPassed / totalTests : 0;
+
+      // For SHORTEST mode, factor in code length
+      const avgCharCount =
+        playerSubmissions.length > 0
+          ? playerSubmissions.reduce((sum, s) => sum + (s.charCount || 0), 0) /
+            playerSubmissions.length
+          : Infinity;
+
+      // For FASTEST mode, factor in submission time
+      const avgTime =
+        playerSubmissions.length > 0
+          ? playerSubmissions.reduce(
+              (sum, s) => sum + s.submittedAt.getTime(),
+              0
+            ) / playerSubmissions.length
+          : Infinity;
+
+      let score = passRate * 100;
+
+      // Mode-specific scoring adjustments
+      if (match.mode === "SHORTEST") {
+        // Lower char count = higher bonus (max 20 points)
+        const charBonus = Math.max(0, 20 - avgCharCount / 50);
+        score += charBonus;
+      }
+
+      return {
+        playerId: player.id,
+        userId: player.userId,
+        score,
+        avgTime,
+      };
+    });
+
+    // Sort by score (desc), then by time (asc) for tiebreaker
+    playerScores.sort((a, b) => {
+      if (b.score !== a.score) return b.score - a.score;
+      return a.avgTime - b.avgTime;
+    });
+
+    // Update rankings in a transaction
+    await prisma.$transaction(async (tx) => {
+      for (let i = 0; i < playerScores.length; i++) {
+        await tx.matchPlayer.update({
+          where: { id: playerScores[i].playerId },
+          data: {
+            rank: i + 1,
+            score: playerScores[i].score,
+          },
+        });
+
+        // Update user stats
+        const isWinner = i === 0;
+        await tx.user.update({
+          where: { id: playerScores[i].userId },
+          data: {
+            totalMatches: { increment: 1 },
+            ...(isWinner ? { totalWins: { increment: 1 } } : {}),
+          },
+        });
+      }
+
+      // Mark match as completed
+      await tx.match.update({
+        where: { id: matchId },
+        data: {
+          status: "COMPLETED",
+          endedAt: new Date(),
+        },
+      });
+    });
+
+    // Return final rankings
+    const finalMatch = await prisma.match.findUnique({
+      where: { id: matchId },
+      include: {
+        players: {
+          include: {
+            user: {
+              select: {
+                id: true,
+                username: true,
+                displayName: true,
+              },
+            },
+          },
+          orderBy: { rank: "asc" },
+        },
+      },
+    });
+
+    return NextResponse.json({
+      message: "Evaluation complete",
+      rankings: finalMatch?.players.map((p) => ({
+        rank: p.rank,
+        userId: p.userId,
+        username: p.user.username,
+        displayName: p.user.displayName,
+        score: p.score,
+      })),
+      roundSubmissions, // For debugging / Backboard integration
+    });
+  } catch (error) {
+    console.error("Evaluate error:", error);
+    return NextResponse.json(
+      { error: "Internal server error" },
+      { status: 500 }
+    );
+  }
+}
diff --git a/app/api/match/[matchId]/route.ts b/app/api/match/[matchId]/route.ts
new file mode 100644
index 0000000..2a3ae51
--- /dev/null
+++ b/app/api/match/[matchId]/route.ts
@@ -0,0 +1,126 @@
+// ============================================================
+// GET /api/match/[matchId] — Get match details
+// POST /api/match/[matchId] — Start the match (transition to IN_PROGRESS)
+// ============================================================
+
+import { NextRequest, NextResponse } from "next/server";
+import { prisma } from "@/lib/db";
+import { getUserFromRequest } from "@/lib/auth";
+
+export async function GET(
+  req: NextRequest,
+  { params }: { params: Promise<{ matchId: string }> }
+) {
+  const payload = getUserFromRequest(req);
+  if (!payload) {
+    return NextResponse.json({ error: "Not authenticated" }, { status: 401 });
+  }
+
+  const { matchId } = await params;
+
+  try {
+    const match = await prisma.match.findUnique({
+      where: { id: matchId },
+      include: {
+        players: {
+          include: {
+            user: {
+              select: {
+                id: true,
+                username: true,
+                displayName: true,
+                skillTier: true,
+                elo: true,
+              },
+            },
+          },
+        },
+        questions: {
+          include: { question: true },
+          orderBy: { order: "asc" },
+        },
+        submissions: {
+          where: { userId: payload.userId },
+          select: {
+            id: true,
+            questionId: true,
+            language: true,
+            submittedAt: true,
+            testsPassed: true,
+            testsTotal: true,
+          },
+        },
+      },
+    });
+
+    if (!match) {
+      return NextResponse.json({ error: "Match not found" }, { status: 404 });
+    }
+
+    // Verify user is a player in this match
+    const isPlayer = match.players.some(
+      (p) => p.userId === payload.userId
+    );
+    if (!isPlayer) {
+      return NextResponse.json(
+        { error: "You are not a player in this match" },
+        { status: 403 }
+      );
+    }
+
+    return NextResponse.json({ match });
+  } catch (error) {
+    console.error("Match fetch error:", error);
+    return NextResponse.json(
+      { error: "Internal server error" },
+      { status: 500 }
+    );
+  }
+}
+
+// Start match — any player can trigger this, transitions WAITING → IN_PROGRESS
+export async function POST(
+  req: NextRequest,
+  { params }: { params: Promise<{ matchId: string }> }
+) {
+  const payload = getUserFromRequest(req);
+  if (!payload) {
+    return NextResponse.json({ error: "Not authenticated" }, { status: 401 });
+  }
+
+  const { matchId } = await params;
+
+  try {
+    const match = await prisma.match.findUnique({
+      where: { id: matchId },
+      include: { players: true },
+    });
+
+    if (!match) {
+      return NextResponse.json({ error: "Match not found" }, { status: 404 });
+    }
+
+    if (match.status !== "WAITING") {
+      return NextResponse.json(
+        { error: `Match is already ${match.status}` },
+        { status: 400 }
+      );
+    }
+
+    const updated = await prisma.match.update({
+      where: { id: matchId },
+      data: {
+        status: "IN_PROGRESS",
+        startedAt: new Date(),
+      },
+    });
+
+    return NextResponse.json({ match: updated });
+  } catch (error) {
+    console.error("Match start error:", error);
+    return NextResponse.json(
+      { error: "Internal server error" },
+      { status: 500 }
+    );
+  }
+}
diff --git a/app/api/match/[matchId]/submit/route.ts b/app/api/match/[matchId]/submit/route.ts
new file mode 100644
index 0000000..8bc3e23
--- /dev/null
+++ b/app/api/match/[matchId]/submit/route.ts
@@ -0,0 +1,149 @@
+// ============================================================
+// POST /api/match/[matchId]/submit — Submit code for a question
+// ============================================================
+// Runs code against test cases via Piston, stores results.
+
+import { NextRequest, NextResponse } from "next/server";
+import { prisma } from "@/lib/db";
+import { getUserFromRequest } from "@/lib/auth";
+import { runCode, type PistonResult } from "@/lib/piston";
+
+export async function POST(
+  req: NextRequest,
+  { params }: { params: Promise<{ matchId: string }> }
+) {
+  const payload = getUserFromRequest(req);
+  if (!payload) {
+    return NextResponse.json({ error: "Not authenticated" }, { status: 401 });
+  }
+
+  const { matchId } = await params;
+
+  try {
+    const body = await req.json();
+    const { questionId, code, language } = body;
+
+    if (!questionId || !code || !language) {
+      return NextResponse.json(
+        { error: "questionId, code, and language are required" },
+        { status: 400 }
+      );
+    }
+
+    // Verify match exists and is in progress
+    const match = await prisma.match.findUnique({
+      where: { id: matchId },
+      include: {
+        players: true,
+        questions: { include: { question: true } },
+      },
+    });
+
+    if (!match) {
+      return NextResponse.json({ error: "Match not found" }, { status: 404 });
+    }
+
+    if (match.status !== "IN_PROGRESS") {
+      return NextResponse.json(
+        { error: `Match is ${match.status}, not accepting submissions` },
+        { status: 400 }
+      );
+    }
+
+    // Verify user is a player
+    const isPlayer = match.players.some((p) => p.userId === payload.userId);
+    if (!isPlayer) {
+      return NextResponse.json(
+        { error: "You are not a player in this match" },
+        { status: 403 }
+      );
+    }
+
+    // Find the question
+    const matchQuestion = match.questions.find(
+      (mq) => mq.questionId === questionId
+    );
+    if (!matchQuestion) {
+      return NextResponse.json(
+        { error: "Question not part of this match" },
+        { status: 400 }
+      );
+    }
+
+    const question = matchQuestion.question;
+
+    // Run code against test cases via Piston
+    let testsPassed = 0;
+    let testsTotal = 0;
+    let lastStdout = "";
+    let lastStderr = "";
+    let lastExitCode = 0;
+    let execTimeMs = 0;
+
+    const testCases = (question.testCases as Array<{
+      input: string;
+      expectedOutput: string;
+    }>) || [];
+
+    testsTotal = testCases.length;
+
+    if (testsTotal > 0) {
+      for (const tc of testCases) {
+        const result: PistonResult = await runCode(language, code, tc.input);
+
+        lastStdout = result.run.stdout;
+        lastStderr = result.run.stderr;
+        lastExitCode = result.run.code;
+
+        // Compare output (trim whitespace)
+        const actual = result.run.stdout.trim();
+        const expected = tc.expectedOutput.trim();
+
+        if (actual === expected) {
+          testsPassed++;
+        }
+      }
+    } else {
+      // No test cases — just run the code once
+      const result: PistonResult = await runCode(language, code);
+      lastStdout = result.run.stdout;
+      lastStderr = result.run.stderr;
+      lastExitCode = result.run.code;
+    }
+
+    // Save submission
+    const submission = await prisma.submission.create({
+      data: {
+        matchId,
+        userId: payload.userId,
+        questionId,
+        code,
+        language,
+        charCount: code.length,
+        stdout: lastStdout,
+        stderr: lastStderr,
+        exitCode: lastExitCode,
+        execTimeMs,
+        testsPassed,
+        testsTotal,
+      },
+    });
+
+    return NextResponse.json({
+      submission: {
+        id: submission.id,
+        testsPassed,
+        testsTotal,
+        stdout: lastStdout,
+        stderr: lastStderr,
+        exitCode: lastExitCode,
+      },
+    });
+  } catch (error) {
+    console.error("Submit error:", error);
+    return NextResponse.json(
+      { error: "Internal server error" },
+      { status: 500 }
+    );
+  }
+}
diff --git a/app/api/questions/route.ts b/app/api/questions/route.ts
new file mode 100644
index 0000000..48eb9ee
--- /dev/null
+++ b/app/api/questions/route.ts
@@ -0,0 +1,87 @@
+// ============================================================
+// GET /api/questions — List questions (optionally filter by mode)
+// POST /api/questions — Create a new question
+// ============================================================
+
+import { NextRequest, NextResponse } from "next/server";
+import { prisma } from "@/lib/db";
+import { getUserFromRequest } from "@/lib/auth";
+import { GameMode, Difficulty } from "@prisma/client";
+
+export async function GET(req: NextRequest) {
+  const payload = getUserFromRequest(req);
+  if (!payload) {
+    return NextResponse.json({ error: "Not authenticated" }, { status: 401 });
+  }
+
+  const { searchParams } = new URL(req.url);
+  const mode = searchParams.get("mode") as GameMode | null;
+  const difficulty = searchParams.get("difficulty") as Difficulty | null;
+
+  try {
+    const questions = await prisma.question.findMany({
+      where: {
+        ...(mode ? { mode } : {}),
+        ...(difficulty ? { difficulty } : {}),
+      },
+      orderBy: { createdAt: "desc" },
+    });
+
+    return NextResponse.json({ questions });
+  } catch (error) {
+    console.error("Questions list error:", error);
+    return NextResponse.json(
+      { error: "Internal server error" },
+      { status: 500 }
+    );
+  }
+}
+
+export async function POST(req: NextRequest) {
+  const payload = getUserFromRequest(req);
+  if (!payload) {
+    return NextResponse.json({ error: "Not authenticated" }, { status: 401 });
+  }
+
+  try {
+    const body = await req.json();
+    const {
+      title,
+      description,
+      difficulty = "MEDIUM",
+      mode = "FASTEST",
+      testCases,
+      brokenCode,
+      brokenLanguage,
+      expectedOutput,
+    } = body;
+
+    if (!title || !description) {
+      return NextResponse.json(
+        { error: "title and description are required" },
+        { status: 400 }
+      );
+    }
+
+    const question = await prisma.question.create({
+      data: {
+        title,
+        description,
+        difficulty: difficulty as Difficulty,
+        mode: mode as GameMode,
+        testCases: testCases || null,
+        brokenCode: brokenCode || null,
+        brokenLanguage: brokenLanguage || null,
+        expectedOutput: expectedOutput || null,
+      },
+    });
+
+    return NextResponse.json({ question }, { status: 201 });
+  } catch (error) {
+    console.error("Question create error:", error);
+    return NextResponse.json(
+      { error: "Internal server error" },
+      { status: 500 }
+    );
+  }
+}
diff --git a/app/api/queue/route.ts b/app/api/queue/route.ts
new file mode 100644
index 0000000..4c5a9df
--- /dev/null
+++ b/app/api/queue/route.ts
@@ -0,0 +1,218 @@
+// ============================================================
+// POST /api/queue — Join the matchmaking queue
+// DELETE /api/queue — Leave the queue
+// GET /api/queue — Check queue status
+// ============================================================
+// When 8 players are in the queue, a match is automatically created.
+
+import { NextRequest, NextResponse } from "next/server";
+import { prisma } from "@/lib/db";
+import { getUserFromRequest } from "@/lib/auth";
+import { GameMode } from "@prisma/client";
+
+const PLAYERS_PER_MATCH = 8;
+
+// ---- Join Queue ----
+export async function POST(req: NextRequest) {
+  const payload = getUserFromRequest(req);
+  if (!payload) {
+    return NextResponse.json({ error: "Not authenticated" }, { status: 401 });
+  }
+
+  try {
+    // Check if already in queue
+    const existing = await prisma.queueEntry.findFirst({
+      where: { userId: payload.userId, active: true },
+    });
+
+    if (existing) {
+      return NextResponse.json(
+        { message: "Already in queue", queueEntry: existing },
+        { status: 200 }
+      );
+    }
+
+    // Check if already in an active match
+    const activeMatch = await prisma.matchPlayer.findFirst({
+      where: {
+        userId: payload.userId,
+        match: { status: { in: ["WAITING", "IN_PROGRESS"] } },
+      },
+      include: { match: true },
+    });
+
+    if (activeMatch) {
+      return NextResponse.json(
+        {
+          message: "Already in an active match",
+          matchId: activeMatch.matchId,
+        },
+        { status: 200 }
+      );
+    }
+
+    // Add to queue
+    const queueEntry = await prisma.queueEntry.create({
+      data: { userId: payload.userId },
+    });
+
+    // Check if we have enough players to start a match
+    const match = await tryCreateMatch();
+
+    if (match) {
+      return NextResponse.json(
+        {
+          message: "Match found!",
+          matchId: match.id,
+          status: "matched",
+        },
+        { status: 201 }
+      );
+    }
+
+    // Count current queue size
+    const queueSize = await prisma.queueEntry.count({
+      where: { active: true },
+    });
+
+    return NextResponse.json(
+      {
+        message: "Added to queue",
+        queueEntry,
+        queueSize,
+        playersNeeded: PLAYERS_PER_MATCH - queueSize,
+        status: "waiting",
+      },
+      { status: 201 }
+    );
+  } catch (error) {
+    console.error("Queue join error:", error);
+    return NextResponse.json(
+      { error: "Internal server error" },
+      { status: 500 }
+    );
+  }
+}
+
+// ---- Leave Queue ----
+export async function DELETE(req: NextRequest) {
+  const payload = getUserFromRequest(req);
+  if (!payload) {
+    return NextResponse.json({ error: "Not authenticated" }, { status: 401 });
+  }
+
+  try {
+    await prisma.queueEntry.updateMany({
+      where: { userId: payload.userId, active: true },
+      data: { active: false },
+    });
+
+    return NextResponse.json({ message: "Left queue" });
+  } catch (error) {
+    console.error("Queue leave error:", error);
+    return NextResponse.json(
+      { error: "Internal server error" },
+      { status: 500 }
+    );
+  }
+}
+
+// ---- Queue Status ----
+export async function GET(req: NextRequest) {
+  const payload = getUserFromRequest(req);
+  if (!payload) {
+    return NextResponse.json({ error: "Not authenticated" }, { status: 401 });
+  }
+
+  try {
+    const myEntry = await prisma.queueEntry.findFirst({
+      where: { userId: payload.userId, active: true },
+    });
+
+    const queueSize = await prisma.queueEntry.count({
+      where: { active: true },
+    });
+
+    return NextResponse.json({
+      inQueue: !!myEntry,
+      queueSize,
+      playersNeeded: Math.max(0, PLAYERS_PER_MATCH - queueSize),
+    });
+  } catch (error) {
+    console.error("Queue status error:", error);
+    return NextResponse.json(
+      { error: "Internal server error" },
+      { status: 500 }
+    );
+  }
+}
+
+// ---- Helper: Try to form a match from queued players ----
+
+async function tryCreateMatch() {
+  // Get the first N players (FIFO order)
+  const queueEntries = await prisma.queueEntry.findMany({
+    where: { active: true },
+    orderBy: { joinedAt: "asc" },
+    take: PLAYERS_PER_MATCH,
+    include: { user: true },
+  });
+
+  if (queueEntries.length < PLAYERS_PER_MATCH) {
+    return null;
+  }
+
+  // Pick random game mode
+  const modes: GameMode[] = ["FASTEST", "SHORTEST", "REVERSE", "DEBUGGING"];
+  const mode = modes[Math.floor(Math.random() * modes.length)];
+
+  // Pick random questions for this mode (1-3 questions)
+  const questionCount = Math.floor(Math.random() * 3) + 1;
+  const questions = await prisma.question.findMany({
+    where: { mode },
+    take: questionCount,
+  });
+
+  // Fallback: pick any questions if none exist for this mode
+  const finalQuestions =
+    questions.length > 0
+      ? questions
+      : await prisma.question.findMany({ take: questionCount });
+
+  // Create the match with players and questions in a transaction
+  const match = await prisma.$transaction(async (tx) => {
+    const newMatch = await tx.match.create({
+      data: {
+        mode,
+        status: "WAITING",
+        players: {
+          create: queueEntries.map((entry) => ({
+            userId: entry.userId,
+          })),
+        },
+        questions: {
+          create: finalQuestions.map((q, i) => ({
+            questionId: q.id,
+            order: i,
+          })),
+        },
+      },
+      include: {
+        players: { include: { user: { select: { id: true, username: true, displayName: true, skillTier: true } } } },
+        questions: { include: { question: true } },
+      },
+    });
+
+    // Deactivate queue entries for matched players
+    await tx.queueEntry.updateMany({
+      where: {
+        id: { in: queueEntries.map((e) => e.id) },
+      },
+      data: { active: false },
+    });
+
+    return newMatch;
+  });
+
+  return match;
+}
diff --git a/app/auth/page.tsx b/app/auth/page.tsx
index d9b2a96..0c3f14f 100644
--- a/app/auth/page.tsx
+++ b/app/auth/page.tsx
@@ -3,16 +3,56 @@
 import { Terminal, ArrowLeft } from "lucide-react"
 import Link from "next/link"
 import { useState } from "react"
+import { useRouter } from "next/navigation"
 
 export default function AuthPage() {
+  const router = useRouter()
   const [isLoading, setIsLoading] = useState(false)
+  const [isSignUp, setIsSignUp] = useState(false)
+  const [error, setError] = useState("")
 
-  const handleGoogleSignIn = () => {
+  // Form fields
+  const [username, setUsername] = useState("")
+  const [email, setEmail] = useState("")
+  const [password, setPassword] = useState("")
+
+  const handleSubmit = async (e: React.FormEvent) => {
+    e.preventDefault()
     setIsLoading(true)
-    // Mock: In production, redirect to Supabase Google OAuth
-    setTimeout(() => {
+    setError("")
+
+    try {
+      const endpoint = isSignUp ? "/api/auth/signup" : "/api/auth/signin"
+      const body = isSignUp
+        ? { username, email, password }
+        : { login: username || email, password }
+
+      const res = await fetch(endpoint, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+      })
+
+      const data = await res.json()
+
+      if (!res.ok) {
+        setError(data.error || "Authentication failed")
+        return
+      }
+
+      // Store token in localStorage for client-side access
+      if (data.token) {
+        localStorage.setItem("token", data.token)
+        localStorage.setItem("user", JSON.stringify(data.user))
+      }
+
+      // Redirect to arena
+      router.push("/arena")
+    } catch (err) {
+      setError("Network error. Try again.")
+    } finally {
       setIsLoading(false)
-    }, 2000)
+    }
   }
 
   return (
@@ -51,10 +91,12 @@ export default function AuthPage() {
             </div>
             <div>
               <h1 className="text-xl font-bold uppercase tracking-wider text-foreground">
-                {"Access Terminal"}
+                {isSignUp ? "Register Terminal" : "Access Terminal"}
               </h1>
               <p className="mt-1 text-xs text-muted-foreground">
-                {"// authenticate to enter the arena"}
+                {isSignUp
+                  ? "// create your operative profile"
+                  : "// authenticate to enter the arena"}
               </p>
             </div>
           </div>
@@ -63,7 +105,7 @@ export default function AuthPage() {
           <div className="mb-6 rounded-sm border border-border bg-secondary/50 p-3">
             <div className="flex items-center gap-2 text-xs text-muted-foreground">
               <span className="text-primary">{"$"}</span>
-              <span>{"system.auth --status"}</span>
+              <span>{isSignUp ? "system.register --new" : "system.auth --status"}</span>
             </div>
             <div className="mt-1 flex items-center gap-2 text-xs">
               <span className="text-primary">{">"}</span>
@@ -72,56 +114,54 @@ export default function AuthPage() {
             </div>
           </div>
 
-          {/* Google Sign In button */}
-          <button
-            onClick={handleGoogleSignIn}
-            disabled={isLoading}
-            className="flex w-full items-center justify-center gap-3 rounded-sm border border-border bg-secondary px-4 py-3 text-sm font-bold uppercase tracking-widest text-foreground transition-all hover:border-primary hover:text-primary disabled:opacity-50"
-          >
-            <svg className="h-5 w-5" viewBox="0 0 24 24">
-              <path
-                d="M22.56 12.25c0-.78-.07-1.53-.2-2.25H12v4.26h5.92a5.06 5.06 0 0 1-2.2 3.32v2.77h3.57c2.08-1.92 3.28-4.74 3.28-8.1z"
-                fill="#4285F4"
-              />
-              <path
-                d="M12 23c2.97 0 5.46-.98 7.28-2.66l-3.57-2.77c-.98.66-2.23 1.06-3.71 1.06-2.86 0-5.29-1.93-6.16-4.53H2.18v2.84C3.99 20.53 7.7 23 12 23z"
-                fill="#34A853"
-              />
-              <path
-                d="M5.84 14.09c-.22-.66-.35-1.36-.35-2.09s.13-1.43.35-2.09V7.07H2.18C1.43 8.55 1 10.22 1 12s.43 3.45 1.18 4.93l2.85-2.22.81-.62z"
-                fill="#FBBC05"
-              />
-              <path
-                d="M12 5.38c1.62 0 3.06.56 4.21 1.64l3.15-3.15C17.45 2.09 14.97 1 12 1 7.7 1 3.99 3.47 2.18 7.07l3.66 2.84c.87-2.6 3.3-4.53 6.16-4.53z"
-                fill="#EA4335"
-              />
-            </svg>
-            {isLoading ? "Connecting..." : "Sign in with Google"}
-          </button>
-
-          {/* Divider */}
-          <div className="my-6 flex items-center gap-4">
-            <div className="h-px flex-1 bg-border" />
-            <span className="text-xs text-muted-foreground">{"or"}</span>
-            <div className="h-px flex-1 bg-border" />
-          </div>
+          {/* Error message */}
+          {error && (
+            <div className="mb-4 rounded-sm border border-red-500/30 bg-red-500/10 p-3 text-xs text-red-400">
+              <span className="text-red-500">{"ERROR: "}</span>
+              {error}
+            </div>
+          )}
 
-          {/* Username/Email mock fields */}
-          <div className="flex flex-col gap-4">
+          {/* Auth form */}
+          <form onSubmit={handleSubmit} className="flex flex-col gap-4">
             <div>
               <label
                 htmlFor="username"
                 className="mb-1 block text-xs uppercase tracking-widest text-muted-foreground"
               >
-                Handle
+                Handle{isSignUp ? "" : " / Email"}
               </label>
               <input
                 id="username"
                 type="text"
+                value={username}
+                onChange={(e) => setUsername(e.target.value)}
                 placeholder="your_callsign"
+                required
                 className="w-full rounded-sm border border-border bg-input px-3 py-2 text-sm text-foreground placeholder:text-muted-foreground focus:border-primary focus:outline-none focus:ring-1 focus:ring-primary"
               />
             </div>
+
+            {isSignUp && (
+              <div>
+                <label
+                  htmlFor="email"
+                  className="mb-1 block text-xs uppercase tracking-widest text-muted-foreground"
+                >
+                  Comm Channel (Email)
+                </label>
+                <input
+                  id="email"
+                  type="email"
+                  value={email}
+                  onChange={(e) => setEmail(e.target.value)}
+                  placeholder="operative@domain.com"
+                  required
+                  className="w-full rounded-sm border border-border bg-input px-3 py-2 text-sm text-foreground placeholder:text-muted-foreground focus:border-primary focus:outline-none focus:ring-1 focus:ring-primary"
+                />
+              </div>
+            )}
+
             <div>
               <label
                 htmlFor="password"
@@ -132,21 +172,40 @@ export default function AuthPage() {
               <input
                 id="password"
                 type="password"
+                value={password}
+                onChange={(e) => setPassword(e.target.value)}
                 placeholder="**************"
+                required
+                minLength={6}
                 className="w-full rounded-sm border border-border bg-input px-3 py-2 text-sm text-foreground placeholder:text-muted-foreground focus:border-primary focus:outline-none focus:ring-1 focus:ring-primary"
               />
             </div>
-            <button className="animate-pulse-glow w-full rounded-sm border border-primary bg-primary px-4 py-2.5 text-sm font-bold uppercase tracking-widest text-primary-foreground transition-all hover:bg-primary/90">
-              Initialize Session
+
+            <button
+              type="submit"
+              disabled={isLoading}
+              className="animate-pulse-glow w-full rounded-sm border border-primary bg-primary px-4 py-2.5 text-sm font-bold uppercase tracking-widest text-primary-foreground transition-all hover:bg-primary/90 disabled:opacity-50"
+            >
+              {isLoading
+                ? "Connecting..."
+                : isSignUp
+                  ? "Create Operative"
+                  : "Initialize Session"}
             </button>
-          </div>
+          </form>
 
-          {/* Footer text */}
+          {/* Toggle signup/signin */}
           <p className="mt-6 text-center text-xs text-muted-foreground">
-            {"New operative? "}
-            <Link href="/auth" className="text-primary hover:underline">
-              {"Request Access"}
-            </Link>
+            {isSignUp ? "Already an operative? " : "New operative? "}
+            <button
+              onClick={() => {
+                setIsSignUp(!isSignUp)
+                setError("")
+              }}
+              className="text-primary hover:underline"
+            >
+              {isSignUp ? "Sign In" : "Request Access"}
+            </button>
           </p>
         </div>
       </div>
diff --git a/lib/auth.ts b/lib/auth.ts
new file mode 100644
index 0000000..2c34fcd
--- /dev/null
+++ b/lib/auth.ts
@@ -0,0 +1,65 @@
+// ============================================================
+// JWT Auth Utilities
+// ============================================================
+
+import jwt from "jsonwebtoken";
+import bcrypt from "bcryptjs";
+import { NextRequest } from "next/server";
+
+const JWT_SECRET = process.env.JWT_SECRET || "fallback_dev_secret";
+const JWT_EXPIRES_IN = "7d";
+
+export interface JwtPayload {
+  userId: string;
+  username: string;
+  email: string;
+}
+
+// ---- Password Hashing ----
+
+export async function hashPassword(password: string): Promise<string> {
+  return bcrypt.hash(password, 12);
+}
+
+export async function verifyPassword(
+  password: string,
+  hash: string
+): Promise<boolean> {
+  return bcrypt.compare(password, hash);
+}
+
+// ---- JWT Token ----
+
+export function signToken(payload: JwtPayload): string {
+  return jwt.sign(payload, JWT_SECRET, { expiresIn: JWT_EXPIRES_IN });
+}
+
+export function verifyToken(token: string): JwtPayload {
+  return jwt.verify(token, JWT_SECRET) as JwtPayload;
+}
+
+// ---- Extract user from request ----
+
+export function getUserFromRequest(req: NextRequest): JwtPayload | null {
+  // Check Authorization header first
+  const authHeader = req.headers.get("authorization");
+  if (authHeader?.startsWith("Bearer ")) {
+    try {
+      return verifyToken(authHeader.slice(7));
+    } catch {
+      return null;
+    }
+  }
+
+  // Check cookie as fallback
+  const token = req.cookies.get("token")?.value;
+  if (token) {
+    try {
+      return verifyToken(token);
+    } catch {
+      return null;
+    }
+  }
+
+  return null;
+}
diff --git a/lib/db.ts b/lib/db.ts
new file mode 100644
index 0000000..74aa3b1
--- /dev/null
+++ b/lib/db.ts
@@ -0,0 +1,7 @@
+import { PrismaClient } from "../prisma/generated/prisma/client";
+
+const globalForPrisma = globalThis as unknown as { prisma: PrismaClient };
+
+export const prisma = globalForPrisma.prisma || new PrismaClient();
+
+if (process.env.NODE_ENV !== "production") globalForPrisma.prisma = prisma;
diff --git a/lib/piston.ts b/lib/piston.ts
new file mode 100644
index 0000000..ac235d3
--- /dev/null
+++ b/lib/piston.ts
@@ -0,0 +1,88 @@
+// ============================================================
+// Piston Code Execution Client
+// ============================================================
+// Runs user code against the Piston API (self-hosted or public).
+
+const PISTON_URL = process.env.PISTON_URL || "https://emkc.org/api/v2/piston";
+
+// Language → Piston runtime mapping
+const LANGUAGE_MAP: Record<string, { language: string; version: string }> = {
+  python: { language: "python", version: "3.10.0" },
+  python3: { language: "python", version: "3.10.0" },
+  javascript: { language: "javascript", version: "18.15.0" },
+  js: { language: "javascript", version: "18.15.0" },
+  typescript: { language: "typescript", version: "5.0.3" },
+  ts: { language: "typescript", version: "5.0.3" },
+  cpp: { language: "c++", version: "10.2.0" },
+  "c++": { language: "c++", version: "10.2.0" },
+  c: { language: "c", version: "10.2.0" },
+  java: { language: "java", version: "15.0.2" },
+  go: { language: "go", version: "1.16.2" },
+  rust: { language: "rust", version: "1.68.2" },
+};
+
+export interface PistonResult {
+  run: {
+    stdout: string;
+    stderr: string;
+    code: number;
+    signal: string | null;
+    output: string;
+  };
+  compile?: {
+    stdout: string;
+    stderr: string;
+    code: number;
+    signal: string | null;
+    output: string;
+  };
+  language: string;
+  version: string;
+}
+
+export async function runCode(
+  language: string,
+  code: string,
+  stdin: string = ""
+): Promise<PistonResult> {
+  const runtime = LANGUAGE_MAP[language.toLowerCase()];
+
+  if (!runtime) {
+    throw new Error(
+      `Unsupported language: ${language}. Supported: ${Object.keys(LANGUAGE_MAP).join(", ")}`
+    );
+  }
+
+  const response = await fetch(`${PISTON_URL}/api/v2/execute`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      language: runtime.language,
+      version: runtime.version,
+      files: [{ name: `main`, content: code }],
+      stdin,
+      run_timeout: 10000, // 10 second timeout
+      compile_timeout: 10000,
+      compile_memory_limit: 256000000, // 256MB
+      run_memory_limit: 256000000,
+    }),
+  });
+
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Piston execution failed (${response.status}): ${text}`);
+  }
+
+  return response.json();
+}
+
+// Get available runtimes from Piston
+export async function getRuntimes(): Promise<
+  Array<{ language: string; version: string; aliases: string[] }>
+> {
+  const response = await fetch(`${PISTON_URL}/api/v2/runtimes`);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch runtimes: ${response.status}`);
+  }
+  return response.json();
+}
diff --git a/package-lock.json b/package-lock.json
index d4a7982..2c2ab86 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -8,10 +8,14 @@
       "name": "compile-n-conquer",
       "version": "0.1.0",
       "dependencies": {
+        "@prisma/client": "^7.3.0",
         "backboard-sdk": "^1.4.12",
+        "bcryptjs": "^3.0.3",
         "clsx": "^2.1.1",
+        "jsonwebtoken": "^9.0.3",
         "lucide-react": "^0.460.0",
         "next": "16.1.6",
+        "prisma": "^7.3.0",
         "react": "19.2.3",
         "react-dom": "19.2.3",
         "tailwind-merge": "^2.5.4",
@@ -19,6 +23,8 @@
       },
       "devDependencies": {
         "@tailwindcss/postcss": "^4",
+        "@types/bcryptjs": "^2.4.6",
+        "@types/jsonwebtoken": "^9.0.10",
         "@types/node": "^20",
         "@types/react": "^19",
         "@types/react-dom": "^19",
@@ -72,6 +78,7 @@
       "integrity": "sha512-CGOfOJqWjg2qW/Mb6zNsDm+u5vFQ8DxXfbM09z69p5Z6+mE1ikP2jUXw+j42Pf1XTYED2Rni5f95npYeuwMDQA==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@babel/code-frame": "^7.29.0",
         "@babel/generator": "^7.29.0",
@@ -281,6 +288,67 @@
         "node": ">=6.9.0"
       }
     },
+    "node_modules/@chevrotain/cst-dts-gen": {
+      "version": "10.5.0",
+      "resolved": "https://registry.npmjs.org/@chevrotain/cst-dts-gen/-/cst-dts-gen-10.5.0.tgz",
+      "integrity": "sha512-lhmC/FyqQ2o7pGK4Om+hzuDrm9rhFYIJ/AXoQBeongmn870Xeb0L6oGEiuR8nohFNL5sMaQEJWCxr1oIVIVXrw==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@chevrotain/gast": "10.5.0",
+        "@chevrotain/types": "10.5.0",
+        "lodash": "4.17.21"
+      }
+    },
+    "node_modules/@chevrotain/gast": {
+      "version": "10.5.0",
+      "resolved": "https://registry.npmjs.org/@chevrotain/gast/-/gast-10.5.0.tgz",
+      "integrity": "sha512-pXdMJ9XeDAbgOWKuD1Fldz4ieCs6+nLNmyVhe2gZVqoO7v8HXuHYs5OV2EzUtbuai37TlOAQHrTDvxMnvMJz3A==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@chevrotain/types": "10.5.0",
+        "lodash": "4.17.21"
+      }
+    },
+    "node_modules/@chevrotain/types": {
+      "version": "10.5.0",
+      "resolved": "https://registry.npmjs.org/@chevrotain/types/-/types-10.5.0.tgz",
+      "integrity": "sha512-f1MAia0x/pAVPWH/T73BJVyO2XU5tI4/iE7cnxb7tqdNTNhQI3Uq3XkqcoteTmD4t1aM0LbHCJOhgIDn07kl2A==",
+      "license": "Apache-2.0"
+    },
+    "node_modules/@chevrotain/utils": {
+      "version": "10.5.0",
+      "resolved": "https://registry.npmjs.org/@chevrotain/utils/-/utils-10.5.0.tgz",
+      "integrity": "sha512-hBzuU5+JjB2cqNZyszkDHZgOSrUUT8V3dhgRl8Q9Gp6dAj/H5+KILGjbhDpc3Iy9qmqlm/akuOI2ut9VUtzJxQ==",
+      "license": "Apache-2.0"
+    },
+    "node_modules/@electric-sql/pglite": {
+      "version": "0.3.15",
+      "resolved": "https://registry.npmjs.org/@electric-sql/pglite/-/pglite-0.3.15.tgz",
+      "integrity": "sha512-Cj++n1Mekf9ETfdc16TlDi+cDDQF0W7EcbyRHYOAeZdsAe8M/FJg18itDTSwyHfar2WIezawM9o0EKaRGVKygQ==",
+      "license": "Apache-2.0",
+      "peer": true
+    },
+    "node_modules/@electric-sql/pglite-socket": {
+      "version": "0.0.20",
+      "resolved": "https://registry.npmjs.org/@electric-sql/pglite-socket/-/pglite-socket-0.0.20.tgz",
+      "integrity": "sha512-J5nLGsicnD9wJHnno9r+DGxfcZWh+YJMCe0q/aCgtG6XOm9Z7fKeite8IZSNXgZeGltSigM9U/vAWZQWdgcSFg==",
+      "license": "Apache-2.0",
+      "bin": {
+        "pglite-server": "dist/scripts/server.js"
+      },
+      "peerDependencies": {
+        "@electric-sql/pglite": "0.3.15"
+      }
+    },
+    "node_modules/@electric-sql/pglite-tools": {
+      "version": "0.2.20",
+      "resolved": "https://registry.npmjs.org/@electric-sql/pglite-tools/-/pglite-tools-0.2.20.tgz",
+      "integrity": "sha512-BK50ZnYa3IG7ztXhtgYf0Q7zijV32Iw1cYS8C+ThdQlwx12V5VZ9KRJ42y82Hyb4PkTxZQklVQA9JHyUlex33A==",
+      "license": "Apache-2.0",
+      "peerDependencies": {
+        "@electric-sql/pglite": "0.3.15"
+      }
+    },
     "node_modules/@emnapi/core": {
       "version": "1.8.1",
       "resolved": "https://registry.npmjs.org/@emnapi/core/-/core-1.8.1.tgz",
@@ -458,6 +526,18 @@
         "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
       }
     },
+    "node_modules/@hono/node-server": {
+      "version": "1.19.9",
+      "resolved": "https://registry.npmjs.org/@hono/node-server/-/node-server-1.19.9.tgz",
+      "integrity": "sha512-vHL6w3ecZsky+8P5MD+eFfaGTyCeOHUIFYMGpQGbrBTSmNNoxv0if69rEZ5giu36weC5saFuznL411gRX7bJDw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18.14.1"
+      },
+      "peerDependencies": {
+        "hono": "^4"
+      }
+    },
     "node_modules/@humanfs/core": {
       "version": "0.19.1",
       "resolved": "https://registry.npmjs.org/@humanfs/core/-/core-0.19.1.tgz",
@@ -1026,6 +1106,19 @@
         "@jridgewell/sourcemap-codec": "^1.4.14"
       }
     },
+    "node_modules/@mrleebo/prisma-ast": {
+      "version": "0.13.1",
+      "resolved": "https://registry.npmjs.org/@mrleebo/prisma-ast/-/prisma-ast-0.13.1.tgz",
+      "integrity": "sha512-XyroGQXcHrZdvmrGJvsA9KNeOOgGMg1Vg9OlheUsBOSKznLMDl+YChxbkboRHvtFYJEMRYmlV3uoo/njCw05iw==",
+      "license": "MIT",
+      "dependencies": {
+        "chevrotain": "^10.5.0",
+        "lilconfig": "^2.1.0"
+      },
+      "engines": {
+        "node": ">=16"
+      }
+    },
     "node_modules/@napi-rs/wasm-runtime": {
       "version": "0.2.12",
       "resolved": "https://registry.npmjs.org/@napi-rs/wasm-runtime/-/wasm-runtime-0.2.12.tgz",
@@ -1231,6 +1324,159 @@
         "node": ">=12.4.0"
       }
     },
+    "node_modules/@prisma/client": {
+      "version": "7.3.0",
+      "resolved": "https://registry.npmjs.org/@prisma/client/-/client-7.3.0.tgz",
+      "integrity": "sha512-FXBIxirqQfdC6b6HnNgxGmU7ydCPEPk7maHMOduJJfnTP+MuOGa15X4omjR/zpPUUpm8ef/mEFQjJudOGkXFcQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@prisma/client-runtime-utils": "7.3.0"
+      },
+      "engines": {
+        "node": "^20.19 || ^22.12 || >=24.0"
+      },
+      "peerDependencies": {
+        "prisma": "*",
+        "typescript": ">=5.4.0"
+      },
+      "peerDependenciesMeta": {
+        "prisma": {
+          "optional": true
+        },
+        "typescript": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@prisma/client-runtime-utils": {
+      "version": "7.3.0",
+      "resolved": "https://registry.npmjs.org/@prisma/client-runtime-utils/-/client-runtime-utils-7.3.0.tgz",
+      "integrity": "sha512-dG/ceD9c+tnXATPk8G+USxxYM9E6UdMTnQeQ+1SZUDxTz7SgQcfxEqafqIQHcjdlcNK/pvmmLfSwAs3s2gYwUw==",
+      "license": "Apache-2.0"
+    },
+    "node_modules/@prisma/config": {
+      "version": "7.3.0",
+      "resolved": "https://registry.npmjs.org/@prisma/config/-/config-7.3.0.tgz",
+      "integrity": "sha512-QyMV67+eXF7uMtKxTEeQqNu/Be7iH+3iDZOQZW5ttfbSwBamCSdwPszA0dum+Wx27I7anYTPLmRmMORKViSW1A==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "c12": "3.1.0",
+        "deepmerge-ts": "7.1.5",
+        "effect": "3.18.4",
+        "empathic": "2.0.0"
+      }
+    },
+    "node_modules/@prisma/debug": {
+      "version": "7.3.0",
+      "resolved": "https://registry.npmjs.org/@prisma/debug/-/debug-7.3.0.tgz",
+      "integrity": "sha512-yh/tHhraCzYkffsI1/3a7SHX8tpgbJu1NPnuxS4rEpJdWAUDHUH25F1EDo6PPzirpyLNkgPPZdhojQK804BGtg==",
+      "license": "Apache-2.0"
+    },
+    "node_modules/@prisma/dev": {
+      "version": "0.20.0",
+      "resolved": "https://registry.npmjs.org/@prisma/dev/-/dev-0.20.0.tgz",
+      "integrity": "sha512-ovlBYwWor0OzG+yH4J3Ot+AneD818BttLA+Ii7wjbcLHUrnC4tbUPVGyNd3c/+71KETPKZfjhkTSpdS15dmXNQ==",
+      "license": "ISC",
+      "dependencies": {
+        "@electric-sql/pglite": "0.3.15",
+        "@electric-sql/pglite-socket": "0.0.20",
+        "@electric-sql/pglite-tools": "0.2.20",
+        "@hono/node-server": "1.19.9",
+        "@mrleebo/prisma-ast": "0.13.1",
+        "@prisma/get-platform": "7.2.0",
+        "@prisma/query-plan-executor": "7.2.0",
+        "foreground-child": "3.3.1",
+        "get-port-please": "3.2.0",
+        "hono": "4.11.4",
+        "http-status-codes": "2.3.0",
+        "pathe": "2.0.3",
+        "proper-lockfile": "4.1.2",
+        "remeda": "2.33.4",
+        "std-env": "3.10.0",
+        "valibot": "1.2.0",
+        "zeptomatch": "2.1.0"
+      }
+    },
+    "node_modules/@prisma/engines": {
+      "version": "7.3.0",
+      "resolved": "https://registry.npmjs.org/@prisma/engines/-/engines-7.3.0.tgz",
+      "integrity": "sha512-cWRQoPDXPtR6stOWuWFZf9pHdQ/o8/QNWn0m0zByxf5Kd946Q875XdEJ52pEsX88vOiXUmjuPG3euw82mwQNMg==",
+      "hasInstallScript": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@prisma/debug": "7.3.0",
+        "@prisma/engines-version": "7.3.0-16.9d6ad21cbbceab97458517b147a6a09ff43aa735",
+        "@prisma/fetch-engine": "7.3.0",
+        "@prisma/get-platform": "7.3.0"
+      }
+    },
+    "node_modules/@prisma/engines-version": {
+      "version": "7.3.0-16.9d6ad21cbbceab97458517b147a6a09ff43aa735",
+      "resolved": "https://registry.npmjs.org/@prisma/engines-version/-/engines-version-7.3.0-16.9d6ad21cbbceab97458517b147a6a09ff43aa735.tgz",
+      "integrity": "sha512-IH2va2ouUHihyiTTRW889LjKAl1CusZOvFfZxCDNpjSENt7g2ndFsK0vdIw/72v7+jCN6YgkHmdAP/BI7SDgyg==",
+      "license": "Apache-2.0"
+    },
+    "node_modules/@prisma/engines/node_modules/@prisma/get-platform": {
+      "version": "7.3.0",
+      "resolved": "https://registry.npmjs.org/@prisma/get-platform/-/get-platform-7.3.0.tgz",
+      "integrity": "sha512-N7c6m4/I0Q6JYmWKP2RCD/sM9eWiyCPY98g5c0uEktObNSZnugW2U/PO+pwL0UaqzxqTXt7gTsYsb0FnMnJNbg==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@prisma/debug": "7.3.0"
+      }
+    },
+    "node_modules/@prisma/fetch-engine": {
+      "version": "7.3.0",
+      "resolved": "https://registry.npmjs.org/@prisma/fetch-engine/-/fetch-engine-7.3.0.tgz",
+      "integrity": "sha512-Mm0F84JMqM9Vxk70pzfNpGJ1lE4hYjOeLMu7nOOD1i83nvp8MSAcFYBnHqLvEZiA6onUR+m8iYogtOY4oPO5lQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@prisma/debug": "7.3.0",
+        "@prisma/engines-version": "7.3.0-16.9d6ad21cbbceab97458517b147a6a09ff43aa735",
+        "@prisma/get-platform": "7.3.0"
+      }
+    },
+    "node_modules/@prisma/fetch-engine/node_modules/@prisma/get-platform": {
+      "version": "7.3.0",
+      "resolved": "https://registry.npmjs.org/@prisma/get-platform/-/get-platform-7.3.0.tgz",
+      "integrity": "sha512-N7c6m4/I0Q6JYmWKP2RCD/sM9eWiyCPY98g5c0uEktObNSZnugW2U/PO+pwL0UaqzxqTXt7gTsYsb0FnMnJNbg==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@prisma/debug": "7.3.0"
+      }
+    },
+    "node_modules/@prisma/get-platform": {
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/@prisma/get-platform/-/get-platform-7.2.0.tgz",
+      "integrity": "sha512-k1V0l0Td1732EHpAfi2eySTezyllok9dXb6UQanajkJQzPUGi3vO2z7jdkz67SypFTdmbnyGYxvEvYZdZsMAVA==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@prisma/debug": "7.2.0"
+      }
+    },
+    "node_modules/@prisma/get-platform/node_modules/@prisma/debug": {
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/@prisma/debug/-/debug-7.2.0.tgz",
+      "integrity": "sha512-YSGTiSlBAVJPzX4ONZmMotL+ozJwQjRmZweQNIq/ER0tQJKJynNkRB3kyvt37eOfsbMCXk3gnLF6J9OJ4QWftw==",
+      "license": "Apache-2.0"
+    },
+    "node_modules/@prisma/query-plan-executor": {
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/@prisma/query-plan-executor/-/query-plan-executor-7.2.0.tgz",
+      "integrity": "sha512-EOZmNzcV8uJ0mae3DhTsiHgoNCuu1J9mULQpGCh62zN3PxPTd+qI9tJvk5jOst8WHKQNwJWR3b39t0XvfBB0WQ==",
+      "license": "Apache-2.0"
+    },
+    "node_modules/@prisma/studio-core": {
+      "version": "0.13.1",
+      "resolved": "https://registry.npmjs.org/@prisma/studio-core/-/studio-core-0.13.1.tgz",
+      "integrity": "sha512-agdqaPEePRHcQ7CexEfkX1RvSH9uWDb6pXrZnhCRykhDFAV0/0P3d07WtfiY8hZWb7oRU4v+NkT4cGFHkQJIPg==",
+      "license": "Apache-2.0",
+      "peerDependencies": {
+        "@types/react": "^18.0.0 || ^19.0.0",
+        "react": "^18.0.0 || ^19.0.0",
+        "react-dom": "^18.0.0 || ^19.0.0"
+      }
+    },
     "node_modules/@rtsao/scc": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/@rtsao/scc/-/scc-1.1.0.tgz",
@@ -1238,6 +1484,12 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/@standard-schema/spec": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@standard-schema/spec/-/spec-1.1.0.tgz",
+      "integrity": "sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==",
+      "license": "MIT"
+    },
     "node_modules/@swc/helpers": {
       "version": "0.5.15",
       "resolved": "https://registry.npmjs.org/@swc/helpers/-/helpers-0.5.15.tgz",
@@ -1529,6 +1781,13 @@
         "tslib": "^2.4.0"
       }
     },
+    "node_modules/@types/bcryptjs": {
+      "version": "2.4.6",
+      "resolved": "https://registry.npmjs.org/@types/bcryptjs/-/bcryptjs-2.4.6.tgz",
+      "integrity": "sha512-9xlo6R2qDs5uixm0bcIqCeMCE6HiQsIyel9KQySStiyqNl2tnj2mP3DX1Nf56MD6KMenNNlBBsy3LJ7gUEQPXQ==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/@types/estree": {
       "version": "1.0.8",
       "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz",
@@ -1550,6 +1809,24 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/@types/jsonwebtoken": {
+      "version": "9.0.10",
+      "resolved": "https://registry.npmjs.org/@types/jsonwebtoken/-/jsonwebtoken-9.0.10.tgz",
+      "integrity": "sha512-asx5hIG9Qmf/1oStypjanR7iKTv0gXQ1Ov/jfrX6kS/EO0OFni8orbmGCn0672NHR3kXHwpAwR+B368ZGN/2rA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/ms": "*",
+        "@types/node": "*"
+      }
+    },
+    "node_modules/@types/ms": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/@types/ms/-/ms-2.1.0.tgz",
+      "integrity": "sha512-GsCCIZDE/p3i96vtEqx+7dBUGXrc7zeSK3wwPHIaRThS+9OhWIXRqzs4d6k1SVU8g91DrNRWxWUGhp5KXQb2VA==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/@types/node": {
       "version": "20.19.33",
       "resolved": "https://registry.npmjs.org/@types/node/-/node-20.19.33.tgz",
@@ -1564,8 +1841,8 @@
       "version": "19.2.13",
       "resolved": "https://registry.npmjs.org/@types/react/-/react-19.2.13.tgz",
       "integrity": "sha512-KkiJeU6VbYbUOp5ITMIc7kBfqlYkKA5KhEHVrGMmUUMt7NeaZg65ojdPk+FtNrBAOXNVM5QM72jnADjM+XVRAQ==",
-      "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "csstype": "^3.2.2"
       }
@@ -1625,6 +1902,7 @@
       "integrity": "sha512-BtE0k6cjwjLZoZixN0t5AKP0kSzlGu7FctRXYuPAm//aaiZhmfq1JwdYpYr1brzEspYyFeF+8XF5j2VK6oalrA==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@typescript-eslint/scope-manager": "8.54.0",
         "@typescript-eslint/types": "8.54.0",
@@ -2124,6 +2402,7 @@
       "integrity": "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "bin": {
         "acorn": "bin/acorn"
       },
@@ -2390,6 +2669,15 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/aws-ssl-profiles": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/aws-ssl-profiles/-/aws-ssl-profiles-1.1.2.tgz",
+      "integrity": "sha512-NZKeq9AfyQvEeNlN0zSYAaWrmBffJh3IELMZfRpJVWgrpEbtEpnjvzqBPf+mxoI287JohRDoa+/nsfqqiZmF6g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 6.0.0"
+      }
+    },
     "node_modules/axe-core": {
       "version": "4.11.1",
       "resolved": "https://registry.npmjs.org/axe-core/-/axe-core-4.11.1.tgz",
@@ -2439,6 +2727,15 @@
         "baseline-browser-mapping": "dist/cli.js"
       }
     },
+    "node_modules/bcryptjs": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/bcryptjs/-/bcryptjs-3.0.3.tgz",
+      "integrity": "sha512-GlF5wPWnSa/X5LKM1o0wz0suXIINz1iHRLvTS+sLyi7XPbe5ycmYI3DlZqVGZZtDgl4DmasFg7gOB3JYbphV5g==",
+      "license": "BSD-3-Clause",
+      "bin": {
+        "bcrypt": "bin/bcrypt"
+      }
+    },
     "node_modules/brace-expansion": {
       "version": "1.1.12",
       "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz",
@@ -2483,6 +2780,7 @@
         }
       ],
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "baseline-browser-mapping": "^2.9.0",
         "caniuse-lite": "^1.0.30001759",
@@ -2497,6 +2795,40 @@
         "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7"
       }
     },
+    "node_modules/buffer-equal-constant-time": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/buffer-equal-constant-time/-/buffer-equal-constant-time-1.0.1.tgz",
+      "integrity": "sha512-zRpUiDwd/xk6ADqPMATG8vc9VPrkck7T07OIx0gnjmJAnHnTVXNQG3vfvWNuiZIkwu9KrKdA1iJKfsfTVxE6NA==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/c12": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/c12/-/c12-3.1.0.tgz",
+      "integrity": "sha512-uWoS8OU1MEIsOv8p/5a82c3H31LsWVR5qiyXVfBNOzfffjUWtPnhAb4BYI2uG2HfGmZmFjCtui5XNWaps+iFuw==",
+      "license": "MIT",
+      "dependencies": {
+        "chokidar": "^4.0.3",
+        "confbox": "^0.2.2",
+        "defu": "^6.1.4",
+        "dotenv": "^16.6.1",
+        "exsolve": "^1.0.7",
+        "giget": "^2.0.0",
+        "jiti": "^2.4.2",
+        "ohash": "^2.0.11",
+        "pathe": "^2.0.3",
+        "perfect-debounce": "^1.0.0",
+        "pkg-types": "^2.2.0",
+        "rc9": "^2.1.2"
+      },
+      "peerDependencies": {
+        "magicast": "^0.3.5"
+      },
+      "peerDependenciesMeta": {
+        "magicast": {
+          "optional": true
+        }
+      }
+    },
     "node_modules/call-bind": {
       "version": "1.0.8",
       "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.8.tgz",
@@ -2593,6 +2925,44 @@
         "url": "https://github.com/chalk/chalk?sponsor=1"
       }
     },
+    "node_modules/chevrotain": {
+      "version": "10.5.0",
+      "resolved": "https://registry.npmjs.org/chevrotain/-/chevrotain-10.5.0.tgz",
+      "integrity": "sha512-Pkv5rBY3+CsHOYfV5g/Vs5JY9WTHHDEKOlohI2XeygaZhUeqhAlldZ8Hz9cRmxu709bvS08YzxHdTPHhffc13A==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@chevrotain/cst-dts-gen": "10.5.0",
+        "@chevrotain/gast": "10.5.0",
+        "@chevrotain/types": "10.5.0",
+        "@chevrotain/utils": "10.5.0",
+        "lodash": "4.17.21",
+        "regexp-to-ast": "0.5.0"
+      }
+    },
+    "node_modules/chokidar": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-4.0.3.tgz",
+      "integrity": "sha512-Qgzu8kfBvo+cA4962jnP1KkS6Dop5NS6g7R5LFYJr4b8Ub94PPQXUksCw9PvXoeXPRRddRNC5C1JQUR2SMGtnA==",
+      "license": "MIT",
+      "dependencies": {
+        "readdirp": "^4.0.1"
+      },
+      "engines": {
+        "node": ">= 14.16.0"
+      },
+      "funding": {
+        "url": "https://paulmillr.com/funding/"
+      }
+    },
+    "node_modules/citty": {
+      "version": "0.1.6",
+      "resolved": "https://registry.npmjs.org/citty/-/citty-0.1.6.tgz",
+      "integrity": "sha512-tskPPKEs8D2KPafUypv2gxwJP8h/OaJmC82QQGGDQcHvXX43xF2VDACcJVmZ0EuSxkpO9Kc4MlrA3q0+FG58AQ==",
+      "license": "MIT",
+      "dependencies": {
+        "consola": "^3.2.3"
+      }
+    },
     "node_modules/client-only": {
       "version": "0.0.1",
       "resolved": "https://registry.npmjs.org/client-only/-/client-only-0.0.1.tgz",
@@ -2647,6 +3017,21 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/confbox": {
+      "version": "0.2.4",
+      "resolved": "https://registry.npmjs.org/confbox/-/confbox-0.2.4.tgz",
+      "integrity": "sha512-ysOGlgTFbN2/Y6Cg3Iye8YKulHw+R2fNXHrgSmXISQdMnomY6eNDprVdW9R5xBguEqI954+S6709UyiO7B+6OQ==",
+      "license": "MIT"
+    },
+    "node_modules/consola": {
+      "version": "3.4.2",
+      "resolved": "https://registry.npmjs.org/consola/-/consola-3.4.2.tgz",
+      "integrity": "sha512-5IKcdX0nnYavi6G7TtOhwkYzyjfJlatbjMjuLSfE2kYT5pMDOilZ4OvMhi637CcDICTmz3wARPoyhqyX1Y+XvA==",
+      "license": "MIT",
+      "engines": {
+        "node": "^14.18.0 || >=16.10.0"
+      }
+    },
     "node_modules/convert-source-map": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz",
@@ -2658,7 +3043,6 @@
       "version": "7.0.6",
       "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",
       "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==",
-      "dev": true,
       "license": "MIT",
       "dependencies": {
         "path-key": "^3.1.0",
@@ -2673,7 +3057,6 @@
       "version": "3.2.3",
       "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.2.3.tgz",
       "integrity": "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==",
-      "dev": true,
       "license": "MIT"
     },
     "node_modules/damerau-levenshtein": {
@@ -2771,6 +3154,15 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/deepmerge-ts": {
+      "version": "7.1.5",
+      "resolved": "https://registry.npmjs.org/deepmerge-ts/-/deepmerge-ts-7.1.5.tgz",
+      "integrity": "sha512-HOJkrhaYsweh+W+e74Yn7YStZOilkoPb6fycpwNLKzSPtruFs48nYis0zy5yJz1+ktUhHxoRDJ27RQAWLIJVJw==",
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=16.0.0"
+      }
+    },
     "node_modules/define-data-property": {
       "version": "1.1.4",
       "resolved": "https://registry.npmjs.org/define-data-property/-/define-data-property-1.1.4.tgz",
@@ -2807,6 +3199,12 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/defu": {
+      "version": "6.1.4",
+      "resolved": "https://registry.npmjs.org/defu/-/defu-6.1.4.tgz",
+      "integrity": "sha512-mEQCMmwJu317oSz8CwdIOdwf3xMif1ttiM8LTufzc3g6kR+9Pe236twL8j3IYT1F7GfRgGcW6MWxzZjLIkuHIg==",
+      "license": "MIT"
+    },
     "node_modules/delayed-stream": {
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz",
@@ -2816,6 +3214,21 @@
         "node": ">=0.4.0"
       }
     },
+    "node_modules/denque": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/denque/-/denque-2.1.0.tgz",
+      "integrity": "sha512-HVQE3AAb/pxF8fQAoiqpvg9i3evqug3hoiwakOyZAwJm+6vZehbkYXZ0l4JxS+I3QxM97v5aaRNhj8v5oBhekw==",
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=0.10"
+      }
+    },
+    "node_modules/destr": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/destr/-/destr-2.0.5.tgz",
+      "integrity": "sha512-ugFTXCtDZunbzasqBxrK93Ik/DRYsO6S/fedkWEMKqt04xZ4csmnmwGDBAb07QWNaGMAmnTIemsYZCksjATwsA==",
+      "license": "MIT"
+    },
     "node_modules/detect-libc": {
       "version": "2.1.2",
       "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.1.2.tgz",
@@ -2839,6 +3252,18 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/dotenv": {
+      "version": "16.6.1",
+      "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-16.6.1.tgz",
+      "integrity": "sha512-uBq4egWHTcTt33a72vpSG0z3HnPuIl6NqYcTrKEg2azoEyl2hpW0zqlxysq2pK9HlDIHyHyakeYaYnSAwd8bow==",
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://dotenvx.com"
+      }
+    },
     "node_modules/dunder-proto": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz",
@@ -2853,6 +3278,25 @@
         "node": ">= 0.4"
       }
     },
+    "node_modules/ecdsa-sig-formatter": {
+      "version": "1.0.11",
+      "resolved": "https://registry.npmjs.org/ecdsa-sig-formatter/-/ecdsa-sig-formatter-1.0.11.tgz",
+      "integrity": "sha512-nagl3RYrbNv6kQkeJIpt6NJZy8twLB/2vtz6yN9Z4vRKHN4/QZJIEbqohALSgwKdnksuY3k5Addp5lg8sVoVcQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "safe-buffer": "^5.0.1"
+      }
+    },
+    "node_modules/effect": {
+      "version": "3.18.4",
+      "resolved": "https://registry.npmjs.org/effect/-/effect-3.18.4.tgz",
+      "integrity": "sha512-b1LXQJLe9D11wfnOKAk3PKxuqYshQ0Heez+y5pnkd3jLj1yx9QhM72zZ9uUrOQyNvrs2GZZd/3maL0ZV18YuDA==",
+      "license": "MIT",
+      "dependencies": {
+        "@standard-schema/spec": "^1.0.0",
+        "fast-check": "^3.23.1"
+      }
+    },
     "node_modules/electron-to-chromium": {
       "version": "1.5.286",
       "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.286.tgz",
@@ -2867,6 +3311,15 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/empathic": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/empathic/-/empathic-2.0.0.tgz",
+      "integrity": "sha512-i6UzDscO/XfAcNYD75CfICkmfLedpyPDdozrLMmQc5ORaQcdMoc21OnlEylMIqI7U8eniKrPMxxtj8k0vhmJhA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=14"
+      }
+    },
     "node_modules/enhanced-resolve": {
       "version": "5.19.0",
       "resolved": "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-5.19.0.tgz",
@@ -3083,6 +3536,7 @@
       "integrity": "sha512-LEyamqS7W5HB3ujJyvi0HQK/dtVINZvd5mAAp9eT5S/ujByGjiZLCzPcHVzuXbpJDJF/cxwHlfceVUDZ2lnSTw==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@eslint-community/eslint-utils": "^4.8.0",
         "@eslint-community/regexpp": "^4.12.1",
@@ -3268,6 +3722,7 @@
       "integrity": "sha512-whOE1HFo/qJDyX4SnXzP4N6zOWn79WhnCUY/iDR0mPfQZO8wcYE4JClzI2oZrhBnnMUCBCHZhO6VQyoBU95mZA==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@rtsao/scc": "^1.1.0",
         "array-includes": "^3.1.9",
@@ -3501,6 +3956,34 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/exsolve": {
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/exsolve/-/exsolve-1.0.8.tgz",
+      "integrity": "sha512-LmDxfWXwcTArk8fUEnOfSZpHOJ6zOMUJKOtFLFqJLoKJetuQG874Uc7/Kki7zFLzYybmZhp1M7+98pfMqeX8yA==",
+      "license": "MIT"
+    },
+    "node_modules/fast-check": {
+      "version": "3.23.2",
+      "resolved": "https://registry.npmjs.org/fast-check/-/fast-check-3.23.2.tgz",
+      "integrity": "sha512-h5+1OzzfCC3Ef7VbtKdcv7zsstUQwUDlYpUTvjeUsJAssPgLn7QzbboPtL5ro04Mq0rPOsMzl7q5hIbRs2wD1A==",
+      "funding": [
+        {
+          "type": "individual",
+          "url": "https://github.com/sponsors/dubzzz"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/fast-check"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "pure-rand": "^6.1.0"
+      },
+      "engines": {
+        "node": ">=8.0.0"
+      }
+    },
     "node_modules/fast-deep-equal": {
       "version": "3.1.3",
       "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
@@ -3665,6 +4148,22 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/foreground-child": {
+      "version": "3.3.1",
+      "resolved": "https://registry.npmjs.org/foreground-child/-/foreground-child-3.3.1.tgz",
+      "integrity": "sha512-gIXjKqtFuWEgzFRJA9WCQeSJLZDjgJUOMCMzxtvFq/37KojM1BFGufqsCy0r4qSQmYLsZYMeyRqzIWOMup03sw==",
+      "license": "ISC",
+      "dependencies": {
+        "cross-spawn": "^7.0.6",
+        "signal-exit": "^4.0.1"
+      },
+      "engines": {
+        "node": ">=14"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
     "node_modules/form-data": {
       "version": "4.0.5",
       "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.5.tgz",
@@ -3733,6 +4232,15 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/generate-function": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/generate-function/-/generate-function-2.3.1.tgz",
+      "integrity": "sha512-eeB5GfMNeevm/GRYq20ShmsaGcmI81kIX2K9XQx5miC8KdHaC6Jm0qQ8ZNeGOi7wYB8OsdxKs+Y2oVuTFuVwKQ==",
+      "license": "MIT",
+      "dependencies": {
+        "is-property": "^1.0.2"
+      }
+    },
     "node_modules/generator-function": {
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/generator-function/-/generator-function-2.0.1.tgz",
@@ -3777,6 +4285,12 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/get-port-please": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/get-port-please/-/get-port-please-3.2.0.tgz",
+      "integrity": "sha512-I9QVvBw5U/hw3RmWpYKRumUeaDgxTPd401x364rLmWBJcOQ753eov1eTgzDqRG9bqFIfDc7gfzcQEWrUri3o1A==",
+      "license": "MIT"
+    },
     "node_modules/get-proto": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz",
@@ -3821,6 +4335,23 @@
         "url": "https://github.com/privatenumber/get-tsconfig?sponsor=1"
       }
     },
+    "node_modules/giget": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/giget/-/giget-2.0.0.tgz",
+      "integrity": "sha512-L5bGsVkxJbJgdnwyuheIunkGatUF/zssUoxxjACCseZYAVbaqdh9Tsmmlkl8vYan09H7sbvKt4pS8GqKLBrEzA==",
+      "license": "MIT",
+      "dependencies": {
+        "citty": "^0.1.6",
+        "consola": "^3.4.0",
+        "defu": "^6.1.4",
+        "node-fetch-native": "^1.6.6",
+        "nypm": "^0.6.0",
+        "pathe": "^2.0.3"
+      },
+      "bin": {
+        "giget": "dist/cli.mjs"
+      }
+    },
     "node_modules/glob-parent": {
       "version": "6.0.2",
       "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz",
@@ -3880,9 +4411,19 @@
       "version": "4.2.11",
       "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz",
       "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==",
-      "dev": true,
       "license": "ISC"
     },
+    "node_modules/grammex": {
+      "version": "3.1.12",
+      "resolved": "https://registry.npmjs.org/grammex/-/grammex-3.1.12.tgz",
+      "integrity": "sha512-6ufJOsSA7LcQehIJNCO7HIBykfM7DXQual0Ny780/DEcJIpBlHRvcqEBWGPYd7hrXL2GJ3oJI1MIhaXjWmLQOQ==",
+      "license": "MIT"
+    },
+    "node_modules/graphmatch": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/graphmatch/-/graphmatch-1.1.0.tgz",
+      "integrity": "sha512-0E62MaTW5rPZVRLyIJZG/YejmdA/Xr1QydHEw3Vt+qOKkMIOE8WDLc9ZX2bmAjtJFZcId4lEdrdmASsEy7D1QA=="
+    },
     "node_modules/has-bigints": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/has-bigints/-/has-bigints-1.1.0.tgz",
@@ -3991,6 +4532,38 @@
         "hermes-estree": "0.25.1"
       }
     },
+    "node_modules/hono": {
+      "version": "4.11.4",
+      "resolved": "https://registry.npmjs.org/hono/-/hono-4.11.4.tgz",
+      "integrity": "sha512-U7tt8JsyrxSRKspfhtLET79pU8K+tInj5QZXs1jSugO1Vq5dFj3kmZsRldo29mTBfcjDRVRXrEZ6LS63Cog9ZA==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=16.9.0"
+      }
+    },
+    "node_modules/http-status-codes": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/http-status-codes/-/http-status-codes-2.3.0.tgz",
+      "integrity": "sha512-RJ8XvFvpPM/Dmc5SV+dC4y5PCeOhT3x1Hq0NU3rjGeg5a/CqlhZ7uudknPwZFz4aeAXDcbAyaeP7GAo9lvngtA==",
+      "license": "MIT"
+    },
+    "node_modules/iconv-lite": {
+      "version": "0.7.2",
+      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.7.2.tgz",
+      "integrity": "sha512-im9DjEDQ55s9fL4EYzOAv0yMqmMBSZp6G0VvFyTMPKWxiSBHUj9NW/qqLmXUwXrrM7AvqSlTCfvqRb0cM8yYqw==",
+      "license": "MIT",
+      "dependencies": {
+        "safer-buffer": ">= 2.1.2 < 3.0.0"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
     "node_modules/ignore": {
       "version": "5.3.2",
       "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz",
@@ -4313,6 +4886,12 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/is-property": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/is-property/-/is-property-1.0.2.tgz",
+      "integrity": "sha512-Ks/IoX00TtClbGQr4TWXemAnktAQvYB7HzcCxDGqEZU6oCmb2INHuOoKxbtR+HFkmYWBKv/dOZtGRiAjDhj92g==",
+      "license": "MIT"
+    },
     "node_modules/is-regex": {
       "version": "1.2.1",
       "resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.2.1.tgz",
@@ -4469,7 +5048,6 @@
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
       "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==",
-      "dev": true,
       "license": "ISC"
     },
     "node_modules/iterator.prototype": {
@@ -4494,7 +5072,6 @@
       "version": "2.6.1",
       "resolved": "https://registry.npmjs.org/jiti/-/jiti-2.6.1.tgz",
       "integrity": "sha512-ekilCSN1jwRvIbgeg/57YFh8qQDNbwDb9xT/qu2DAHbFFZUicIl4ygVaAvzveMhMVr3LnpSKTNnwt8PoOfmKhQ==",
-      "dev": true,
       "license": "MIT",
       "bin": {
         "jiti": "lib/jiti-cli.mjs"
@@ -4567,6 +5144,40 @@
         "node": ">=6"
       }
     },
+    "node_modules/jsonwebtoken": {
+      "version": "9.0.3",
+      "resolved": "https://registry.npmjs.org/jsonwebtoken/-/jsonwebtoken-9.0.3.tgz",
+      "integrity": "sha512-MT/xP0CrubFRNLNKvxJ2BYfy53Zkm++5bX9dtuPbqAeQpTVe0MQTFhao8+Cp//EmJp244xt6Drw/GVEGCUj40g==",
+      "license": "MIT",
+      "dependencies": {
+        "jws": "^4.0.1",
+        "lodash.includes": "^4.3.0",
+        "lodash.isboolean": "^3.0.3",
+        "lodash.isinteger": "^4.0.4",
+        "lodash.isnumber": "^3.0.3",
+        "lodash.isplainobject": "^4.0.6",
+        "lodash.isstring": "^4.0.1",
+        "lodash.once": "^4.0.0",
+        "ms": "^2.1.1",
+        "semver": "^7.5.4"
+      },
+      "engines": {
+        "node": ">=12",
+        "npm": ">=6"
+      }
+    },
+    "node_modules/jsonwebtoken/node_modules/semver": {
+      "version": "7.7.4",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz",
+      "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==",
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
     "node_modules/jsx-ast-utils": {
       "version": "3.3.5",
       "resolved": "https://registry.npmjs.org/jsx-ast-utils/-/jsx-ast-utils-3.3.5.tgz",
@@ -4583,6 +5194,27 @@
         "node": ">=4.0"
       }
     },
+    "node_modules/jwa": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/jwa/-/jwa-2.0.1.tgz",
+      "integrity": "sha512-hRF04fqJIP8Abbkq5NKGN0Bbr3JxlQ+qhZufXVr0DvujKy93ZCbXZMHDL4EOtodSbCWxOqR8MS1tXA5hwqCXDg==",
+      "license": "MIT",
+      "dependencies": {
+        "buffer-equal-constant-time": "^1.0.1",
+        "ecdsa-sig-formatter": "1.0.11",
+        "safe-buffer": "^5.0.1"
+      }
+    },
+    "node_modules/jws": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/jws/-/jws-4.0.1.tgz",
+      "integrity": "sha512-EKI/M/yqPncGUUh44xz0PxSidXFr/+r0pA70+gIYhjv+et7yxM+s29Y+VGDkovRofQem0fs7Uvf4+YmAdyRduA==",
+      "license": "MIT",
+      "dependencies": {
+        "jwa": "^2.0.1",
+        "safe-buffer": "^5.0.1"
+      }
+    },
     "node_modules/keyv": {
       "version": "4.5.4",
       "resolved": "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz",
@@ -4888,6 +5520,15 @@
         "url": "https://opencollective.com/parcel"
       }
     },
+    "node_modules/lilconfig": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/lilconfig/-/lilconfig-2.1.0.tgz",
+      "integrity": "sha512-utWOt/GHzuUxnLKxB6dk81RoOeoNeHgbrXiuGk4yyF5qlRz+iIVWu56E2fqGHFrXz0QNUhLB/8nKqvRH66JKGQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      }
+    },
     "node_modules/locate-path": {
       "version": "6.0.0",
       "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz",
@@ -4904,6 +5545,48 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/lodash": {
+      "version": "4.17.21",
+      "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz",
+      "integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==",
+      "license": "MIT"
+    },
+    "node_modules/lodash.includes": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/lodash.includes/-/lodash.includes-4.3.0.tgz",
+      "integrity": "sha512-W3Bx6mdkRTGtlJISOvVD/lbqjTlPPUDTMnlXZFnVwi9NKJ6tiAk6LVdlhZMm17VZisqhKcgzpO5Wz91PCt5b0w==",
+      "license": "MIT"
+    },
+    "node_modules/lodash.isboolean": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/lodash.isboolean/-/lodash.isboolean-3.0.3.tgz",
+      "integrity": "sha512-Bz5mupy2SVbPHURB98VAcw+aHh4vRV5IPNhILUCsOzRmsTmSQ17jIuqopAentWoehktxGd9e/hbIXq980/1QJg==",
+      "license": "MIT"
+    },
+    "node_modules/lodash.isinteger": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/lodash.isinteger/-/lodash.isinteger-4.0.4.tgz",
+      "integrity": "sha512-DBwtEWN2caHQ9/imiNeEA5ys1JoRtRfY3d7V9wkqtbycnAmTvRRmbHKDV4a0EYc678/dia0jrte4tjYwVBaZUA==",
+      "license": "MIT"
+    },
+    "node_modules/lodash.isnumber": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/lodash.isnumber/-/lodash.isnumber-3.0.3.tgz",
+      "integrity": "sha512-QYqzpfwO3/CWf3XP+Z+tkQsfaLL/EnUlXWVkIk5FUPc4sBdTehEqZONuyRt2P67PXAk+NXmTBcc97zw9t1FQrw==",
+      "license": "MIT"
+    },
+    "node_modules/lodash.isplainobject": {
+      "version": "4.0.6",
+      "resolved": "https://registry.npmjs.org/lodash.isplainobject/-/lodash.isplainobject-4.0.6.tgz",
+      "integrity": "sha512-oSXzaWypCMHkPC3NvBEaPHf0KsA5mvPrOPgQWDsbg8n7orZ290M0BmC/jgRZ4vcJ6DTAhjrsSYgdsW/F+MFOBA==",
+      "license": "MIT"
+    },
+    "node_modules/lodash.isstring": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/lodash.isstring/-/lodash.isstring-4.0.1.tgz",
+      "integrity": "sha512-0wJxfxH1wgO3GrbuP+dTTk7op+6L41QCXbGINEmD+ny/G/eCqGzxyCsh7159S+mgDDcoarnBw6PC1PS5+wUGgw==",
+      "license": "MIT"
+    },
     "node_modules/lodash.merge": {
       "version": "4.6.2",
       "resolved": "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz",
@@ -4911,6 +5594,18 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/lodash.once": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/lodash.once/-/lodash.once-4.1.1.tgz",
+      "integrity": "sha512-Sb487aTOCr9drQVL8pIxOzVhafOjZN9UU54hiN8PU3uAiSV7lx1yYNpbNmex2PK6dSJoNTSJUUswT651yww3Mg==",
+      "license": "MIT"
+    },
+    "node_modules/long": {
+      "version": "5.3.2",
+      "resolved": "https://registry.npmjs.org/long/-/long-5.3.2.tgz",
+      "integrity": "sha512-mNAgZ1GmyNhD7AuqnTG3/VQ26o760+ZYBPKjPvugO8+nLbYfX6TVpJPseBvopbdY+qpZ/lKUnmEc1LeZYS3QAA==",
+      "license": "Apache-2.0"
+    },
     "node_modules/loose-envify": {
       "version": "1.4.0",
       "resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz",
@@ -4934,6 +5629,21 @@
         "yallist": "^3.0.2"
       }
     },
+    "node_modules/lru.min": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/lru.min/-/lru.min-1.1.4.tgz",
+      "integrity": "sha512-DqC6n3QQ77zdFpCMASA1a3Jlb64Hv2N2DciFGkO/4L9+q/IpIAuRlKOvCXabtRW6cQf8usbmM6BE/TOPysCdIA==",
+      "license": "MIT",
+      "engines": {
+        "bun": ">=1.0.0",
+        "deno": ">=1.30.0",
+        "node": ">=8.0.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wellwelwel"
+      }
+    },
     "node_modules/lucide-react": {
       "version": "0.460.0",
       "resolved": "https://registry.npmjs.org/lucide-react/-/lucide-react-0.460.0.tgz",
@@ -5034,9 +5744,40 @@
       "version": "2.1.3",
       "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
       "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
-      "dev": true,
       "license": "MIT"
     },
+    "node_modules/mysql2": {
+      "version": "3.15.3",
+      "resolved": "https://registry.npmjs.org/mysql2/-/mysql2-3.15.3.tgz",
+      "integrity": "sha512-FBrGau0IXmuqg4haEZRBfHNWB5mUARw6hNwPDXXGg0XzVJ50mr/9hb267lvpVMnhZ1FON3qNd4Xfcez1rbFwSg==",
+      "license": "MIT",
+      "dependencies": {
+        "aws-ssl-profiles": "^1.1.1",
+        "denque": "^2.1.0",
+        "generate-function": "^2.3.1",
+        "iconv-lite": "^0.7.0",
+        "long": "^5.2.1",
+        "lru.min": "^1.0.0",
+        "named-placeholders": "^1.1.3",
+        "seq-queue": "^0.0.5",
+        "sqlstring": "^2.3.2"
+      },
+      "engines": {
+        "node": ">= 8.0"
+      }
+    },
+    "node_modules/named-placeholders": {
+      "version": "1.1.6",
+      "resolved": "https://registry.npmjs.org/named-placeholders/-/named-placeholders-1.1.6.tgz",
+      "integrity": "sha512-Tz09sEL2EEuv5fFowm419c1+a/jSMiBjI9gHxVLrVdbUkkNUUfjsVYs9pVZu5oCon/kmRh9TfLEObFtkVxmY0w==",
+      "license": "MIT",
+      "dependencies": {
+        "lru.min": "^1.1.0"
+      },
+      "engines": {
+        "node": ">=8.0.0"
+      }
+    },
     "node_modules/nanoid": {
       "version": "3.3.11",
       "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.11.tgz",
@@ -5197,6 +5938,12 @@
         "url": "https://opencollective.com/node-fetch"
       }
     },
+    "node_modules/node-fetch-native": {
+      "version": "1.6.7",
+      "resolved": "https://registry.npmjs.org/node-fetch-native/-/node-fetch-native-1.6.7.tgz",
+      "integrity": "sha512-g9yhqoedzIUm0nTnTqAQvueMPVOuIY16bqgAJJC8XOOubYFNwz6IER9qs0Gq2Xd0+CecCKFjtdDTMA4u4xG06Q==",
+      "license": "MIT"
+    },
     "node_modules/node-releases": {
       "version": "2.0.27",
       "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.27.tgz",
@@ -5204,6 +5951,29 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/nypm": {
+      "version": "0.6.5",
+      "resolved": "https://registry.npmjs.org/nypm/-/nypm-0.6.5.tgz",
+      "integrity": "sha512-K6AJy1GMVyfyMXRVB88700BJqNUkByijGJM8kEHpLdcAt+vSQAVfkWWHYzuRXHSY6xA2sNc5RjTj0p9rE2izVQ==",
+      "license": "MIT",
+      "dependencies": {
+        "citty": "^0.2.0",
+        "pathe": "^2.0.3",
+        "tinyexec": "^1.0.2"
+      },
+      "bin": {
+        "nypm": "dist/cli.mjs"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/nypm/node_modules/citty": {
+      "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/citty/-/citty-0.2.0.tgz",
+      "integrity": "sha512-8csy5IBFI2ex2hTVpaHN2j+LNE199AgiI7y4dMintrr8i0lQiFn+0AWMZrWdHKIgMOer65f8IThysYhoReqjWA==",
+      "license": "MIT"
+    },
     "node_modules/object-assign": {
       "version": "4.1.1",
       "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz",
@@ -5327,6 +6097,12 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/ohash": {
+      "version": "2.0.11",
+      "resolved": "https://registry.npmjs.org/ohash/-/ohash-2.0.11.tgz",
+      "integrity": "sha512-RdR9FQrFwNBNXAr4GixM8YaRZRJ5PUWbKYbE5eOsrwAjJW0q2REGcf79oYPsLyskQCZG1PLN+S/K1V00joZAoQ==",
+      "license": "MIT"
+    },
     "node_modules/optionator": {
       "version": "0.9.4",
       "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.4.tgz",
@@ -5422,7 +6198,6 @@
       "version": "3.1.1",
       "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
       "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==",
-      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">=8"
@@ -5435,6 +6210,18 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/pathe": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/pathe/-/pathe-2.0.3.tgz",
+      "integrity": "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==",
+      "license": "MIT"
+    },
+    "node_modules/perfect-debounce": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/perfect-debounce/-/perfect-debounce-1.0.0.tgz",
+      "integrity": "sha512-xCy9V055GLEqoFaHoC1SoLIaLmWctgCUaBaWxDZ7/Zx4CTyX7cJQLJOok/orfjZAh9kEYpjJa4d0KcJmCbctZA==",
+      "license": "MIT"
+    },
     "node_modules/picocolors": {
       "version": "1.1.1",
       "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
@@ -5454,6 +6241,17 @@
         "url": "https://github.com/sponsors/jonschlinkert"
       }
     },
+    "node_modules/pkg-types": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/pkg-types/-/pkg-types-2.3.0.tgz",
+      "integrity": "sha512-SIqCzDRg0s9npO5XQ3tNZioRY1uK06lA41ynBC1YmFTmnY6FjUjVt6s4LoADmwoig1qqD0oK8h1p/8mlMx8Oig==",
+      "license": "MIT",
+      "dependencies": {
+        "confbox": "^0.2.2",
+        "exsolve": "^1.0.7",
+        "pathe": "^2.0.3"
+      }
+    },
     "node_modules/possible-typed-array-names": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/possible-typed-array-names/-/possible-typed-array-names-1.1.0.tgz",
@@ -5493,6 +6291,19 @@
         "node": "^10 || ^12 || >=14"
       }
     },
+    "node_modules/postgres": {
+      "version": "3.4.7",
+      "resolved": "https://registry.npmjs.org/postgres/-/postgres-3.4.7.tgz",
+      "integrity": "sha512-Jtc2612XINuBjIl/QTWsV5UvE8UHuNblcO3vVADSrKsrc6RqGX6lOW1cEo3CM2v0XG4Nat8nI+YM7/f26VxXLw==",
+      "license": "Unlicense",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "type": "individual",
+        "url": "https://github.com/sponsors/porsager"
+      }
+    },
     "node_modules/prelude-ls": {
       "version": "1.2.1",
       "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz",
@@ -5503,6 +6314,40 @@
         "node": ">= 0.8.0"
       }
     },
+    "node_modules/prisma": {
+      "version": "7.3.0",
+      "resolved": "https://registry.npmjs.org/prisma/-/prisma-7.3.0.tgz",
+      "integrity": "sha512-ApYSOLHfMN8WftJA+vL6XwAPOh/aZ0BgUyyKPwUFgjARmG6EBI9LzDPf6SWULQMSAxydV9qn5gLj037nPNlg2w==",
+      "hasInstallScript": true,
+      "license": "Apache-2.0",
+      "peer": true,
+      "dependencies": {
+        "@prisma/config": "7.3.0",
+        "@prisma/dev": "0.20.0",
+        "@prisma/engines": "7.3.0",
+        "@prisma/studio-core": "0.13.1",
+        "mysql2": "3.15.3",
+        "postgres": "3.4.7"
+      },
+      "bin": {
+        "prisma": "build/index.js"
+      },
+      "engines": {
+        "node": "^20.19 || ^22.12 || >=24.0"
+      },
+      "peerDependencies": {
+        "better-sqlite3": ">=9.0.0",
+        "typescript": ">=5.4.0"
+      },
+      "peerDependenciesMeta": {
+        "better-sqlite3": {
+          "optional": true
+        },
+        "typescript": {
+          "optional": true
+        }
+      }
+    },
     "node_modules/prop-types": {
       "version": "15.8.1",
       "resolved": "https://registry.npmjs.org/prop-types/-/prop-types-15.8.1.tgz",
@@ -5515,6 +6360,23 @@
         "react-is": "^16.13.1"
       }
     },
+    "node_modules/proper-lockfile": {
+      "version": "4.1.2",
+      "resolved": "https://registry.npmjs.org/proper-lockfile/-/proper-lockfile-4.1.2.tgz",
+      "integrity": "sha512-TjNPblN4BwAWMXU8s9AEz4JmQxnD1NNL7bNOY/AKUzyamc379FWASUhc/K1pL2noVb+XmZKLL68cjzLsiOAMaA==",
+      "license": "MIT",
+      "dependencies": {
+        "graceful-fs": "^4.2.4",
+        "retry": "^0.12.0",
+        "signal-exit": "^3.0.2"
+      }
+    },
+    "node_modules/proper-lockfile/node_modules/signal-exit": {
+      "version": "3.0.7",
+      "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz",
+      "integrity": "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==",
+      "license": "ISC"
+    },
     "node_modules/punycode": {
       "version": "2.3.1",
       "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz",
@@ -5525,6 +6387,22 @@
         "node": ">=6"
       }
     },
+    "node_modules/pure-rand": {
+      "version": "6.1.0",
+      "resolved": "https://registry.npmjs.org/pure-rand/-/pure-rand-6.1.0.tgz",
+      "integrity": "sha512-bVWawvoZoBYpp6yIoQtQXHZjmz35RSVHnUOTefl8Vcjr8snTPY1wnpSPMWekcFwbxI6gtmT7rSYPFvz71ldiOA==",
+      "funding": [
+        {
+          "type": "individual",
+          "url": "https://github.com/sponsors/dubzzz"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/fast-check"
+        }
+      ],
+      "license": "MIT"
+    },
     "node_modules/queue-microtask": {
       "version": "1.2.3",
       "resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz",
@@ -5546,11 +6424,22 @@
       ],
       "license": "MIT"
     },
+    "node_modules/rc9": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/rc9/-/rc9-2.1.2.tgz",
+      "integrity": "sha512-btXCnMmRIBINM2LDZoEmOogIZU7Qe7zn4BpomSKZ/ykbLObuBdvG+mFq11DL6fjH1DRwHhrlgtYWG96bJiC7Cg==",
+      "license": "MIT",
+      "dependencies": {
+        "defu": "^6.1.4",
+        "destr": "^2.0.3"
+      }
+    },
     "node_modules/react": {
       "version": "19.2.3",
       "resolved": "https://registry.npmjs.org/react/-/react-19.2.3.tgz",
       "integrity": "sha512-Ku/hhYbVjOQnXDZFv2+RibmLFGwFdeeKHFcOTlrt7xplBnya5OGn/hIRDsqDiSUcfORsDC7MPxwork8jBwsIWA==",
       "license": "MIT",
+      "peer": true,
       "engines": {
         "node": ">=0.10.0"
       }
@@ -5560,6 +6449,7 @@
       "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-19.2.3.tgz",
       "integrity": "sha512-yELu4WmLPw5Mr/lmeEpox5rw3RETacE++JgHqQzd2dg+YbJuat3jH4ingc+WPZhxaoFzdv9y33G+F7Nl5O0GBg==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "scheduler": "^0.27.0"
       },
@@ -5574,6 +6464,19 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/readdirp": {
+      "version": "4.1.2",
+      "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-4.1.2.tgz",
+      "integrity": "sha512-GDhwkLfywWL2s6vEjyhri+eXmfH6j1L7JE27WhqLeYzoh/A3DBaYGEj2H/HFZCn/kMfim73FXxEJTw06WtxQwg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 14.18.0"
+      },
+      "funding": {
+        "type": "individual",
+        "url": "https://paulmillr.com/funding/"
+      }
+    },
     "node_modules/reflect.getprototypeof": {
       "version": "1.0.10",
       "resolved": "https://registry.npmjs.org/reflect.getprototypeof/-/reflect.getprototypeof-1.0.10.tgz",
@@ -5597,6 +6500,12 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/regexp-to-ast": {
+      "version": "0.5.0",
+      "resolved": "https://registry.npmjs.org/regexp-to-ast/-/regexp-to-ast-0.5.0.tgz",
+      "integrity": "sha512-tlbJqcMHnPKI9zSrystikWKwHkBqu2a/Sgw01h3zFjvYrMxEDYHzzoMZnUrbIfpTFEsoRnnviOXNCzFiSc54Qw==",
+      "license": "MIT"
+    },
     "node_modules/regexp.prototype.flags": {
       "version": "1.5.4",
       "resolved": "https://registry.npmjs.org/regexp.prototype.flags/-/regexp.prototype.flags-1.5.4.tgz",
@@ -5618,6 +6527,15 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/remeda": {
+      "version": "2.33.4",
+      "resolved": "https://registry.npmjs.org/remeda/-/remeda-2.33.4.tgz",
+      "integrity": "sha512-ygHswjlc/opg2VrtiYvUOPLjxjtdKvjGz1/plDhkG66hjNjFr1xmfrs2ClNFo/E6TyUFiwYNh53bKV26oBoMGQ==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/remeda"
+      }
+    },
     "node_modules/resolve": {
       "version": "1.22.11",
       "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.11.tgz",
@@ -5659,6 +6577,15 @@
         "url": "https://github.com/privatenumber/resolve-pkg-maps?sponsor=1"
       }
     },
+    "node_modules/retry": {
+      "version": "0.12.0",
+      "resolved": "https://registry.npmjs.org/retry/-/retry-0.12.0.tgz",
+      "integrity": "sha512-9LkiTwjUh6rT555DtE9rTX+BKByPfrMzEAtnlEtdEwr3Nkffwiihqe2bWADg+OQRjt9gl6ICdmB/ZFDCGAtSow==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 4"
+      }
+    },
     "node_modules/reusify": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/reusify/-/reusify-1.1.0.tgz",
@@ -5714,6 +6641,26 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/safe-buffer": {
+      "version": "5.2.1",
+      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+      "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "license": "MIT"
+    },
     "node_modules/safe-push-apply": {
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/safe-push-apply/-/safe-push-apply-1.0.0.tgz",
@@ -5749,6 +6696,12 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/safer-buffer": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
+      "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==",
+      "license": "MIT"
+    },
     "node_modules/scheduler": {
       "version": "0.27.0",
       "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.27.0.tgz",
@@ -5765,6 +6718,11 @@
         "semver": "bin/semver.js"
       }
     },
+    "node_modules/seq-queue": {
+      "version": "0.0.5",
+      "resolved": "https://registry.npmjs.org/seq-queue/-/seq-queue-0.0.5.tgz",
+      "integrity": "sha512-hr3Wtp/GZIc/6DAGPDcV4/9WoZhjrkXsi5B/07QgX8tsdc6ilr7BFM6PM6rbdAX1kFSDYeZGLipIZZKyQP0O5Q=="
+    },
     "node_modules/set-function-length": {
       "version": "1.2.2",
       "resolved": "https://registry.npmjs.org/set-function-length/-/set-function-length-1.2.2.tgz",
@@ -5876,7 +6834,6 @@
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
       "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==",
-      "dev": true,
       "license": "MIT",
       "dependencies": {
         "shebang-regex": "^3.0.0"
@@ -5889,7 +6846,6 @@
       "version": "3.0.0",
       "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz",
       "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==",
-      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">=8"
@@ -5971,6 +6927,18 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/signal-exit": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz",
+      "integrity": "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=14"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
     "node_modules/source-map-js": {
       "version": "1.2.1",
       "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
@@ -5980,6 +6948,15 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/sqlstring": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmjs.org/sqlstring/-/sqlstring-2.3.3.tgz",
+      "integrity": "sha512-qC9iz2FlN7DQl3+wjwn3802RTyjCx7sDvfQEXchwa6CWOx07/WVfh91gBmQ9fahw8snwGEWU3xGzOt4tFyHLxg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
     "node_modules/stable-hash": {
       "version": "0.0.5",
       "resolved": "https://registry.npmjs.org/stable-hash/-/stable-hash-0.0.5.tgz",
@@ -5987,6 +6964,12 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/std-env": {
+      "version": "3.10.0",
+      "resolved": "https://registry.npmjs.org/std-env/-/std-env-3.10.0.tgz",
+      "integrity": "sha512-5GS12FdOZNliM5mAOxFRg7Ir0pWz8MdpYm6AY6VPkGpbA7ZzmbzNcBJQ0GPvvyWgcY7QAhCgf9Uy89I03faLkg==",
+      "license": "MIT"
+    },
     "node_modules/stop-iteration-iterator": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/stop-iteration-iterator/-/stop-iteration-iterator-1.1.0.tgz",
@@ -6200,7 +7183,8 @@
       "version": "4.1.18",
       "resolved": "https://registry.npmjs.org/tailwindcss/-/tailwindcss-4.1.18.tgz",
       "integrity": "sha512-4+Z+0yiYyEtUVCScyfHCxOYP06L5Ne+JiHhY2IjR2KWMIWhJOYZKLSGZaP5HkZ8+bY0cxfzwDE5uOmzFXyIwxw==",
-      "license": "MIT"
+      "license": "MIT",
+      "peer": true
     },
     "node_modules/tailwindcss-animate": {
       "version": "1.0.7",
@@ -6225,6 +7209,15 @@
         "url": "https://opencollective.com/webpack"
       }
     },
+    "node_modules/tinyexec": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-1.0.2.tgz",
+      "integrity": "sha512-W/KYk+NFhkmsYpuHq5JykngiOCnxeVL8v8dFnqxSD8qEEdRfXk1SDM6JzNqcERbcGYj9tMrDQBYV9cjgnunFIg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      }
+    },
     "node_modules/tinyglobby": {
       "version": "0.2.15",
       "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.15.tgz",
@@ -6266,6 +7259,7 @@
       "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "engines": {
         "node": ">=12"
       },
@@ -6426,8 +7420,9 @@
       "version": "5.9.3",
       "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz",
       "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
-      "dev": true,
+      "devOptional": true,
       "license": "Apache-2.0",
+      "peer": true,
       "bin": {
         "tsc": "bin/tsc",
         "tsserver": "bin/tsserver"
@@ -6562,6 +7557,20 @@
         "punycode": "^2.1.0"
       }
     },
+    "node_modules/valibot": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/valibot/-/valibot-1.2.0.tgz",
+      "integrity": "sha512-mm1rxUsmOxzrwnX5arGS+U4T25RdvpPjPN4yR0u9pUBov9+zGVtO84tif1eY4r6zWxVxu3KzIyknJy3rxfRZZg==",
+      "license": "MIT",
+      "peerDependencies": {
+        "typescript": ">=5"
+      },
+      "peerDependenciesMeta": {
+        "typescript": {
+          "optional": true
+        }
+      }
+    },
     "node_modules/web-streams-polyfill": {
       "version": "3.3.3",
       "resolved": "https://registry.npmjs.org/web-streams-polyfill/-/web-streams-polyfill-3.3.3.tgz",
@@ -6575,7 +7584,6 @@
       "version": "2.0.2",
       "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
       "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==",
-      "dev": true,
       "license": "ISC",
       "dependencies": {
         "isexe": "^2.0.0"
@@ -6706,12 +7714,23 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/zeptomatch": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/zeptomatch/-/zeptomatch-2.1.0.tgz",
+      "integrity": "sha512-KiGErG2J0G82LSpniV0CtIzjlJ10E04j02VOudJsPyPwNZgGnRKQy7I1R7GMyg/QswnE4l7ohSGrQbQbjXPPDA==",
+      "license": "MIT",
+      "dependencies": {
+        "grammex": "^3.1.11",
+        "graphmatch": "^1.1.0"
+      }
+    },
     "node_modules/zod": {
       "version": "4.3.6",
       "resolved": "https://registry.npmjs.org/zod/-/zod-4.3.6.tgz",
       "integrity": "sha512-rftlrkhHZOcjDwkGlnUtZZkvaPHCsDATp4pGpuOOMDaTdDDXF91wuVDJoWoPsKX/3YPQ5fHuF3STjcYyKr+Qhg==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "funding": {
         "url": "https://github.com/sponsors/colinhacks"
       }
diff --git a/package.json b/package.json
index 5199381..4626741 100644
--- a/package.json
+++ b/package.json
@@ -6,20 +6,31 @@
     "dev": "next dev",
     "build": "next build",
     "start": "next start",
-    "lint": "eslint"
+    "lint": "eslint",
+    "db:migrate": "npx prisma migrate dev",
+    "db:push": "npx prisma db push",
+    "db:seed": "npx tsx prisma/seed.ts",
+    "db:studio": "npx prisma studio",
+    "db:generate": "npx prisma generate"
   },
   "dependencies": {
+    "@prisma/client": "^7.3.0",
     "backboard-sdk": "^1.4.12",
+    "bcryptjs": "^3.0.3",
+    "clsx": "^2.1.1",
+    "jsonwebtoken": "^9.0.3",
     "lucide-react": "^0.460.0",
     "next": "16.1.6",
+    "prisma": "^7.3.0",
     "react": "19.2.3",
     "react-dom": "19.2.3",
-    "tailwindcss-animate": "^1.0.7",
-    "clsx": "^2.1.1",
-    "tailwind-merge": "^2.5.4"
+    "tailwind-merge": "^2.5.4",
+    "tailwindcss-animate": "^1.0.7"
   },
   "devDependencies": {
     "@tailwindcss/postcss": "^4",
+    "@types/bcryptjs": "^2.4.6",
+    "@types/jsonwebtoken": "^9.0.10",
     "@types/node": "^20",
     "@types/react": "^19",
     "@types/react-dom": "^19",
diff --git a/prisma.config.ts b/prisma.config.ts
new file mode 100644
index 0000000..831a20f
--- /dev/null
+++ b/prisma.config.ts
@@ -0,0 +1,14 @@
+// This file was generated by Prisma, and assumes you have installed the following:
+// npm install --save-dev prisma dotenv
+import "dotenv/config";
+import { defineConfig } from "prisma/config";
+
+export default defineConfig({
+  schema: "prisma/schema.prisma",
+  migrations: {
+    path: "prisma/migrations",
+  },
+  datasource: {
+    url: process.env["DATABASE_URL"],
+  },
+});
diff --git a/prisma/generated/prisma/browser.ts b/prisma/generated/prisma/browser.ts
new file mode 100644
index 0000000..5fcb419
--- /dev/null
+++ b/prisma/generated/prisma/browser.ts
@@ -0,0 +1,54 @@
+
+/* !!! This is code generated by Prisma. Do not edit directly. !!! */
+/* eslint-disable */
+// biome-ignore-all lint: generated file
+// @ts-nocheck 
+/*
+ * This file should be your main import to use Prisma-related types and utilities in a browser. 
+ * Use it to get access to models, enums, and input types.
+ * 
+ * This file does not contain a `PrismaClient` class, nor several other helpers that are intended as server-side only.
+ * See `client.ts` for the standard, server-side entry point.
+ *
+ * 🟢 You can import this file directly.
+ */
+
+import * as Prisma from './internal/prismaNamespaceBrowser'
+export { Prisma }
+export * as $Enums from './enums'
+export * from './enums';
+/**
+ * Model User
+ * 
+ */
+export type User = Prisma.UserModel
+/**
+ * Model QueueEntry
+ * 
+ */
+export type QueueEntry = Prisma.QueueEntryModel
+/**
+ * Model Match
+ * 
+ */
+export type Match = Prisma.MatchModel
+/**
+ * Model MatchPlayer
+ * 
+ */
+export type MatchPlayer = Prisma.MatchPlayerModel
+/**
+ * Model Question
+ * 
+ */
+export type Question = Prisma.QuestionModel
+/**
+ * Model MatchQuestion
+ * 
+ */
+export type MatchQuestion = Prisma.MatchQuestionModel
+/**
+ * Model Submission
+ * 
+ */
+export type Submission = Prisma.SubmissionModel
diff --git a/prisma/generated/prisma/client.ts b/prisma/generated/prisma/client.ts
new file mode 100644
index 0000000..3652453
--- /dev/null
+++ b/prisma/generated/prisma/client.ts
@@ -0,0 +1,76 @@
+
+/* !!! This is code generated by Prisma. Do not edit directly. !!! */
+/* eslint-disable */
+// biome-ignore-all lint: generated file
+// @ts-nocheck 
+/*
+ * This file should be your main import to use Prisma. Through it you get access to all the models, enums, and input types.
+ * If you're looking for something you can import in the client-side of your application, please refer to the `browser.ts` file instead.
+ *
+ * 🟢 You can import this file directly.
+ */
+
+import * as process from 'node:process'
+import * as path from 'node:path'
+import { fileURLToPath } from 'node:url'
+globalThis['__dirname'] = path.dirname(fileURLToPath(import.meta.url))
+
+import * as runtime from "@prisma/client/runtime/client"
+import * as $Enums from "./enums"
+import * as $Class from "./internal/class"
+import * as Prisma from "./internal/prismaNamespace"
+
+export * as $Enums from './enums'
+export * from "./enums"
+/**
+ * ## Prisma Client
+ * 
+ * Type-safe database client for TypeScript
+ * @example
+ * ```
+ * const prisma = new PrismaClient()
+ * // Fetch zero or more Users
+ * const users = await prisma.user.findMany()
+ * ```
+ * 
+ * Read more in our [docs](https://pris.ly/d/client).
+ */
+export const PrismaClient = $Class.getPrismaClientClass()
+export type PrismaClient<LogOpts extends Prisma.LogLevel = never, OmitOpts extends Prisma.PrismaClientOptions["omit"] = Prisma.PrismaClientOptions["omit"], ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = $Class.PrismaClient<LogOpts, OmitOpts, ExtArgs>
+export { Prisma }
+
+/**
+ * Model User
+ * 
+ */
+export type User = Prisma.UserModel
+/**
+ * Model QueueEntry
+ * 
+ */
+export type QueueEntry = Prisma.QueueEntryModel
+/**
+ * Model Match
+ * 
+ */
+export type Match = Prisma.MatchModel
+/**
+ * Model MatchPlayer
+ * 
+ */
+export type MatchPlayer = Prisma.MatchPlayerModel
+/**
+ * Model Question
+ * 
+ */
+export type Question = Prisma.QuestionModel
+/**
+ * Model MatchQuestion
+ * 
+ */
+export type MatchQuestion = Prisma.MatchQuestionModel
+/**
+ * Model Submission
+ * 
+ */
+export type Submission = Prisma.SubmissionModel
diff --git a/prisma/generated/prisma/commonInputTypes.ts b/prisma/generated/prisma/commonInputTypes.ts
new file mode 100644
index 0000000..8aedf36
--- /dev/null
+++ b/prisma/generated/prisma/commonInputTypes.ts
@@ -0,0 +1,660 @@
+
+/* !!! This is code generated by Prisma. Do not edit directly. !!! */
+/* eslint-disable */
+// biome-ignore-all lint: generated file
+// @ts-nocheck 
+/*
+ * This file exports various common sort, input & filter types that are not directly linked to a particular model.
+ *
+ * 🟢 You can import this file directly.
+ */
+
+import type * as runtime from "@prisma/client/runtime/client"
+import * as $Enums from "./enums"
+import type * as Prisma from "./internal/prismaNamespace"
+
+
+export type StringFilter<$PrismaModel = never> = {
+  equals?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  in?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel>
+  notIn?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel>
+  lt?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  lte?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  gt?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  gte?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  contains?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  startsWith?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  endsWith?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  mode?: Prisma.QueryMode
+  not?: Prisma.NestedStringFilter<$PrismaModel> | string
+}
+
+export type StringNullableFilter<$PrismaModel = never> = {
+  equals?: string | Prisma.StringFieldRefInput<$PrismaModel> | null
+  in?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | null
+  notIn?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | null
+  lt?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  lte?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  gt?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  gte?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  contains?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  startsWith?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  endsWith?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  mode?: Prisma.QueryMode
+  not?: Prisma.NestedStringNullableFilter<$PrismaModel> | string | null
+}
+
+export type EnumSkillTierFilter<$PrismaModel = never> = {
+  equals?: $Enums.SkillTier | Prisma.EnumSkillTierFieldRefInput<$PrismaModel>
+  in?: $Enums.SkillTier[] | Prisma.ListEnumSkillTierFieldRefInput<$PrismaModel>
+  notIn?: $Enums.SkillTier[] | Prisma.ListEnumSkillTierFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedEnumSkillTierFilter<$PrismaModel> | $Enums.SkillTier
+}
+
+export type IntFilter<$PrismaModel = never> = {
+  equals?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  in?: number[] | Prisma.ListIntFieldRefInput<$PrismaModel>
+  notIn?: number[] | Prisma.ListIntFieldRefInput<$PrismaModel>
+  lt?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  lte?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  gt?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  gte?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedIntFilter<$PrismaModel> | number
+}
+
+export type DateTimeFilter<$PrismaModel = never> = {
+  equals?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  in?: Date[] | string[] | Prisma.ListDateTimeFieldRefInput<$PrismaModel>
+  notIn?: Date[] | string[] | Prisma.ListDateTimeFieldRefInput<$PrismaModel>
+  lt?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  lte?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  gt?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  gte?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedDateTimeFilter<$PrismaModel> | Date | string
+}
+
+export type SortOrderInput = {
+  sort: Prisma.SortOrder
+  nulls?: Prisma.NullsOrder
+}
+
+export type StringWithAggregatesFilter<$PrismaModel = never> = {
+  equals?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  in?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel>
+  notIn?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel>
+  lt?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  lte?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  gt?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  gte?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  contains?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  startsWith?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  endsWith?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  mode?: Prisma.QueryMode
+  not?: Prisma.NestedStringWithAggregatesFilter<$PrismaModel> | string
+  _count?: Prisma.NestedIntFilter<$PrismaModel>
+  _min?: Prisma.NestedStringFilter<$PrismaModel>
+  _max?: Prisma.NestedStringFilter<$PrismaModel>
+}
+
+export type StringNullableWithAggregatesFilter<$PrismaModel = never> = {
+  equals?: string | Prisma.StringFieldRefInput<$PrismaModel> | null
+  in?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | null
+  notIn?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | null
+  lt?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  lte?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  gt?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  gte?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  contains?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  startsWith?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  endsWith?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  mode?: Prisma.QueryMode
+  not?: Prisma.NestedStringNullableWithAggregatesFilter<$PrismaModel> | string | null
+  _count?: Prisma.NestedIntNullableFilter<$PrismaModel>
+  _min?: Prisma.NestedStringNullableFilter<$PrismaModel>
+  _max?: Prisma.NestedStringNullableFilter<$PrismaModel>
+}
+
+export type EnumSkillTierWithAggregatesFilter<$PrismaModel = never> = {
+  equals?: $Enums.SkillTier | Prisma.EnumSkillTierFieldRefInput<$PrismaModel>
+  in?: $Enums.SkillTier[] | Prisma.ListEnumSkillTierFieldRefInput<$PrismaModel>
+  notIn?: $Enums.SkillTier[] | Prisma.ListEnumSkillTierFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedEnumSkillTierWithAggregatesFilter<$PrismaModel> | $Enums.SkillTier
+  _count?: Prisma.NestedIntFilter<$PrismaModel>
+  _min?: Prisma.NestedEnumSkillTierFilter<$PrismaModel>
+  _max?: Prisma.NestedEnumSkillTierFilter<$PrismaModel>
+}
+
+export type IntWithAggregatesFilter<$PrismaModel = never> = {
+  equals?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  in?: number[] | Prisma.ListIntFieldRefInput<$PrismaModel>
+  notIn?: number[] | Prisma.ListIntFieldRefInput<$PrismaModel>
+  lt?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  lte?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  gt?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  gte?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedIntWithAggregatesFilter<$PrismaModel> | number
+  _count?: Prisma.NestedIntFilter<$PrismaModel>
+  _avg?: Prisma.NestedFloatFilter<$PrismaModel>
+  _sum?: Prisma.NestedIntFilter<$PrismaModel>
+  _min?: Prisma.NestedIntFilter<$PrismaModel>
+  _max?: Prisma.NestedIntFilter<$PrismaModel>
+}
+
+export type DateTimeWithAggregatesFilter<$PrismaModel = never> = {
+  equals?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  in?: Date[] | string[] | Prisma.ListDateTimeFieldRefInput<$PrismaModel>
+  notIn?: Date[] | string[] | Prisma.ListDateTimeFieldRefInput<$PrismaModel>
+  lt?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  lte?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  gt?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  gte?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedDateTimeWithAggregatesFilter<$PrismaModel> | Date | string
+  _count?: Prisma.NestedIntFilter<$PrismaModel>
+  _min?: Prisma.NestedDateTimeFilter<$PrismaModel>
+  _max?: Prisma.NestedDateTimeFilter<$PrismaModel>
+}
+
+export type BoolFilter<$PrismaModel = never> = {
+  equals?: boolean | Prisma.BooleanFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedBoolFilter<$PrismaModel> | boolean
+}
+
+export type BoolWithAggregatesFilter<$PrismaModel = never> = {
+  equals?: boolean | Prisma.BooleanFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedBoolWithAggregatesFilter<$PrismaModel> | boolean
+  _count?: Prisma.NestedIntFilter<$PrismaModel>
+  _min?: Prisma.NestedBoolFilter<$PrismaModel>
+  _max?: Prisma.NestedBoolFilter<$PrismaModel>
+}
+
+export type EnumMatchStatusFilter<$PrismaModel = never> = {
+  equals?: $Enums.MatchStatus | Prisma.EnumMatchStatusFieldRefInput<$PrismaModel>
+  in?: $Enums.MatchStatus[] | Prisma.ListEnumMatchStatusFieldRefInput<$PrismaModel>
+  notIn?: $Enums.MatchStatus[] | Prisma.ListEnumMatchStatusFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedEnumMatchStatusFilter<$PrismaModel> | $Enums.MatchStatus
+}
+
+export type EnumGameModeFilter<$PrismaModel = never> = {
+  equals?: $Enums.GameMode | Prisma.EnumGameModeFieldRefInput<$PrismaModel>
+  in?: $Enums.GameMode[] | Prisma.ListEnumGameModeFieldRefInput<$PrismaModel>
+  notIn?: $Enums.GameMode[] | Prisma.ListEnumGameModeFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedEnumGameModeFilter<$PrismaModel> | $Enums.GameMode
+}
+
+export type DateTimeNullableFilter<$PrismaModel = never> = {
+  equals?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | null
+  in?: Date[] | string[] | Prisma.ListDateTimeFieldRefInput<$PrismaModel> | null
+  notIn?: Date[] | string[] | Prisma.ListDateTimeFieldRefInput<$PrismaModel> | null
+  lt?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  lte?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  gt?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  gte?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedDateTimeNullableFilter<$PrismaModel> | Date | string | null
+}
+
+export type EnumMatchStatusWithAggregatesFilter<$PrismaModel = never> = {
+  equals?: $Enums.MatchStatus | Prisma.EnumMatchStatusFieldRefInput<$PrismaModel>
+  in?: $Enums.MatchStatus[] | Prisma.ListEnumMatchStatusFieldRefInput<$PrismaModel>
+  notIn?: $Enums.MatchStatus[] | Prisma.ListEnumMatchStatusFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedEnumMatchStatusWithAggregatesFilter<$PrismaModel> | $Enums.MatchStatus
+  _count?: Prisma.NestedIntFilter<$PrismaModel>
+  _min?: Prisma.NestedEnumMatchStatusFilter<$PrismaModel>
+  _max?: Prisma.NestedEnumMatchStatusFilter<$PrismaModel>
+}
+
+export type EnumGameModeWithAggregatesFilter<$PrismaModel = never> = {
+  equals?: $Enums.GameMode | Prisma.EnumGameModeFieldRefInput<$PrismaModel>
+  in?: $Enums.GameMode[] | Prisma.ListEnumGameModeFieldRefInput<$PrismaModel>
+  notIn?: $Enums.GameMode[] | Prisma.ListEnumGameModeFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedEnumGameModeWithAggregatesFilter<$PrismaModel> | $Enums.GameMode
+  _count?: Prisma.NestedIntFilter<$PrismaModel>
+  _min?: Prisma.NestedEnumGameModeFilter<$PrismaModel>
+  _max?: Prisma.NestedEnumGameModeFilter<$PrismaModel>
+}
+
+export type DateTimeNullableWithAggregatesFilter<$PrismaModel = never> = {
+  equals?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | null
+  in?: Date[] | string[] | Prisma.ListDateTimeFieldRefInput<$PrismaModel> | null
+  notIn?: Date[] | string[] | Prisma.ListDateTimeFieldRefInput<$PrismaModel> | null
+  lt?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  lte?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  gt?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  gte?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedDateTimeNullableWithAggregatesFilter<$PrismaModel> | Date | string | null
+  _count?: Prisma.NestedIntNullableFilter<$PrismaModel>
+  _min?: Prisma.NestedDateTimeNullableFilter<$PrismaModel>
+  _max?: Prisma.NestedDateTimeNullableFilter<$PrismaModel>
+}
+
+export type IntNullableFilter<$PrismaModel = never> = {
+  equals?: number | Prisma.IntFieldRefInput<$PrismaModel> | null
+  in?: number[] | Prisma.ListIntFieldRefInput<$PrismaModel> | null
+  notIn?: number[] | Prisma.ListIntFieldRefInput<$PrismaModel> | null
+  lt?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  lte?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  gt?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  gte?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedIntNullableFilter<$PrismaModel> | number | null
+}
+
+export type FloatNullableFilter<$PrismaModel = never> = {
+  equals?: number | Prisma.FloatFieldRefInput<$PrismaModel> | null
+  in?: number[] | Prisma.ListFloatFieldRefInput<$PrismaModel> | null
+  notIn?: number[] | Prisma.ListFloatFieldRefInput<$PrismaModel> | null
+  lt?: number | Prisma.FloatFieldRefInput<$PrismaModel>
+  lte?: number | Prisma.FloatFieldRefInput<$PrismaModel>
+  gt?: number | Prisma.FloatFieldRefInput<$PrismaModel>
+  gte?: number | Prisma.FloatFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedFloatNullableFilter<$PrismaModel> | number | null
+}
+
+export type IntNullableWithAggregatesFilter<$PrismaModel = never> = {
+  equals?: number | Prisma.IntFieldRefInput<$PrismaModel> | null
+  in?: number[] | Prisma.ListIntFieldRefInput<$PrismaModel> | null
+  notIn?: number[] | Prisma.ListIntFieldRefInput<$PrismaModel> | null
+  lt?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  lte?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  gt?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  gte?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedIntNullableWithAggregatesFilter<$PrismaModel> | number | null
+  _count?: Prisma.NestedIntNullableFilter<$PrismaModel>
+  _avg?: Prisma.NestedFloatNullableFilter<$PrismaModel>
+  _sum?: Prisma.NestedIntNullableFilter<$PrismaModel>
+  _min?: Prisma.NestedIntNullableFilter<$PrismaModel>
+  _max?: Prisma.NestedIntNullableFilter<$PrismaModel>
+}
+
+export type FloatNullableWithAggregatesFilter<$PrismaModel = never> = {
+  equals?: number | Prisma.FloatFieldRefInput<$PrismaModel> | null
+  in?: number[] | Prisma.ListFloatFieldRefInput<$PrismaModel> | null
+  notIn?: number[] | Prisma.ListFloatFieldRefInput<$PrismaModel> | null
+  lt?: number | Prisma.FloatFieldRefInput<$PrismaModel>
+  lte?: number | Prisma.FloatFieldRefInput<$PrismaModel>
+  gt?: number | Prisma.FloatFieldRefInput<$PrismaModel>
+  gte?: number | Prisma.FloatFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedFloatNullableWithAggregatesFilter<$PrismaModel> | number | null
+  _count?: Prisma.NestedIntNullableFilter<$PrismaModel>
+  _avg?: Prisma.NestedFloatNullableFilter<$PrismaModel>
+  _sum?: Prisma.NestedFloatNullableFilter<$PrismaModel>
+  _min?: Prisma.NestedFloatNullableFilter<$PrismaModel>
+  _max?: Prisma.NestedFloatNullableFilter<$PrismaModel>
+}
+
+export type EnumDifficultyFilter<$PrismaModel = never> = {
+  equals?: $Enums.Difficulty | Prisma.EnumDifficultyFieldRefInput<$PrismaModel>
+  in?: $Enums.Difficulty[] | Prisma.ListEnumDifficultyFieldRefInput<$PrismaModel>
+  notIn?: $Enums.Difficulty[] | Prisma.ListEnumDifficultyFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedEnumDifficultyFilter<$PrismaModel> | $Enums.Difficulty
+}
+
+export type JsonNullableFilter<$PrismaModel = never> =
+| Prisma.PatchUndefined<
+    Prisma.Either<Required<JsonNullableFilterBase<$PrismaModel>>, Exclude<keyof Required<JsonNullableFilterBase<$PrismaModel>>, 'path'>>,
+    Required<JsonNullableFilterBase<$PrismaModel>>
+  >
+| Prisma.OptionalFlat<Omit<Required<JsonNullableFilterBase<$PrismaModel>>, 'path'>>
+
+export type JsonNullableFilterBase<$PrismaModel = never> = {
+  equals?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | Prisma.JsonNullValueFilter
+  path?: string[]
+  mode?: Prisma.QueryMode | Prisma.EnumQueryModeFieldRefInput<$PrismaModel>
+  string_contains?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  string_starts_with?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  string_ends_with?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  array_starts_with?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | null
+  array_ends_with?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | null
+  array_contains?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | null
+  lt?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel>
+  lte?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel>
+  gt?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel>
+  gte?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel>
+  not?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | Prisma.JsonNullValueFilter
+}
+
+export type EnumDifficultyWithAggregatesFilter<$PrismaModel = never> = {
+  equals?: $Enums.Difficulty | Prisma.EnumDifficultyFieldRefInput<$PrismaModel>
+  in?: $Enums.Difficulty[] | Prisma.ListEnumDifficultyFieldRefInput<$PrismaModel>
+  notIn?: $Enums.Difficulty[] | Prisma.ListEnumDifficultyFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedEnumDifficultyWithAggregatesFilter<$PrismaModel> | $Enums.Difficulty
+  _count?: Prisma.NestedIntFilter<$PrismaModel>
+  _min?: Prisma.NestedEnumDifficultyFilter<$PrismaModel>
+  _max?: Prisma.NestedEnumDifficultyFilter<$PrismaModel>
+}
+
+export type JsonNullableWithAggregatesFilter<$PrismaModel = never> =
+| Prisma.PatchUndefined<
+    Prisma.Either<Required<JsonNullableWithAggregatesFilterBase<$PrismaModel>>, Exclude<keyof Required<JsonNullableWithAggregatesFilterBase<$PrismaModel>>, 'path'>>,
+    Required<JsonNullableWithAggregatesFilterBase<$PrismaModel>>
+  >
+| Prisma.OptionalFlat<Omit<Required<JsonNullableWithAggregatesFilterBase<$PrismaModel>>, 'path'>>
+
+export type JsonNullableWithAggregatesFilterBase<$PrismaModel = never> = {
+  equals?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | Prisma.JsonNullValueFilter
+  path?: string[]
+  mode?: Prisma.QueryMode | Prisma.EnumQueryModeFieldRefInput<$PrismaModel>
+  string_contains?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  string_starts_with?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  string_ends_with?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  array_starts_with?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | null
+  array_ends_with?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | null
+  array_contains?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | null
+  lt?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel>
+  lte?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel>
+  gt?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel>
+  gte?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel>
+  not?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | Prisma.JsonNullValueFilter
+  _count?: Prisma.NestedIntNullableFilter<$PrismaModel>
+  _min?: Prisma.NestedJsonNullableFilter<$PrismaModel>
+  _max?: Prisma.NestedJsonNullableFilter<$PrismaModel>
+}
+
+export type NestedStringFilter<$PrismaModel = never> = {
+  equals?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  in?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel>
+  notIn?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel>
+  lt?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  lte?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  gt?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  gte?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  contains?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  startsWith?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  endsWith?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedStringFilter<$PrismaModel> | string
+}
+
+export type NestedStringNullableFilter<$PrismaModel = never> = {
+  equals?: string | Prisma.StringFieldRefInput<$PrismaModel> | null
+  in?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | null
+  notIn?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | null
+  lt?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  lte?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  gt?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  gte?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  contains?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  startsWith?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  endsWith?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedStringNullableFilter<$PrismaModel> | string | null
+}
+
+export type NestedEnumSkillTierFilter<$PrismaModel = never> = {
+  equals?: $Enums.SkillTier | Prisma.EnumSkillTierFieldRefInput<$PrismaModel>
+  in?: $Enums.SkillTier[] | Prisma.ListEnumSkillTierFieldRefInput<$PrismaModel>
+  notIn?: $Enums.SkillTier[] | Prisma.ListEnumSkillTierFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedEnumSkillTierFilter<$PrismaModel> | $Enums.SkillTier
+}
+
+export type NestedIntFilter<$PrismaModel = never> = {
+  equals?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  in?: number[] | Prisma.ListIntFieldRefInput<$PrismaModel>
+  notIn?: number[] | Prisma.ListIntFieldRefInput<$PrismaModel>
+  lt?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  lte?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  gt?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  gte?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedIntFilter<$PrismaModel> | number
+}
+
+export type NestedDateTimeFilter<$PrismaModel = never> = {
+  equals?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  in?: Date[] | string[] | Prisma.ListDateTimeFieldRefInput<$PrismaModel>
+  notIn?: Date[] | string[] | Prisma.ListDateTimeFieldRefInput<$PrismaModel>
+  lt?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  lte?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  gt?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  gte?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedDateTimeFilter<$PrismaModel> | Date | string
+}
+
+export type NestedStringWithAggregatesFilter<$PrismaModel = never> = {
+  equals?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  in?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel>
+  notIn?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel>
+  lt?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  lte?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  gt?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  gte?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  contains?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  startsWith?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  endsWith?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedStringWithAggregatesFilter<$PrismaModel> | string
+  _count?: Prisma.NestedIntFilter<$PrismaModel>
+  _min?: Prisma.NestedStringFilter<$PrismaModel>
+  _max?: Prisma.NestedStringFilter<$PrismaModel>
+}
+
+export type NestedStringNullableWithAggregatesFilter<$PrismaModel = never> = {
+  equals?: string | Prisma.StringFieldRefInput<$PrismaModel> | null
+  in?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | null
+  notIn?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | null
+  lt?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  lte?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  gt?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  gte?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  contains?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  startsWith?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  endsWith?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedStringNullableWithAggregatesFilter<$PrismaModel> | string | null
+  _count?: Prisma.NestedIntNullableFilter<$PrismaModel>
+  _min?: Prisma.NestedStringNullableFilter<$PrismaModel>
+  _max?: Prisma.NestedStringNullableFilter<$PrismaModel>
+}
+
+export type NestedIntNullableFilter<$PrismaModel = never> = {
+  equals?: number | Prisma.IntFieldRefInput<$PrismaModel> | null
+  in?: number[] | Prisma.ListIntFieldRefInput<$PrismaModel> | null
+  notIn?: number[] | Prisma.ListIntFieldRefInput<$PrismaModel> | null
+  lt?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  lte?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  gt?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  gte?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedIntNullableFilter<$PrismaModel> | number | null
+}
+
+export type NestedEnumSkillTierWithAggregatesFilter<$PrismaModel = never> = {
+  equals?: $Enums.SkillTier | Prisma.EnumSkillTierFieldRefInput<$PrismaModel>
+  in?: $Enums.SkillTier[] | Prisma.ListEnumSkillTierFieldRefInput<$PrismaModel>
+  notIn?: $Enums.SkillTier[] | Prisma.ListEnumSkillTierFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedEnumSkillTierWithAggregatesFilter<$PrismaModel> | $Enums.SkillTier
+  _count?: Prisma.NestedIntFilter<$PrismaModel>
+  _min?: Prisma.NestedEnumSkillTierFilter<$PrismaModel>
+  _max?: Prisma.NestedEnumSkillTierFilter<$PrismaModel>
+}
+
+export type NestedIntWithAggregatesFilter<$PrismaModel = never> = {
+  equals?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  in?: number[] | Prisma.ListIntFieldRefInput<$PrismaModel>
+  notIn?: number[] | Prisma.ListIntFieldRefInput<$PrismaModel>
+  lt?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  lte?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  gt?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  gte?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedIntWithAggregatesFilter<$PrismaModel> | number
+  _count?: Prisma.NestedIntFilter<$PrismaModel>
+  _avg?: Prisma.NestedFloatFilter<$PrismaModel>
+  _sum?: Prisma.NestedIntFilter<$PrismaModel>
+  _min?: Prisma.NestedIntFilter<$PrismaModel>
+  _max?: Prisma.NestedIntFilter<$PrismaModel>
+}
+
+export type NestedFloatFilter<$PrismaModel = never> = {
+  equals?: number | Prisma.FloatFieldRefInput<$PrismaModel>
+  in?: number[] | Prisma.ListFloatFieldRefInput<$PrismaModel>
+  notIn?: number[] | Prisma.ListFloatFieldRefInput<$PrismaModel>
+  lt?: number | Prisma.FloatFieldRefInput<$PrismaModel>
+  lte?: number | Prisma.FloatFieldRefInput<$PrismaModel>
+  gt?: number | Prisma.FloatFieldRefInput<$PrismaModel>
+  gte?: number | Prisma.FloatFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedFloatFilter<$PrismaModel> | number
+}
+
+export type NestedDateTimeWithAggregatesFilter<$PrismaModel = never> = {
+  equals?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  in?: Date[] | string[] | Prisma.ListDateTimeFieldRefInput<$PrismaModel>
+  notIn?: Date[] | string[] | Prisma.ListDateTimeFieldRefInput<$PrismaModel>
+  lt?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  lte?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  gt?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  gte?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedDateTimeWithAggregatesFilter<$PrismaModel> | Date | string
+  _count?: Prisma.NestedIntFilter<$PrismaModel>
+  _min?: Prisma.NestedDateTimeFilter<$PrismaModel>
+  _max?: Prisma.NestedDateTimeFilter<$PrismaModel>
+}
+
+export type NestedBoolFilter<$PrismaModel = never> = {
+  equals?: boolean | Prisma.BooleanFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedBoolFilter<$PrismaModel> | boolean
+}
+
+export type NestedBoolWithAggregatesFilter<$PrismaModel = never> = {
+  equals?: boolean | Prisma.BooleanFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedBoolWithAggregatesFilter<$PrismaModel> | boolean
+  _count?: Prisma.NestedIntFilter<$PrismaModel>
+  _min?: Prisma.NestedBoolFilter<$PrismaModel>
+  _max?: Prisma.NestedBoolFilter<$PrismaModel>
+}
+
+export type NestedEnumMatchStatusFilter<$PrismaModel = never> = {
+  equals?: $Enums.MatchStatus | Prisma.EnumMatchStatusFieldRefInput<$PrismaModel>
+  in?: $Enums.MatchStatus[] | Prisma.ListEnumMatchStatusFieldRefInput<$PrismaModel>
+  notIn?: $Enums.MatchStatus[] | Prisma.ListEnumMatchStatusFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedEnumMatchStatusFilter<$PrismaModel> | $Enums.MatchStatus
+}
+
+export type NestedEnumGameModeFilter<$PrismaModel = never> = {
+  equals?: $Enums.GameMode | Prisma.EnumGameModeFieldRefInput<$PrismaModel>
+  in?: $Enums.GameMode[] | Prisma.ListEnumGameModeFieldRefInput<$PrismaModel>
+  notIn?: $Enums.GameMode[] | Prisma.ListEnumGameModeFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedEnumGameModeFilter<$PrismaModel> | $Enums.GameMode
+}
+
+export type NestedDateTimeNullableFilter<$PrismaModel = never> = {
+  equals?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | null
+  in?: Date[] | string[] | Prisma.ListDateTimeFieldRefInput<$PrismaModel> | null
+  notIn?: Date[] | string[] | Prisma.ListDateTimeFieldRefInput<$PrismaModel> | null
+  lt?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  lte?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  gt?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  gte?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedDateTimeNullableFilter<$PrismaModel> | Date | string | null
+}
+
+export type NestedEnumMatchStatusWithAggregatesFilter<$PrismaModel = never> = {
+  equals?: $Enums.MatchStatus | Prisma.EnumMatchStatusFieldRefInput<$PrismaModel>
+  in?: $Enums.MatchStatus[] | Prisma.ListEnumMatchStatusFieldRefInput<$PrismaModel>
+  notIn?: $Enums.MatchStatus[] | Prisma.ListEnumMatchStatusFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedEnumMatchStatusWithAggregatesFilter<$PrismaModel> | $Enums.MatchStatus
+  _count?: Prisma.NestedIntFilter<$PrismaModel>
+  _min?: Prisma.NestedEnumMatchStatusFilter<$PrismaModel>
+  _max?: Prisma.NestedEnumMatchStatusFilter<$PrismaModel>
+}
+
+export type NestedEnumGameModeWithAggregatesFilter<$PrismaModel = never> = {
+  equals?: $Enums.GameMode | Prisma.EnumGameModeFieldRefInput<$PrismaModel>
+  in?: $Enums.GameMode[] | Prisma.ListEnumGameModeFieldRefInput<$PrismaModel>
+  notIn?: $Enums.GameMode[] | Prisma.ListEnumGameModeFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedEnumGameModeWithAggregatesFilter<$PrismaModel> | $Enums.GameMode
+  _count?: Prisma.NestedIntFilter<$PrismaModel>
+  _min?: Prisma.NestedEnumGameModeFilter<$PrismaModel>
+  _max?: Prisma.NestedEnumGameModeFilter<$PrismaModel>
+}
+
+export type NestedDateTimeNullableWithAggregatesFilter<$PrismaModel = never> = {
+  equals?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | null
+  in?: Date[] | string[] | Prisma.ListDateTimeFieldRefInput<$PrismaModel> | null
+  notIn?: Date[] | string[] | Prisma.ListDateTimeFieldRefInput<$PrismaModel> | null
+  lt?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  lte?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  gt?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  gte?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedDateTimeNullableWithAggregatesFilter<$PrismaModel> | Date | string | null
+  _count?: Prisma.NestedIntNullableFilter<$PrismaModel>
+  _min?: Prisma.NestedDateTimeNullableFilter<$PrismaModel>
+  _max?: Prisma.NestedDateTimeNullableFilter<$PrismaModel>
+}
+
+export type NestedFloatNullableFilter<$PrismaModel = never> = {
+  equals?: number | Prisma.FloatFieldRefInput<$PrismaModel> | null
+  in?: number[] | Prisma.ListFloatFieldRefInput<$PrismaModel> | null
+  notIn?: number[] | Prisma.ListFloatFieldRefInput<$PrismaModel> | null
+  lt?: number | Prisma.FloatFieldRefInput<$PrismaModel>
+  lte?: number | Prisma.FloatFieldRefInput<$PrismaModel>
+  gt?: number | Prisma.FloatFieldRefInput<$PrismaModel>
+  gte?: number | Prisma.FloatFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedFloatNullableFilter<$PrismaModel> | number | null
+}
+
+export type NestedIntNullableWithAggregatesFilter<$PrismaModel = never> = {
+  equals?: number | Prisma.IntFieldRefInput<$PrismaModel> | null
+  in?: number[] | Prisma.ListIntFieldRefInput<$PrismaModel> | null
+  notIn?: number[] | Prisma.ListIntFieldRefInput<$PrismaModel> | null
+  lt?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  lte?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  gt?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  gte?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedIntNullableWithAggregatesFilter<$PrismaModel> | number | null
+  _count?: Prisma.NestedIntNullableFilter<$PrismaModel>
+  _avg?: Prisma.NestedFloatNullableFilter<$PrismaModel>
+  _sum?: Prisma.NestedIntNullableFilter<$PrismaModel>
+  _min?: Prisma.NestedIntNullableFilter<$PrismaModel>
+  _max?: Prisma.NestedIntNullableFilter<$PrismaModel>
+}
+
+export type NestedFloatNullableWithAggregatesFilter<$PrismaModel = never> = {
+  equals?: number | Prisma.FloatFieldRefInput<$PrismaModel> | null
+  in?: number[] | Prisma.ListFloatFieldRefInput<$PrismaModel> | null
+  notIn?: number[] | Prisma.ListFloatFieldRefInput<$PrismaModel> | null
+  lt?: number | Prisma.FloatFieldRefInput<$PrismaModel>
+  lte?: number | Prisma.FloatFieldRefInput<$PrismaModel>
+  gt?: number | Prisma.FloatFieldRefInput<$PrismaModel>
+  gte?: number | Prisma.FloatFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedFloatNullableWithAggregatesFilter<$PrismaModel> | number | null
+  _count?: Prisma.NestedIntNullableFilter<$PrismaModel>
+  _avg?: Prisma.NestedFloatNullableFilter<$PrismaModel>
+  _sum?: Prisma.NestedFloatNullableFilter<$PrismaModel>
+  _min?: Prisma.NestedFloatNullableFilter<$PrismaModel>
+  _max?: Prisma.NestedFloatNullableFilter<$PrismaModel>
+}
+
+export type NestedEnumDifficultyFilter<$PrismaModel = never> = {
+  equals?: $Enums.Difficulty | Prisma.EnumDifficultyFieldRefInput<$PrismaModel>
+  in?: $Enums.Difficulty[] | Prisma.ListEnumDifficultyFieldRefInput<$PrismaModel>
+  notIn?: $Enums.Difficulty[] | Prisma.ListEnumDifficultyFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedEnumDifficultyFilter<$PrismaModel> | $Enums.Difficulty
+}
+
+export type NestedEnumDifficultyWithAggregatesFilter<$PrismaModel = never> = {
+  equals?: $Enums.Difficulty | Prisma.EnumDifficultyFieldRefInput<$PrismaModel>
+  in?: $Enums.Difficulty[] | Prisma.ListEnumDifficultyFieldRefInput<$PrismaModel>
+  notIn?: $Enums.Difficulty[] | Prisma.ListEnumDifficultyFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedEnumDifficultyWithAggregatesFilter<$PrismaModel> | $Enums.Difficulty
+  _count?: Prisma.NestedIntFilter<$PrismaModel>
+  _min?: Prisma.NestedEnumDifficultyFilter<$PrismaModel>
+  _max?: Prisma.NestedEnumDifficultyFilter<$PrismaModel>
+}
+
+export type NestedJsonNullableFilter<$PrismaModel = never> =
+| Prisma.PatchUndefined<
+    Prisma.Either<Required<NestedJsonNullableFilterBase<$PrismaModel>>, Exclude<keyof Required<NestedJsonNullableFilterBase<$PrismaModel>>, 'path'>>,
+    Required<NestedJsonNullableFilterBase<$PrismaModel>>
+  >
+| Prisma.OptionalFlat<Omit<Required<NestedJsonNullableFilterBase<$PrismaModel>>, 'path'>>
+
+export type NestedJsonNullableFilterBase<$PrismaModel = never> = {
+  equals?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | Prisma.JsonNullValueFilter
+  path?: string[]
+  mode?: Prisma.QueryMode | Prisma.EnumQueryModeFieldRefInput<$PrismaModel>
+  string_contains?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  string_starts_with?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  string_ends_with?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  array_starts_with?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | null
+  array_ends_with?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | null
+  array_contains?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | null
+  lt?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel>
+  lte?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel>
+  gt?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel>
+  gte?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel>
+  not?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | Prisma.JsonNullValueFilter
+}
+
+
diff --git a/prisma/generated/prisma/enums.ts b/prisma/generated/prisma/enums.ts
new file mode 100644
index 0000000..78585b5
--- /dev/null
+++ b/prisma/generated/prisma/enums.ts
@@ -0,0 +1,49 @@
+
+/* !!! This is code generated by Prisma. Do not edit directly. !!! */
+/* eslint-disable */
+// biome-ignore-all lint: generated file
+// @ts-nocheck 
+/*
+* This file exports all enum related types from the schema.
+*
+* 🟢 You can import this file directly.
+*/
+
+export const SkillTier = {
+  BEGINNER: 'BEGINNER',
+  INTERMEDIATE: 'INTERMEDIATE',
+  ADVANCED: 'ADVANCED',
+  PRO: 'PRO'
+} as const
+
+export type SkillTier = (typeof SkillTier)[keyof typeof SkillTier]
+
+
+export const MatchStatus = {
+  WAITING: 'WAITING',
+  IN_PROGRESS: 'IN_PROGRESS',
+  EVALUATING: 'EVALUATING',
+  COMPLETED: 'COMPLETED',
+  CANCELLED: 'CANCELLED'
+} as const
+
+export type MatchStatus = (typeof MatchStatus)[keyof typeof MatchStatus]
+
+
+export const GameMode = {
+  FASTEST: 'FASTEST',
+  SHORTEST: 'SHORTEST',
+  REVERSE: 'REVERSE',
+  DEBUGGING: 'DEBUGGING'
+} as const
+
+export type GameMode = (typeof GameMode)[keyof typeof GameMode]
+
+
+export const Difficulty = {
+  EASY: 'EASY',
+  MEDIUM: 'MEDIUM',
+  HARD: 'HARD'
+} as const
+
+export type Difficulty = (typeof Difficulty)[keyof typeof Difficulty]
diff --git a/prisma/generated/prisma/internal/class.ts b/prisma/generated/prisma/internal/class.ts
new file mode 100644
index 0000000..7b9c193
--- /dev/null
+++ b/prisma/generated/prisma/internal/class.ts
@@ -0,0 +1,252 @@
+
+/* !!! This is code generated by Prisma. Do not edit directly. !!! */
+/* eslint-disable */
+// biome-ignore-all lint: generated file
+// @ts-nocheck 
+/*
+ * WARNING: This is an internal file that is subject to change!
+ *
+ * 🛑 Under no circumstances should you import this file directly! 🛑
+ *
+ * Please import the `PrismaClient` class from the `client.ts` file instead.
+ */
+
+import * as runtime from "@prisma/client/runtime/client"
+import type * as Prisma from "./prismaNamespace"
+
+
+const config: runtime.GetPrismaClientConfig = {
+  "previewFeatures": [],
+  "clientVersion": "7.3.0",
+  "engineVersion": "9d6ad21cbbceab97458517b147a6a09ff43aa735",
+  "activeProvider": "postgresql",
+  "inlineSchema": "// ============================================================\n// Compile-n-Conquer — Prisma Schema\n// ============================================================\n\ngenerator client {\n  provider = \"prisma-client\"\n  output   = \"./generated/prisma\"\n}\n\ndatasource db {\n  provider = \"postgresql\"\n}\n\n// ---- Users ----\n\nmodel User {\n  id           String    @id @default(cuid())\n  username     String    @unique\n  email        String    @unique\n  passwordHash String\n  displayName  String?\n  avatarUrl    String?\n  skillTier    SkillTier @default(BEGINNER)\n  elo          Int       @default(1000)\n  totalWins    Int       @default(0)\n  totalMatches Int       @default(0)\n  createdAt    DateTime  @default(now())\n  updatedAt    DateTime  @updatedAt\n\n  // Relations\n  submissions  Submission[]\n  matchPlayers MatchPlayer[]\n  queueEntries QueueEntry[]\n\n  @@map(\"users\")\n}\n\nenum SkillTier {\n  BEGINNER\n  INTERMEDIATE\n  ADVANCED\n  PRO\n}\n\n// ---- Matchmaking Queue ----\n\nmodel QueueEntry {\n  id       String   @id @default(cuid())\n  userId   String\n  joinedAt DateTime @default(now())\n  active   Boolean  @default(true)\n\n  user User @relation(fields: [userId], references: [id], onDelete: Cascade)\n\n  @@unique([userId, active])\n  @@map(\"queue_entries\")\n}\n\n// ---- Matches ----\n\nmodel Match {\n  id        String      @id @default(cuid())\n  status    MatchStatus @default(WAITING)\n  mode      GameMode    @default(FASTEST)\n  startedAt DateTime?\n  endedAt   DateTime?\n  createdAt DateTime    @default(now())\n\n  // Backboard thread IDs for evaluation\n  threadTimeComplexity  String?\n  threadSpaceComplexity String?\n  threadOriginality     String?\n  threadRanking         String?\n\n  // Relations\n  players     MatchPlayer[]\n  questions   MatchQuestion[]\n  submissions Submission[]\n\n  @@map(\"matches\")\n}\n\nenum MatchStatus {\n  WAITING // Waiting for all players to connect\n  IN_PROGRESS // Match is live\n  EVALUATING // Code submitted, LLM evaluation running\n  COMPLETED // Results are in\n  CANCELLED\n}\n\nenum GameMode {\n  FASTEST // First to pass all test cases\n  SHORTEST // Shortest code (by chars) that passes\n  REVERSE // Given output, write the code that produces it\n  DEBUGGING // Fix broken code\n}\n\nmodel MatchPlayer {\n  id       String   @id @default(cuid())\n  matchId  String\n  userId   String\n  rank     Int? // Final rank after evaluation\n  score    Float? // Final weighted score\n  joinedAt DateTime @default(now())\n\n  match Match @relation(fields: [matchId], references: [id], onDelete: Cascade)\n  user  User  @relation(fields: [userId], references: [id], onDelete: Cascade)\n\n  @@unique([matchId, userId])\n  @@map(\"match_players\")\n}\n\n// ---- Questions ----\n\nmodel Question {\n  id          String     @id @default(cuid())\n  title       String\n  description String\n  difficulty  Difficulty @default(MEDIUM)\n  mode        GameMode   @default(FASTEST)\n\n  // For DEBUGGING mode: the broken code to fix\n  brokenCode     String?\n  brokenLanguage String?\n\n  // For REVERSE mode: expected output\n  expectedOutput String?\n\n  // Test cases stored as JSON\n  testCases Json? // [{ input: string, expectedOutput: string }]\n\n  createdAt DateTime @default(now())\n  updatedAt DateTime @updatedAt\n\n  // Relations\n  matchQuestions MatchQuestion[]\n  submissions    Submission[]\n\n  @@map(\"questions\")\n}\n\nenum Difficulty {\n  EASY\n  MEDIUM\n  HARD\n}\n\nmodel MatchQuestion {\n  id         String @id @default(cuid())\n  matchId    String\n  questionId String\n  order      Int    @default(0) // Question order in the match\n\n  match    Match    @relation(fields: [matchId], references: [id], onDelete: Cascade)\n  question Question @relation(fields: [questionId], references: [id], onDelete: Cascade)\n\n  @@unique([matchId, questionId])\n  @@map(\"match_questions\")\n}\n\n// ---- Submissions ----\n\nmodel Submission {\n  id         String @id @default(cuid())\n  matchId    String\n  userId     String\n  questionId String\n  code       String\n  language   String\n  charCount  Int? // For SHORTEST mode\n\n  // Piston execution results\n  stdout      String?\n  stderr      String?\n  exitCode    Int?\n  execTimeMs  Int?\n  testsPassed Int     @default(0)\n  testsTotal  Int     @default(0)\n\n  // LLM evaluation scores\n  timeComplexity   String? // e.g. \"O(n)\"\n  timeScore        Float?\n  spaceComplexity  String?\n  spaceScore       Float?\n  originalityScore Float?\n  relevanceScore   Float?\n\n  submittedAt DateTime @default(now())\n\n  match    Match    @relation(fields: [matchId], references: [id], onDelete: Cascade)\n  user     User     @relation(fields: [userId], references: [id], onDelete: Cascade)\n  question Question @relation(fields: [questionId], references: [id], onDelete: Cascade)\n\n  @@map(\"submissions\")\n}\n",
+  "runtimeDataModel": {
+    "models": {},
+    "enums": {},
+    "types": {}
+  }
+}
+
+config.runtimeDataModel = JSON.parse("{\"models\":{\"User\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"username\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"email\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"passwordHash\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"displayName\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"avatarUrl\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"skillTier\",\"kind\":\"enum\",\"type\":\"SkillTier\"},{\"name\":\"elo\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"totalWins\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"totalMatches\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"createdAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"updatedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"submissions\",\"kind\":\"object\",\"type\":\"Submission\",\"relationName\":\"SubmissionToUser\"},{\"name\":\"matchPlayers\",\"kind\":\"object\",\"type\":\"MatchPlayer\",\"relationName\":\"MatchPlayerToUser\"},{\"name\":\"queueEntries\",\"kind\":\"object\",\"type\":\"QueueEntry\",\"relationName\":\"QueueEntryToUser\"}],\"dbName\":\"users\"},\"QueueEntry\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"userId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"joinedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"active\",\"kind\":\"scalar\",\"type\":\"Boolean\"},{\"name\":\"user\",\"kind\":\"object\",\"type\":\"User\",\"relationName\":\"QueueEntryToUser\"}],\"dbName\":\"queue_entries\"},\"Match\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"status\",\"kind\":\"enum\",\"type\":\"MatchStatus\"},{\"name\":\"mode\",\"kind\":\"enum\",\"type\":\"GameMode\"},{\"name\":\"startedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"endedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"createdAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"threadTimeComplexity\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"threadSpaceComplexity\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"threadOriginality\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"threadRanking\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"players\",\"kind\":\"object\",\"type\":\"MatchPlayer\",\"relationName\":\"MatchToMatchPlayer\"},{\"name\":\"questions\",\"kind\":\"object\",\"type\":\"MatchQuestion\",\"relationName\":\"MatchToMatchQuestion\"},{\"name\":\"submissions\",\"kind\":\"object\",\"type\":\"Submission\",\"relationName\":\"MatchToSubmission\"}],\"dbName\":\"matches\"},\"MatchPlayer\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"matchId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"userId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"rank\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"score\",\"kind\":\"scalar\",\"type\":\"Float\"},{\"name\":\"joinedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"match\",\"kind\":\"object\",\"type\":\"Match\",\"relationName\":\"MatchToMatchPlayer\"},{\"name\":\"user\",\"kind\":\"object\",\"type\":\"User\",\"relationName\":\"MatchPlayerToUser\"}],\"dbName\":\"match_players\"},\"Question\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"title\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"description\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"difficulty\",\"kind\":\"enum\",\"type\":\"Difficulty\"},{\"name\":\"mode\",\"kind\":\"enum\",\"type\":\"GameMode\"},{\"name\":\"brokenCode\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"brokenLanguage\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"expectedOutput\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"testCases\",\"kind\":\"scalar\",\"type\":\"Json\"},{\"name\":\"createdAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"updatedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"matchQuestions\",\"kind\":\"object\",\"type\":\"MatchQuestion\",\"relationName\":\"MatchQuestionToQuestion\"},{\"name\":\"submissions\",\"kind\":\"object\",\"type\":\"Submission\",\"relationName\":\"QuestionToSubmission\"}],\"dbName\":\"questions\"},\"MatchQuestion\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"matchId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"questionId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"order\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"match\",\"kind\":\"object\",\"type\":\"Match\",\"relationName\":\"MatchToMatchQuestion\"},{\"name\":\"question\",\"kind\":\"object\",\"type\":\"Question\",\"relationName\":\"MatchQuestionToQuestion\"}],\"dbName\":\"match_questions\"},\"Submission\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"matchId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"userId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"questionId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"code\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"language\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"charCount\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"stdout\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"stderr\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"exitCode\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"execTimeMs\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"testsPassed\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"testsTotal\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"timeComplexity\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"timeScore\",\"kind\":\"scalar\",\"type\":\"Float\"},{\"name\":\"spaceComplexity\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"spaceScore\",\"kind\":\"scalar\",\"type\":\"Float\"},{\"name\":\"originalityScore\",\"kind\":\"scalar\",\"type\":\"Float\"},{\"name\":\"relevanceScore\",\"kind\":\"scalar\",\"type\":\"Float\"},{\"name\":\"submittedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"match\",\"kind\":\"object\",\"type\":\"Match\",\"relationName\":\"MatchToSubmission\"},{\"name\":\"user\",\"kind\":\"object\",\"type\":\"User\",\"relationName\":\"SubmissionToUser\"},{\"name\":\"question\",\"kind\":\"object\",\"type\":\"Question\",\"relationName\":\"QuestionToSubmission\"}],\"dbName\":\"submissions\"}},\"enums\":{},\"types\":{}}")
+
+async function decodeBase64AsWasm(wasmBase64: string): Promise<WebAssembly.Module> {
+  const { Buffer } = await import('node:buffer')
+  const wasmArray = Buffer.from(wasmBase64, 'base64')
+  return new WebAssembly.Module(wasmArray)
+}
+
+config.compilerWasm = {
+  getRuntime: async () => await import("@prisma/client/runtime/query_compiler_fast_bg.postgresql.mjs"),
+
+  getQueryCompilerWasmModule: async () => {
+    const { wasm } = await import("@prisma/client/runtime/query_compiler_fast_bg.postgresql.wasm-base64.mjs")
+    return await decodeBase64AsWasm(wasm)
+  },
+
+  importName: "./query_compiler_fast_bg.js"
+}
+
+
+
+export type LogOptions<ClientOptions extends Prisma.PrismaClientOptions> =
+  'log' extends keyof ClientOptions ? ClientOptions['log'] extends Array<Prisma.LogLevel | Prisma.LogDefinition> ? Prisma.GetEvents<ClientOptions['log']> : never : never
+
+export interface PrismaClientConstructor {
+    /**
+   * ## Prisma Client
+   * 
+   * Type-safe database client for TypeScript
+   * @example
+   * ```
+   * const prisma = new PrismaClient()
+   * // Fetch zero or more Users
+   * const users = await prisma.user.findMany()
+   * ```
+   * 
+   * Read more in our [docs](https://pris.ly/d/client).
+   */
+
+  new <
+    Options extends Prisma.PrismaClientOptions = Prisma.PrismaClientOptions,
+    LogOpts extends LogOptions<Options> = LogOptions<Options>,
+    OmitOpts extends Prisma.PrismaClientOptions['omit'] = Options extends { omit: infer U } ? U : Prisma.PrismaClientOptions['omit'],
+    ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs
+  >(options: Prisma.Subset<Options, Prisma.PrismaClientOptions> ): PrismaClient<LogOpts, OmitOpts, ExtArgs>
+}
+
+/**
+ * ## Prisma Client
+ * 
+ * Type-safe database client for TypeScript
+ * @example
+ * ```
+ * const prisma = new PrismaClient()
+ * // Fetch zero or more Users
+ * const users = await prisma.user.findMany()
+ * ```
+ * 
+ * Read more in our [docs](https://pris.ly/d/client).
+ */
+
+export interface PrismaClient<
+  in LogOpts extends Prisma.LogLevel = never,
+  in out OmitOpts extends Prisma.PrismaClientOptions['omit'] = undefined,
+  in out ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs
+> {
+  [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['other'] }
+
+  $on<V extends LogOpts>(eventType: V, callback: (event: V extends 'query' ? Prisma.QueryEvent : Prisma.LogEvent) => void): PrismaClient;
+
+  /**
+   * Connect with the database
+   */
+  $connect(): runtime.Types.Utils.JsPromise<void>;
+
+  /**
+   * Disconnect from the database
+   */
+  $disconnect(): runtime.Types.Utils.JsPromise<void>;
+
+/**
+   * Executes a prepared raw query and returns the number of affected rows.
+   * @example
+   * ```
+   * const result = await prisma.$executeRaw`UPDATE User SET cool = ${true} WHERE email = ${'user@email.com'};`
+   * ```
+   *
+   * Read more in our [docs](https://pris.ly/d/raw-queries).
+   */
+  $executeRaw<T = unknown>(query: TemplateStringsArray | Prisma.Sql, ...values: any[]): Prisma.PrismaPromise<number>;
+
+  /**
+   * Executes a raw query and returns the number of affected rows.
+   * Susceptible to SQL injections, see documentation.
+   * @example
+   * ```
+   * const result = await prisma.$executeRawUnsafe('UPDATE User SET cool = $1 WHERE email = $2 ;', true, 'user@email.com')
+   * ```
+   *
+   * Read more in our [docs](https://pris.ly/d/raw-queries).
+   */
+  $executeRawUnsafe<T = unknown>(query: string, ...values: any[]): Prisma.PrismaPromise<number>;
+
+  /**
+   * Performs a prepared raw query and returns the `SELECT` data.
+   * @example
+   * ```
+   * const result = await prisma.$queryRaw`SELECT * FROM User WHERE id = ${1} OR email = ${'user@email.com'};`
+   * ```
+   *
+   * Read more in our [docs](https://pris.ly/d/raw-queries).
+   */
+  $queryRaw<T = unknown>(query: TemplateStringsArray | Prisma.Sql, ...values: any[]): Prisma.PrismaPromise<T>;
+
+  /**
+   * Performs a raw query and returns the `SELECT` data.
+   * Susceptible to SQL injections, see documentation.
+   * @example
+   * ```
+   * const result = await prisma.$queryRawUnsafe('SELECT * FROM User WHERE id = $1 OR email = $2;', 1, 'user@email.com')
+   * ```
+   *
+   * Read more in our [docs](https://pris.ly/d/raw-queries).
+   */
+  $queryRawUnsafe<T = unknown>(query: string, ...values: any[]): Prisma.PrismaPromise<T>;
+
+
+  /**
+   * Allows the running of a sequence of read/write operations that are guaranteed to either succeed or fail as a whole.
+   * @example
+   * ```
+   * const [george, bob, alice] = await prisma.$transaction([
+   *   prisma.user.create({ data: { name: 'George' } }),
+   *   prisma.user.create({ data: { name: 'Bob' } }),
+   *   prisma.user.create({ data: { name: 'Alice' } }),
+   * ])
+   * ```
+   * 
+   * Read more in our [docs](https://www.prisma.io/docs/concepts/components/prisma-client/transactions).
+   */
+  $transaction<P extends Prisma.PrismaPromise<any>[]>(arg: [...P], options?: { isolationLevel?: Prisma.TransactionIsolationLevel }): runtime.Types.Utils.JsPromise<runtime.Types.Utils.UnwrapTuple<P>>
+
+  $transaction<R>(fn: (prisma: Omit<PrismaClient, runtime.ITXClientDenyList>) => runtime.Types.Utils.JsPromise<R>, options?: { maxWait?: number, timeout?: number, isolationLevel?: Prisma.TransactionIsolationLevel }): runtime.Types.Utils.JsPromise<R>
+
+  $extends: runtime.Types.Extensions.ExtendsHook<"extends", Prisma.TypeMapCb<OmitOpts>, ExtArgs, runtime.Types.Utils.Call<Prisma.TypeMapCb<OmitOpts>, {
+    extArgs: ExtArgs
+  }>>
+
+      /**
+   * `prisma.user`: Exposes CRUD operations for the **User** model.
+    * Example usage:
+    * ```ts
+    * // Fetch zero or more Users
+    * const users = await prisma.user.findMany()
+    * ```
+    */
+  get user(): Prisma.UserDelegate<ExtArgs, { omit: OmitOpts }>;
+
+  /**
+   * `prisma.queueEntry`: Exposes CRUD operations for the **QueueEntry** model.
+    * Example usage:
+    * ```ts
+    * // Fetch zero or more QueueEntries
+    * const queueEntries = await prisma.queueEntry.findMany()
+    * ```
+    */
+  get queueEntry(): Prisma.QueueEntryDelegate<ExtArgs, { omit: OmitOpts }>;
+
+  /**
+   * `prisma.match`: Exposes CRUD operations for the **Match** model.
+    * Example usage:
+    * ```ts
+    * // Fetch zero or more Matches
+    * const matches = await prisma.match.findMany()
+    * ```
+    */
+  get match(): Prisma.MatchDelegate<ExtArgs, { omit: OmitOpts }>;
+
+  /**
+   * `prisma.matchPlayer`: Exposes CRUD operations for the **MatchPlayer** model.
+    * Example usage:
+    * ```ts
+    * // Fetch zero or more MatchPlayers
+    * const matchPlayers = await prisma.matchPlayer.findMany()
+    * ```
+    */
+  get matchPlayer(): Prisma.MatchPlayerDelegate<ExtArgs, { omit: OmitOpts }>;
+
+  /**
+   * `prisma.question`: Exposes CRUD operations for the **Question** model.
+    * Example usage:
+    * ```ts
+    * // Fetch zero or more Questions
+    * const questions = await prisma.question.findMany()
+    * ```
+    */
+  get question(): Prisma.QuestionDelegate<ExtArgs, { omit: OmitOpts }>;
+
+  /**
+   * `prisma.matchQuestion`: Exposes CRUD operations for the **MatchQuestion** model.
+    * Example usage:
+    * ```ts
+    * // Fetch zero or more MatchQuestions
+    * const matchQuestions = await prisma.matchQuestion.findMany()
+    * ```
+    */
+  get matchQuestion(): Prisma.MatchQuestionDelegate<ExtArgs, { omit: OmitOpts }>;
+
+  /**
+   * `prisma.submission`: Exposes CRUD operations for the **Submission** model.
+    * Example usage:
+    * ```ts
+    * // Fetch zero or more Submissions
+    * const submissions = await prisma.submission.findMany()
+    * ```
+    */
+  get submission(): Prisma.SubmissionDelegate<ExtArgs, { omit: OmitOpts }>;
+}
+
+export function getPrismaClientClass(): PrismaClientConstructor {
+  return runtime.getPrismaClient(config) as unknown as PrismaClientConstructor
+}
diff --git a/prisma/generated/prisma/internal/prismaNamespace.ts b/prisma/generated/prisma/internal/prismaNamespace.ts
new file mode 100644
index 0000000..5941113
--- /dev/null
+++ b/prisma/generated/prisma/internal/prismaNamespace.ts
@@ -0,0 +1,1422 @@
+
+/* !!! This is code generated by Prisma. Do not edit directly. !!! */
+/* eslint-disable */
+// biome-ignore-all lint: generated file
+// @ts-nocheck 
+/*
+ * WARNING: This is an internal file that is subject to change!
+ *
+ * 🛑 Under no circumstances should you import this file directly! 🛑
+ *
+ * All exports from this file are wrapped under a `Prisma` namespace object in the client.ts file.
+ * While this enables partial backward compatibility, it is not part of the stable public API.
+ *
+ * If you are looking for your Models, Enums, and Input Types, please import them from the respective
+ * model files in the `model` directory!
+ */
+
+import * as runtime from "@prisma/client/runtime/client"
+import type * as Prisma from "../models"
+import { type PrismaClient } from "./class"
+
+export type * from '../models'
+
+export type DMMF = typeof runtime.DMMF
+
+export type PrismaPromise<T> = runtime.Types.Public.PrismaPromise<T>
+
+/**
+ * Prisma Errors
+ */
+
+export const PrismaClientKnownRequestError = runtime.PrismaClientKnownRequestError
+export type PrismaClientKnownRequestError = runtime.PrismaClientKnownRequestError
+
+export const PrismaClientUnknownRequestError = runtime.PrismaClientUnknownRequestError
+export type PrismaClientUnknownRequestError = runtime.PrismaClientUnknownRequestError
+
+export const PrismaClientRustPanicError = runtime.PrismaClientRustPanicError
+export type PrismaClientRustPanicError = runtime.PrismaClientRustPanicError
+
+export const PrismaClientInitializationError = runtime.PrismaClientInitializationError
+export type PrismaClientInitializationError = runtime.PrismaClientInitializationError
+
+export const PrismaClientValidationError = runtime.PrismaClientValidationError
+export type PrismaClientValidationError = runtime.PrismaClientValidationError
+
+/**
+ * Re-export of sql-template-tag
+ */
+export const sql = runtime.sqltag
+export const empty = runtime.empty
+export const join = runtime.join
+export const raw = runtime.raw
+export const Sql = runtime.Sql
+export type Sql = runtime.Sql
+
+
+
+/**
+ * Decimal.js
+ */
+export const Decimal = runtime.Decimal
+export type Decimal = runtime.Decimal
+
+export type DecimalJsLike = runtime.DecimalJsLike
+
+/**
+* Extensions
+*/
+export type Extension = runtime.Types.Extensions.UserArgs
+export const getExtensionContext = runtime.Extensions.getExtensionContext
+export type Args<T, F extends runtime.Operation> = runtime.Types.Public.Args<T, F>
+export type Payload<T, F extends runtime.Operation = never> = runtime.Types.Public.Payload<T, F>
+export type Result<T, A, F extends runtime.Operation> = runtime.Types.Public.Result<T, A, F>
+export type Exact<A, W> = runtime.Types.Public.Exact<A, W>
+
+export type PrismaVersion = {
+  client: string
+  engine: string
+}
+
+/**
+ * Prisma Client JS version: 7.3.0
+ * Query Engine version: 9d6ad21cbbceab97458517b147a6a09ff43aa735
+ */
+export const prismaVersion: PrismaVersion = {
+  client: "7.3.0",
+  engine: "9d6ad21cbbceab97458517b147a6a09ff43aa735"
+}
+
+/**
+ * Utility Types
+ */
+
+export type Bytes = runtime.Bytes
+export type JsonObject = runtime.JsonObject
+export type JsonArray = runtime.JsonArray
+export type JsonValue = runtime.JsonValue
+export type InputJsonObject = runtime.InputJsonObject
+export type InputJsonArray = runtime.InputJsonArray
+export type InputJsonValue = runtime.InputJsonValue
+
+
+export const NullTypes = {
+  DbNull: runtime.NullTypes.DbNull as (new (secret: never) => typeof runtime.DbNull),
+  JsonNull: runtime.NullTypes.JsonNull as (new (secret: never) => typeof runtime.JsonNull),
+  AnyNull: runtime.NullTypes.AnyNull as (new (secret: never) => typeof runtime.AnyNull),
+}
+/**
+ * Helper for filtering JSON entries that have `null` on the database (empty on the db)
+ *
+ * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
+ */
+export const DbNull = runtime.DbNull
+
+/**
+ * Helper for filtering JSON entries that have JSON `null` values (not empty on the db)
+ *
+ * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
+ */
+export const JsonNull = runtime.JsonNull
+
+/**
+ * Helper for filtering JSON entries that are `Prisma.DbNull` or `Prisma.JsonNull`
+ *
+ * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
+ */
+export const AnyNull = runtime.AnyNull
+
+
+type SelectAndInclude = {
+  select: any
+  include: any
+}
+
+type SelectAndOmit = {
+  select: any
+  omit: any
+}
+
+/**
+ * From T, pick a set of properties whose keys are in the union K
+ */
+type Prisma__Pick<T, K extends keyof T> = {
+    [P in K]: T[P];
+};
+
+export type Enumerable<T> = T | Array<T>;
+
+/**
+ * Subset
+ * @desc From `T` pick properties that exist in `U`. Simple version of Intersection
+ */
+export type Subset<T, U> = {
+  [key in keyof T]: key extends keyof U ? T[key] : never;
+};
+
+/**
+ * SelectSubset
+ * @desc From `T` pick properties that exist in `U`. Simple version of Intersection.
+ * Additionally, it validates, if both select and include are present. If the case, it errors.
+ */
+export type SelectSubset<T, U> = {
+  [key in keyof T]: key extends keyof U ? T[key] : never
+} &
+  (T extends SelectAndInclude
+    ? 'Please either choose `select` or `include`.'
+    : T extends SelectAndOmit
+      ? 'Please either choose `select` or `omit`.'
+      : {})
+
+/**
+ * Subset + Intersection
+ * @desc From `T` pick properties that exist in `U` and intersect `K`
+ */
+export type SubsetIntersection<T, U, K> = {
+  [key in keyof T]: key extends keyof U ? T[key] : never
+} &
+  K
+
+type Without<T, U> = { [P in Exclude<keyof T, keyof U>]?: never };
+
+/**
+ * XOR is needed to have a real mutually exclusive union type
+ * https://stackoverflow.com/questions/42123407/does-typescript-support-mutually-exclusive-types
+ */
+export type XOR<T, U> =
+  T extends object ?
+  U extends object ?
+    (Without<T, U> & U) | (Without<U, T> & T)
+  : U : T
+
+
+/**
+ * Is T a Record?
+ */
+type IsObject<T extends any> = T extends Array<any>
+? False
+: T extends Date
+? False
+: T extends Uint8Array
+? False
+: T extends BigInt
+? False
+: T extends object
+? True
+: False
+
+
+/**
+ * If it's T[], return T
+ */
+export type UnEnumerate<T extends unknown> = T extends Array<infer U> ? U : T
+
+/**
+ * From ts-toolbelt
+ */
+
+type __Either<O extends object, K extends Key> = Omit<O, K> &
+  {
+    // Merge all but K
+    [P in K]: Prisma__Pick<O, P & keyof O> // With K possibilities
+  }[K]
+
+type EitherStrict<O extends object, K extends Key> = Strict<__Either<O, K>>
+
+type EitherLoose<O extends object, K extends Key> = ComputeRaw<__Either<O, K>>
+
+type _Either<
+  O extends object,
+  K extends Key,
+  strict extends Boolean
+> = {
+  1: EitherStrict<O, K>
+  0: EitherLoose<O, K>
+}[strict]
+
+export type Either<
+  O extends object,
+  K extends Key,
+  strict extends Boolean = 1
+> = O extends unknown ? _Either<O, K, strict> : never
+
+export type Union = any
+
+export type PatchUndefined<O extends object, O1 extends object> = {
+  [K in keyof O]: O[K] extends undefined ? At<O1, K> : O[K]
+} & {}
+
+/** Helper Types for "Merge" **/
+export type IntersectOf<U extends Union> = (
+  U extends unknown ? (k: U) => void : never
+) extends (k: infer I) => void
+  ? I
+  : never
+
+export type Overwrite<O extends object, O1 extends object> = {
+    [K in keyof O]: K extends keyof O1 ? O1[K] : O[K];
+} & {};
+
+type _Merge<U extends object> = IntersectOf<Overwrite<U, {
+    [K in keyof U]-?: At<U, K>;
+}>>;
+
+type Key = string | number | symbol;
+type AtStrict<O extends object, K extends Key> = O[K & keyof O];
+type AtLoose<O extends object, K extends Key> = O extends unknown ? AtStrict<O, K> : never;
+export type At<O extends object, K extends Key, strict extends Boolean = 1> = {
+    1: AtStrict<O, K>;
+    0: AtLoose<O, K>;
+}[strict];
+
+export type ComputeRaw<A extends any> = A extends Function ? A : {
+  [K in keyof A]: A[K];
+} & {};
+
+export type OptionalFlat<O> = {
+  [K in keyof O]?: O[K];
+} & {};
+
+type _Record<K extends keyof any, T> = {
+  [P in K]: T;
+};
+
+// cause typescript not to expand types and preserve names
+type NoExpand<T> = T extends unknown ? T : never;
+
+// this type assumes the passed object is entirely optional
+export type AtLeast<O extends object, K extends string> = NoExpand<
+  O extends unknown
+  ? | (K extends keyof O ? { [P in K]: O[P] } & O : O)
+    | {[P in keyof O as P extends K ? P : never]-?: O[P]} & O
+  : never>;
+
+type _Strict<U, _U = U> = U extends unknown ? U & OptionalFlat<_Record<Exclude<Keys<_U>, keyof U>, never>> : never;
+
+export type Strict<U extends object> = ComputeRaw<_Strict<U>>;
+/** End Helper Types for "Merge" **/
+
+export type Merge<U extends object> = ComputeRaw<_Merge<Strict<U>>>;
+
+export type Boolean = True | False
+
+export type True = 1
+
+export type False = 0
+
+export type Not<B extends Boolean> = {
+  0: 1
+  1: 0
+}[B]
+
+export type Extends<A1 extends any, A2 extends any> = [A1] extends [never]
+  ? 0 // anything `never` is false
+  : A1 extends A2
+  ? 1
+  : 0
+
+export type Has<U extends Union, U1 extends Union> = Not<
+  Extends<Exclude<U1, U>, U1>
+>
+
+export type Or<B1 extends Boolean, B2 extends Boolean> = {
+  0: {
+    0: 0
+    1: 1
+  }
+  1: {
+    0: 1
+    1: 1
+  }
+}[B1][B2]
+
+export type Keys<U extends Union> = U extends unknown ? keyof U : never
+
+export type GetScalarType<T, O> = O extends object ? {
+  [P in keyof T]: P extends keyof O
+    ? O[P]
+    : never
+} : never
+
+type FieldPaths<
+  T,
+  U = Omit<T, '_avg' | '_sum' | '_count' | '_min' | '_max'>
+> = IsObject<T> extends True ? U : T
+
+export type GetHavingFields<T> = {
+  [K in keyof T]: Or<
+    Or<Extends<'OR', K>, Extends<'AND', K>>,
+    Extends<'NOT', K>
+  > extends True
+    ? // infer is only needed to not hit TS limit
+      // based on the brilliant idea of Pierre-Antoine Mills
+      // https://github.com/microsoft/TypeScript/issues/30188#issuecomment-478938437
+      T[K] extends infer TK
+      ? GetHavingFields<UnEnumerate<TK> extends object ? Merge<UnEnumerate<TK>> : never>
+      : never
+    : {} extends FieldPaths<T[K]>
+    ? never
+    : K
+}[keyof T]
+
+/**
+ * Convert tuple to union
+ */
+type _TupleToUnion<T> = T extends (infer E)[] ? E : never
+type TupleToUnion<K extends readonly any[]> = _TupleToUnion<K>
+export type MaybeTupleToUnion<T> = T extends any[] ? TupleToUnion<T> : T
+
+/**
+ * Like `Pick`, but additionally can also accept an array of keys
+ */
+export type PickEnumerable<T, K extends Enumerable<keyof T> | keyof T> = Prisma__Pick<T, MaybeTupleToUnion<K>>
+
+/**
+ * Exclude all keys with underscores
+ */
+export type ExcludeUnderscoreKeys<T extends string> = T extends `_${string}` ? never : T
+
+
+export type FieldRef<Model, FieldType> = runtime.FieldRef<Model, FieldType>
+
+type FieldRefInputType<Model, FieldType> = Model extends never ? never : FieldRef<Model, FieldType>
+
+
+export const ModelName = {
+  User: 'User',
+  QueueEntry: 'QueueEntry',
+  Match: 'Match',
+  MatchPlayer: 'MatchPlayer',
+  Question: 'Question',
+  MatchQuestion: 'MatchQuestion',
+  Submission: 'Submission'
+} as const
+
+export type ModelName = (typeof ModelName)[keyof typeof ModelName]
+
+
+
+export interface TypeMapCb<GlobalOmitOptions = {}> extends runtime.Types.Utils.Fn<{extArgs: runtime.Types.Extensions.InternalArgs }, runtime.Types.Utils.Record<string, any>> {
+  returns: TypeMap<this['params']['extArgs'], GlobalOmitOptions>
+}
+
+export type TypeMap<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> = {
+  globalOmitOptions: {
+    omit: GlobalOmitOptions
+  }
+  meta: {
+    modelProps: "user" | "queueEntry" | "match" | "matchPlayer" | "question" | "matchQuestion" | "submission"
+    txIsolationLevel: TransactionIsolationLevel
+  }
+  model: {
+    User: {
+      payload: Prisma.$UserPayload<ExtArgs>
+      fields: Prisma.UserFieldRefs
+      operations: {
+        findUnique: {
+          args: Prisma.UserFindUniqueArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload> | null
+        }
+        findUniqueOrThrow: {
+          args: Prisma.UserFindUniqueOrThrowArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload>
+        }
+        findFirst: {
+          args: Prisma.UserFindFirstArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload> | null
+        }
+        findFirstOrThrow: {
+          args: Prisma.UserFindFirstOrThrowArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload>
+        }
+        findMany: {
+          args: Prisma.UserFindManyArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload>[]
+        }
+        create: {
+          args: Prisma.UserCreateArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload>
+        }
+        createMany: {
+          args: Prisma.UserCreateManyArgs<ExtArgs>
+          result: BatchPayload
+        }
+        createManyAndReturn: {
+          args: Prisma.UserCreateManyAndReturnArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload>[]
+        }
+        delete: {
+          args: Prisma.UserDeleteArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload>
+        }
+        update: {
+          args: Prisma.UserUpdateArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload>
+        }
+        deleteMany: {
+          args: Prisma.UserDeleteManyArgs<ExtArgs>
+          result: BatchPayload
+        }
+        updateMany: {
+          args: Prisma.UserUpdateManyArgs<ExtArgs>
+          result: BatchPayload
+        }
+        updateManyAndReturn: {
+          args: Prisma.UserUpdateManyAndReturnArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload>[]
+        }
+        upsert: {
+          args: Prisma.UserUpsertArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload>
+        }
+        aggregate: {
+          args: Prisma.UserAggregateArgs<ExtArgs>
+          result: runtime.Types.Utils.Optional<Prisma.AggregateUser>
+        }
+        groupBy: {
+          args: Prisma.UserGroupByArgs<ExtArgs>
+          result: runtime.Types.Utils.Optional<Prisma.UserGroupByOutputType>[]
+        }
+        count: {
+          args: Prisma.UserCountArgs<ExtArgs>
+          result: runtime.Types.Utils.Optional<Prisma.UserCountAggregateOutputType> | number
+        }
+      }
+    }
+    QueueEntry: {
+      payload: Prisma.$QueueEntryPayload<ExtArgs>
+      fields: Prisma.QueueEntryFieldRefs
+      operations: {
+        findUnique: {
+          args: Prisma.QueueEntryFindUniqueArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$QueueEntryPayload> | null
+        }
+        findUniqueOrThrow: {
+          args: Prisma.QueueEntryFindUniqueOrThrowArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$QueueEntryPayload>
+        }
+        findFirst: {
+          args: Prisma.QueueEntryFindFirstArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$QueueEntryPayload> | null
+        }
+        findFirstOrThrow: {
+          args: Prisma.QueueEntryFindFirstOrThrowArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$QueueEntryPayload>
+        }
+        findMany: {
+          args: Prisma.QueueEntryFindManyArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$QueueEntryPayload>[]
+        }
+        create: {
+          args: Prisma.QueueEntryCreateArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$QueueEntryPayload>
+        }
+        createMany: {
+          args: Prisma.QueueEntryCreateManyArgs<ExtArgs>
+          result: BatchPayload
+        }
+        createManyAndReturn: {
+          args: Prisma.QueueEntryCreateManyAndReturnArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$QueueEntryPayload>[]
+        }
+        delete: {
+          args: Prisma.QueueEntryDeleteArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$QueueEntryPayload>
+        }
+        update: {
+          args: Prisma.QueueEntryUpdateArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$QueueEntryPayload>
+        }
+        deleteMany: {
+          args: Prisma.QueueEntryDeleteManyArgs<ExtArgs>
+          result: BatchPayload
+        }
+        updateMany: {
+          args: Prisma.QueueEntryUpdateManyArgs<ExtArgs>
+          result: BatchPayload
+        }
+        updateManyAndReturn: {
+          args: Prisma.QueueEntryUpdateManyAndReturnArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$QueueEntryPayload>[]
+        }
+        upsert: {
+          args: Prisma.QueueEntryUpsertArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$QueueEntryPayload>
+        }
+        aggregate: {
+          args: Prisma.QueueEntryAggregateArgs<ExtArgs>
+          result: runtime.Types.Utils.Optional<Prisma.AggregateQueueEntry>
+        }
+        groupBy: {
+          args: Prisma.QueueEntryGroupByArgs<ExtArgs>
+          result: runtime.Types.Utils.Optional<Prisma.QueueEntryGroupByOutputType>[]
+        }
+        count: {
+          args: Prisma.QueueEntryCountArgs<ExtArgs>
+          result: runtime.Types.Utils.Optional<Prisma.QueueEntryCountAggregateOutputType> | number
+        }
+      }
+    }
+    Match: {
+      payload: Prisma.$MatchPayload<ExtArgs>
+      fields: Prisma.MatchFieldRefs
+      operations: {
+        findUnique: {
+          args: Prisma.MatchFindUniqueArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$MatchPayload> | null
+        }
+        findUniqueOrThrow: {
+          args: Prisma.MatchFindUniqueOrThrowArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$MatchPayload>
+        }
+        findFirst: {
+          args: Prisma.MatchFindFirstArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$MatchPayload> | null
+        }
+        findFirstOrThrow: {
+          args: Prisma.MatchFindFirstOrThrowArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$MatchPayload>
+        }
+        findMany: {
+          args: Prisma.MatchFindManyArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$MatchPayload>[]
+        }
+        create: {
+          args: Prisma.MatchCreateArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$MatchPayload>
+        }
+        createMany: {
+          args: Prisma.MatchCreateManyArgs<ExtArgs>
+          result: BatchPayload
+        }
+        createManyAndReturn: {
+          args: Prisma.MatchCreateManyAndReturnArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$MatchPayload>[]
+        }
+        delete: {
+          args: Prisma.MatchDeleteArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$MatchPayload>
+        }
+        update: {
+          args: Prisma.MatchUpdateArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$MatchPayload>
+        }
+        deleteMany: {
+          args: Prisma.MatchDeleteManyArgs<ExtArgs>
+          result: BatchPayload
+        }
+        updateMany: {
+          args: Prisma.MatchUpdateManyArgs<ExtArgs>
+          result: BatchPayload
+        }
+        updateManyAndReturn: {
+          args: Prisma.MatchUpdateManyAndReturnArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$MatchPayload>[]
+        }
+        upsert: {
+          args: Prisma.MatchUpsertArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$MatchPayload>
+        }
+        aggregate: {
+          args: Prisma.MatchAggregateArgs<ExtArgs>
+          result: runtime.Types.Utils.Optional<Prisma.AggregateMatch>
+        }
+        groupBy: {
+          args: Prisma.MatchGroupByArgs<ExtArgs>
+          result: runtime.Types.Utils.Optional<Prisma.MatchGroupByOutputType>[]
+        }
+        count: {
+          args: Prisma.MatchCountArgs<ExtArgs>
+          result: runtime.Types.Utils.Optional<Prisma.MatchCountAggregateOutputType> | number
+        }
+      }
+    }
+    MatchPlayer: {
+      payload: Prisma.$MatchPlayerPayload<ExtArgs>
+      fields: Prisma.MatchPlayerFieldRefs
+      operations: {
+        findUnique: {
+          args: Prisma.MatchPlayerFindUniqueArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$MatchPlayerPayload> | null
+        }
+        findUniqueOrThrow: {
+          args: Prisma.MatchPlayerFindUniqueOrThrowArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$MatchPlayerPayload>
+        }
+        findFirst: {
+          args: Prisma.MatchPlayerFindFirstArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$MatchPlayerPayload> | null
+        }
+        findFirstOrThrow: {
+          args: Prisma.MatchPlayerFindFirstOrThrowArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$MatchPlayerPayload>
+        }
+        findMany: {
+          args: Prisma.MatchPlayerFindManyArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$MatchPlayerPayload>[]
+        }
+        create: {
+          args: Prisma.MatchPlayerCreateArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$MatchPlayerPayload>
+        }
+        createMany: {
+          args: Prisma.MatchPlayerCreateManyArgs<ExtArgs>
+          result: BatchPayload
+        }
+        createManyAndReturn: {
+          args: Prisma.MatchPlayerCreateManyAndReturnArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$MatchPlayerPayload>[]
+        }
+        delete: {
+          args: Prisma.MatchPlayerDeleteArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$MatchPlayerPayload>
+        }
+        update: {
+          args: Prisma.MatchPlayerUpdateArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$MatchPlayerPayload>
+        }
+        deleteMany: {
+          args: Prisma.MatchPlayerDeleteManyArgs<ExtArgs>
+          result: BatchPayload
+        }
+        updateMany: {
+          args: Prisma.MatchPlayerUpdateManyArgs<ExtArgs>
+          result: BatchPayload
+        }
+        updateManyAndReturn: {
+          args: Prisma.MatchPlayerUpdateManyAndReturnArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$MatchPlayerPayload>[]
+        }
+        upsert: {
+          args: Prisma.MatchPlayerUpsertArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$MatchPlayerPayload>
+        }
+        aggregate: {
+          args: Prisma.MatchPlayerAggregateArgs<ExtArgs>
+          result: runtime.Types.Utils.Optional<Prisma.AggregateMatchPlayer>
+        }
+        groupBy: {
+          args: Prisma.MatchPlayerGroupByArgs<ExtArgs>
+          result: runtime.Types.Utils.Optional<Prisma.MatchPlayerGroupByOutputType>[]
+        }
+        count: {
+          args: Prisma.MatchPlayerCountArgs<ExtArgs>
+          result: runtime.Types.Utils.Optional<Prisma.MatchPlayerCountAggregateOutputType> | number
+        }
+      }
+    }
+    Question: {
+      payload: Prisma.$QuestionPayload<ExtArgs>
+      fields: Prisma.QuestionFieldRefs
+      operations: {
+        findUnique: {
+          args: Prisma.QuestionFindUniqueArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$QuestionPayload> | null
+        }
+        findUniqueOrThrow: {
+          args: Prisma.QuestionFindUniqueOrThrowArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$QuestionPayload>
+        }
+        findFirst: {
+          args: Prisma.QuestionFindFirstArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$QuestionPayload> | null
+        }
+        findFirstOrThrow: {
+          args: Prisma.QuestionFindFirstOrThrowArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$QuestionPayload>
+        }
+        findMany: {
+          args: Prisma.QuestionFindManyArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$QuestionPayload>[]
+        }
+        create: {
+          args: Prisma.QuestionCreateArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$QuestionPayload>
+        }
+        createMany: {
+          args: Prisma.QuestionCreateManyArgs<ExtArgs>
+          result: BatchPayload
+        }
+        createManyAndReturn: {
+          args: Prisma.QuestionCreateManyAndReturnArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$QuestionPayload>[]
+        }
+        delete: {
+          args: Prisma.QuestionDeleteArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$QuestionPayload>
+        }
+        update: {
+          args: Prisma.QuestionUpdateArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$QuestionPayload>
+        }
+        deleteMany: {
+          args: Prisma.QuestionDeleteManyArgs<ExtArgs>
+          result: BatchPayload
+        }
+        updateMany: {
+          args: Prisma.QuestionUpdateManyArgs<ExtArgs>
+          result: BatchPayload
+        }
+        updateManyAndReturn: {
+          args: Prisma.QuestionUpdateManyAndReturnArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$QuestionPayload>[]
+        }
+        upsert: {
+          args: Prisma.QuestionUpsertArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$QuestionPayload>
+        }
+        aggregate: {
+          args: Prisma.QuestionAggregateArgs<ExtArgs>
+          result: runtime.Types.Utils.Optional<Prisma.AggregateQuestion>
+        }
+        groupBy: {
+          args: Prisma.QuestionGroupByArgs<ExtArgs>
+          result: runtime.Types.Utils.Optional<Prisma.QuestionGroupByOutputType>[]
+        }
+        count: {
+          args: Prisma.QuestionCountArgs<ExtArgs>
+          result: runtime.Types.Utils.Optional<Prisma.QuestionCountAggregateOutputType> | number
+        }
+      }
+    }
+    MatchQuestion: {
+      payload: Prisma.$MatchQuestionPayload<ExtArgs>
+      fields: Prisma.MatchQuestionFieldRefs
+      operations: {
+        findUnique: {
+          args: Prisma.MatchQuestionFindUniqueArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$MatchQuestionPayload> | null
+        }
+        findUniqueOrThrow: {
+          args: Prisma.MatchQuestionFindUniqueOrThrowArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$MatchQuestionPayload>
+        }
+        findFirst: {
+          args: Prisma.MatchQuestionFindFirstArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$MatchQuestionPayload> | null
+        }
+        findFirstOrThrow: {
+          args: Prisma.MatchQuestionFindFirstOrThrowArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$MatchQuestionPayload>
+        }
+        findMany: {
+          args: Prisma.MatchQuestionFindManyArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$MatchQuestionPayload>[]
+        }
+        create: {
+          args: Prisma.MatchQuestionCreateArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$MatchQuestionPayload>
+        }
+        createMany: {
+          args: Prisma.MatchQuestionCreateManyArgs<ExtArgs>
+          result: BatchPayload
+        }
+        createManyAndReturn: {
+          args: Prisma.MatchQuestionCreateManyAndReturnArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$MatchQuestionPayload>[]
+        }
+        delete: {
+          args: Prisma.MatchQuestionDeleteArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$MatchQuestionPayload>
+        }
+        update: {
+          args: Prisma.MatchQuestionUpdateArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$MatchQuestionPayload>
+        }
+        deleteMany: {
+          args: Prisma.MatchQuestionDeleteManyArgs<ExtArgs>
+          result: BatchPayload
+        }
+        updateMany: {
+          args: Prisma.MatchQuestionUpdateManyArgs<ExtArgs>
+          result: BatchPayload
+        }
+        updateManyAndReturn: {
+          args: Prisma.MatchQuestionUpdateManyAndReturnArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$MatchQuestionPayload>[]
+        }
+        upsert: {
+          args: Prisma.MatchQuestionUpsertArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$MatchQuestionPayload>
+        }
+        aggregate: {
+          args: Prisma.MatchQuestionAggregateArgs<ExtArgs>
+          result: runtime.Types.Utils.Optional<Prisma.AggregateMatchQuestion>
+        }
+        groupBy: {
+          args: Prisma.MatchQuestionGroupByArgs<ExtArgs>
+          result: runtime.Types.Utils.Optional<Prisma.MatchQuestionGroupByOutputType>[]
+        }
+        count: {
+          args: Prisma.MatchQuestionCountArgs<ExtArgs>
+          result: runtime.Types.Utils.Optional<Prisma.MatchQuestionCountAggregateOutputType> | number
+        }
+      }
+    }
+    Submission: {
+      payload: Prisma.$SubmissionPayload<ExtArgs>
+      fields: Prisma.SubmissionFieldRefs
+      operations: {
+        findUnique: {
+          args: Prisma.SubmissionFindUniqueArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$SubmissionPayload> | null
+        }
+        findUniqueOrThrow: {
+          args: Prisma.SubmissionFindUniqueOrThrowArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$SubmissionPayload>
+        }
+        findFirst: {
+          args: Prisma.SubmissionFindFirstArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$SubmissionPayload> | null
+        }
+        findFirstOrThrow: {
+          args: Prisma.SubmissionFindFirstOrThrowArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$SubmissionPayload>
+        }
+        findMany: {
+          args: Prisma.SubmissionFindManyArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$SubmissionPayload>[]
+        }
+        create: {
+          args: Prisma.SubmissionCreateArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$SubmissionPayload>
+        }
+        createMany: {
+          args: Prisma.SubmissionCreateManyArgs<ExtArgs>
+          result: BatchPayload
+        }
+        createManyAndReturn: {
+          args: Prisma.SubmissionCreateManyAndReturnArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$SubmissionPayload>[]
+        }
+        delete: {
+          args: Prisma.SubmissionDeleteArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$SubmissionPayload>
+        }
+        update: {
+          args: Prisma.SubmissionUpdateArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$SubmissionPayload>
+        }
+        deleteMany: {
+          args: Prisma.SubmissionDeleteManyArgs<ExtArgs>
+          result: BatchPayload
+        }
+        updateMany: {
+          args: Prisma.SubmissionUpdateManyArgs<ExtArgs>
+          result: BatchPayload
+        }
+        updateManyAndReturn: {
+          args: Prisma.SubmissionUpdateManyAndReturnArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$SubmissionPayload>[]
+        }
+        upsert: {
+          args: Prisma.SubmissionUpsertArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$SubmissionPayload>
+        }
+        aggregate: {
+          args: Prisma.SubmissionAggregateArgs<ExtArgs>
+          result: runtime.Types.Utils.Optional<Prisma.AggregateSubmission>
+        }
+        groupBy: {
+          args: Prisma.SubmissionGroupByArgs<ExtArgs>
+          result: runtime.Types.Utils.Optional<Prisma.SubmissionGroupByOutputType>[]
+        }
+        count: {
+          args: Prisma.SubmissionCountArgs<ExtArgs>
+          result: runtime.Types.Utils.Optional<Prisma.SubmissionCountAggregateOutputType> | number
+        }
+      }
+    }
+  }
+} & {
+  other: {
+    payload: any
+    operations: {
+      $executeRaw: {
+        args: [query: TemplateStringsArray | Sql, ...values: any[]],
+        result: any
+      }
+      $executeRawUnsafe: {
+        args: [query: string, ...values: any[]],
+        result: any
+      }
+      $queryRaw: {
+        args: [query: TemplateStringsArray | Sql, ...values: any[]],
+        result: any
+      }
+      $queryRawUnsafe: {
+        args: [query: string, ...values: any[]],
+        result: any
+      }
+    }
+  }
+}
+
+/**
+ * Enums
+ */
+
+export const TransactionIsolationLevel = runtime.makeStrictEnum({
+  ReadUncommitted: 'ReadUncommitted',
+  ReadCommitted: 'ReadCommitted',
+  RepeatableRead: 'RepeatableRead',
+  Serializable: 'Serializable'
+} as const)
+
+export type TransactionIsolationLevel = (typeof TransactionIsolationLevel)[keyof typeof TransactionIsolationLevel]
+
+
+export const UserScalarFieldEnum = {
+  id: 'id',
+  username: 'username',
+  email: 'email',
+  passwordHash: 'passwordHash',
+  displayName: 'displayName',
+  avatarUrl: 'avatarUrl',
+  skillTier: 'skillTier',
+  elo: 'elo',
+  totalWins: 'totalWins',
+  totalMatches: 'totalMatches',
+  createdAt: 'createdAt',
+  updatedAt: 'updatedAt'
+} as const
+
+export type UserScalarFieldEnum = (typeof UserScalarFieldEnum)[keyof typeof UserScalarFieldEnum]
+
+
+export const QueueEntryScalarFieldEnum = {
+  id: 'id',
+  userId: 'userId',
+  joinedAt: 'joinedAt',
+  active: 'active'
+} as const
+
+export type QueueEntryScalarFieldEnum = (typeof QueueEntryScalarFieldEnum)[keyof typeof QueueEntryScalarFieldEnum]
+
+
+export const MatchScalarFieldEnum = {
+  id: 'id',
+  status: 'status',
+  mode: 'mode',
+  startedAt: 'startedAt',
+  endedAt: 'endedAt',
+  createdAt: 'createdAt',
+  threadTimeComplexity: 'threadTimeComplexity',
+  threadSpaceComplexity: 'threadSpaceComplexity',
+  threadOriginality: 'threadOriginality',
+  threadRanking: 'threadRanking'
+} as const
+
+export type MatchScalarFieldEnum = (typeof MatchScalarFieldEnum)[keyof typeof MatchScalarFieldEnum]
+
+
+export const MatchPlayerScalarFieldEnum = {
+  id: 'id',
+  matchId: 'matchId',
+  userId: 'userId',
+  rank: 'rank',
+  score: 'score',
+  joinedAt: 'joinedAt'
+} as const
+
+export type MatchPlayerScalarFieldEnum = (typeof MatchPlayerScalarFieldEnum)[keyof typeof MatchPlayerScalarFieldEnum]
+
+
+export const QuestionScalarFieldEnum = {
+  id: 'id',
+  title: 'title',
+  description: 'description',
+  difficulty: 'difficulty',
+  mode: 'mode',
+  brokenCode: 'brokenCode',
+  brokenLanguage: 'brokenLanguage',
+  expectedOutput: 'expectedOutput',
+  testCases: 'testCases',
+  createdAt: 'createdAt',
+  updatedAt: 'updatedAt'
+} as const
+
+export type QuestionScalarFieldEnum = (typeof QuestionScalarFieldEnum)[keyof typeof QuestionScalarFieldEnum]
+
+
+export const MatchQuestionScalarFieldEnum = {
+  id: 'id',
+  matchId: 'matchId',
+  questionId: 'questionId',
+  order: 'order'
+} as const
+
+export type MatchQuestionScalarFieldEnum = (typeof MatchQuestionScalarFieldEnum)[keyof typeof MatchQuestionScalarFieldEnum]
+
+
+export const SubmissionScalarFieldEnum = {
+  id: 'id',
+  matchId: 'matchId',
+  userId: 'userId',
+  questionId: 'questionId',
+  code: 'code',
+  language: 'language',
+  charCount: 'charCount',
+  stdout: 'stdout',
+  stderr: 'stderr',
+  exitCode: 'exitCode',
+  execTimeMs: 'execTimeMs',
+  testsPassed: 'testsPassed',
+  testsTotal: 'testsTotal',
+  timeComplexity: 'timeComplexity',
+  timeScore: 'timeScore',
+  spaceComplexity: 'spaceComplexity',
+  spaceScore: 'spaceScore',
+  originalityScore: 'originalityScore',
+  relevanceScore: 'relevanceScore',
+  submittedAt: 'submittedAt'
+} as const
+
+export type SubmissionScalarFieldEnum = (typeof SubmissionScalarFieldEnum)[keyof typeof SubmissionScalarFieldEnum]
+
+
+export const SortOrder = {
+  asc: 'asc',
+  desc: 'desc'
+} as const
+
+export type SortOrder = (typeof SortOrder)[keyof typeof SortOrder]
+
+
+export const NullableJsonNullValueInput = {
+  DbNull: DbNull,
+  JsonNull: JsonNull
+} as const
+
+export type NullableJsonNullValueInput = (typeof NullableJsonNullValueInput)[keyof typeof NullableJsonNullValueInput]
+
+
+export const QueryMode = {
+  default: 'default',
+  insensitive: 'insensitive'
+} as const
+
+export type QueryMode = (typeof QueryMode)[keyof typeof QueryMode]
+
+
+export const NullsOrder = {
+  first: 'first',
+  last: 'last'
+} as const
+
+export type NullsOrder = (typeof NullsOrder)[keyof typeof NullsOrder]
+
+
+export const JsonNullValueFilter = {
+  DbNull: DbNull,
+  JsonNull: JsonNull,
+  AnyNull: AnyNull
+} as const
+
+export type JsonNullValueFilter = (typeof JsonNullValueFilter)[keyof typeof JsonNullValueFilter]
+
+
+
+/**
+ * Field references
+ */
+
+
+/**
+ * Reference to a field of type 'String'
+ */
+export type StringFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'String'>
+    
+
+
+/**
+ * Reference to a field of type 'String[]'
+ */
+export type ListStringFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'String[]'>
+    
+
+
+/**
+ * Reference to a field of type 'SkillTier'
+ */
+export type EnumSkillTierFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'SkillTier'>
+    
+
+
+/**
+ * Reference to a field of type 'SkillTier[]'
+ */
+export type ListEnumSkillTierFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'SkillTier[]'>
+    
+
+
+/**
+ * Reference to a field of type 'Int'
+ */
+export type IntFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Int'>
+    
+
+
+/**
+ * Reference to a field of type 'Int[]'
+ */
+export type ListIntFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Int[]'>
+    
+
+
+/**
+ * Reference to a field of type 'DateTime'
+ */
+export type DateTimeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'DateTime'>
+    
+
+
+/**
+ * Reference to a field of type 'DateTime[]'
+ */
+export type ListDateTimeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'DateTime[]'>
+    
+
+
+/**
+ * Reference to a field of type 'Boolean'
+ */
+export type BooleanFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Boolean'>
+    
+
+
+/**
+ * Reference to a field of type 'MatchStatus'
+ */
+export type EnumMatchStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'MatchStatus'>
+    
+
+
+/**
+ * Reference to a field of type 'MatchStatus[]'
+ */
+export type ListEnumMatchStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'MatchStatus[]'>
+    
+
+
+/**
+ * Reference to a field of type 'GameMode'
+ */
+export type EnumGameModeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'GameMode'>
+    
+
+
+/**
+ * Reference to a field of type 'GameMode[]'
+ */
+export type ListEnumGameModeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'GameMode[]'>
+    
+
+
+/**
+ * Reference to a field of type 'Float'
+ */
+export type FloatFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Float'>
+    
+
+
+/**
+ * Reference to a field of type 'Float[]'
+ */
+export type ListFloatFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Float[]'>
+    
+
+
+/**
+ * Reference to a field of type 'Difficulty'
+ */
+export type EnumDifficultyFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Difficulty'>
+    
+
+
+/**
+ * Reference to a field of type 'Difficulty[]'
+ */
+export type ListEnumDifficultyFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Difficulty[]'>
+    
+
+
+/**
+ * Reference to a field of type 'Json'
+ */
+export type JsonFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Json'>
+    
+
+
+/**
+ * Reference to a field of type 'QueryMode'
+ */
+export type EnumQueryModeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'QueryMode'>
+    
+
+/**
+ * Batch Payload for updateMany & deleteMany & createMany
+ */
+export type BatchPayload = {
+  count: number
+}
+
+export const defineExtension = runtime.Extensions.defineExtension as unknown as runtime.Types.Extensions.ExtendsHook<"define", TypeMapCb, runtime.Types.Extensions.DefaultArgs>
+export type DefaultPrismaClient = PrismaClient
+export type ErrorFormat = 'pretty' | 'colorless' | 'minimal'
+export type PrismaClientOptions = ({
+  /**
+   * Instance of a Driver Adapter, e.g., like one provided by `@prisma/adapter-pg`.
+   */
+  adapter: runtime.SqlDriverAdapterFactory
+  accelerateUrl?: never
+} | {
+  /**
+   * Prisma Accelerate URL allowing the client to connect through Accelerate instead of a direct database.
+   */
+  accelerateUrl: string
+  adapter?: never
+}) & {
+  /**
+   * @default "colorless"
+   */
+  errorFormat?: ErrorFormat
+  /**
+   * @example
+   * ```
+   * // Shorthand for `emit: 'stdout'`
+   * log: ['query', 'info', 'warn', 'error']
+   * 
+   * // Emit as events only
+   * log: [
+   *   { emit: 'event', level: 'query' },
+   *   { emit: 'event', level: 'info' },
+   *   { emit: 'event', level: 'warn' }
+   *   { emit: 'event', level: 'error' }
+   * ]
+   * 
+   * / Emit as events and log to stdout
+   * og: [
+   *  { emit: 'stdout', level: 'query' },
+   *  { emit: 'stdout', level: 'info' },
+   *  { emit: 'stdout', level: 'warn' }
+   *  { emit: 'stdout', level: 'error' }
+   * 
+   * ```
+   * Read more in our [docs](https://pris.ly/d/logging).
+   */
+  log?: (LogLevel | LogDefinition)[]
+  /**
+   * The default values for transactionOptions
+   * maxWait ?= 2000
+   * timeout ?= 5000
+   */
+  transactionOptions?: {
+    maxWait?: number
+    timeout?: number
+    isolationLevel?: TransactionIsolationLevel
+  }
+  /**
+   * Global configuration for omitting model fields by default.
+   * 
+   * @example
+   * ```
+   * const prisma = new PrismaClient({
+   *   omit: {
+   *     user: {
+   *       password: true
+   *     }
+   *   }
+   * })
+   * ```
+   */
+  omit?: GlobalOmitConfig
+  /**
+   * SQL commenter plugins that add metadata to SQL queries as comments.
+   * Comments follow the sqlcommenter format: https://google.github.io/sqlcommenter/
+   * 
+   * @example
+   * ```
+   * const prisma = new PrismaClient({
+   *   adapter,
+   *   comments: [
+   *     traceContext(),
+   *     queryInsights(),
+   *   ],
+   * })
+   * ```
+   */
+  comments?: runtime.SqlCommenterPlugin[]
+}
+export type GlobalOmitConfig = {
+  user?: Prisma.UserOmit
+  queueEntry?: Prisma.QueueEntryOmit
+  match?: Prisma.MatchOmit
+  matchPlayer?: Prisma.MatchPlayerOmit
+  question?: Prisma.QuestionOmit
+  matchQuestion?: Prisma.MatchQuestionOmit
+  submission?: Prisma.SubmissionOmit
+}
+
+/* Types for Logging */
+export type LogLevel = 'info' | 'query' | 'warn' | 'error'
+export type LogDefinition = {
+  level: LogLevel
+  emit: 'stdout' | 'event'
+}
+
+export type CheckIsLogLevel<T> = T extends LogLevel ? T : never;
+
+export type GetLogType<T> = CheckIsLogLevel<
+  T extends LogDefinition ? T['level'] : T
+>;
+
+export type GetEvents<T extends any[]> = T extends Array<LogLevel | LogDefinition>
+  ? GetLogType<T[number]>
+  : never;
+
+export type QueryEvent = {
+  timestamp: Date
+  query: string
+  params: string
+  duration: number
+  target: string
+}
+
+export type LogEvent = {
+  timestamp: Date
+  message: string
+  target: string
+}
+/* End Types for Logging */
+
+
+export type PrismaAction =
+  | 'findUnique'
+  | 'findUniqueOrThrow'
+  | 'findMany'
+  | 'findFirst'
+  | 'findFirstOrThrow'
+  | 'create'
+  | 'createMany'
+  | 'createManyAndReturn'
+  | 'update'
+  | 'updateMany'
+  | 'updateManyAndReturn'
+  | 'upsert'
+  | 'delete'
+  | 'deleteMany'
+  | 'executeRaw'
+  | 'queryRaw'
+  | 'aggregate'
+  | 'count'
+  | 'runCommandRaw'
+  | 'findRaw'
+  | 'groupBy'
+
+/**
+ * `PrismaClient` proxy available in interactive transactions.
+ */
+export type TransactionClient = Omit<DefaultPrismaClient, runtime.ITXClientDenyList>
+
diff --git a/prisma/generated/prisma/internal/prismaNamespaceBrowser.ts b/prisma/generated/prisma/internal/prismaNamespaceBrowser.ts
new file mode 100644
index 0000000..f516195
--- /dev/null
+++ b/prisma/generated/prisma/internal/prismaNamespaceBrowser.ts
@@ -0,0 +1,227 @@
+
+/* !!! This is code generated by Prisma. Do not edit directly. !!! */
+/* eslint-disable */
+// biome-ignore-all lint: generated file
+// @ts-nocheck 
+/*
+ * WARNING: This is an internal file that is subject to change!
+ *
+ * 🛑 Under no circumstances should you import this file directly! 🛑
+ *
+ * All exports from this file are wrapped under a `Prisma` namespace object in the browser.ts file.
+ * While this enables partial backward compatibility, it is not part of the stable public API.
+ *
+ * If you are looking for your Models, Enums, and Input Types, please import them from the respective
+ * model files in the `model` directory!
+ */
+
+import * as runtime from "@prisma/client/runtime/index-browser"
+
+export type * from '../models'
+export type * from './prismaNamespace'
+
+export const Decimal = runtime.Decimal
+
+
+export const NullTypes = {
+  DbNull: runtime.NullTypes.DbNull as (new (secret: never) => typeof runtime.DbNull),
+  JsonNull: runtime.NullTypes.JsonNull as (new (secret: never) => typeof runtime.JsonNull),
+  AnyNull: runtime.NullTypes.AnyNull as (new (secret: never) => typeof runtime.AnyNull),
+}
+/**
+ * Helper for filtering JSON entries that have `null` on the database (empty on the db)
+ *
+ * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
+ */
+export const DbNull = runtime.DbNull
+
+/**
+ * Helper for filtering JSON entries that have JSON `null` values (not empty on the db)
+ *
+ * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
+ */
+export const JsonNull = runtime.JsonNull
+
+/**
+ * Helper for filtering JSON entries that are `Prisma.DbNull` or `Prisma.JsonNull`
+ *
+ * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
+ */
+export const AnyNull = runtime.AnyNull
+
+
+export const ModelName = {
+  User: 'User',
+  QueueEntry: 'QueueEntry',
+  Match: 'Match',
+  MatchPlayer: 'MatchPlayer',
+  Question: 'Question',
+  MatchQuestion: 'MatchQuestion',
+  Submission: 'Submission'
+} as const
+
+export type ModelName = (typeof ModelName)[keyof typeof ModelName]
+
+/*
+ * Enums
+ */
+
+export const TransactionIsolationLevel = runtime.makeStrictEnum({
+  ReadUncommitted: 'ReadUncommitted',
+  ReadCommitted: 'ReadCommitted',
+  RepeatableRead: 'RepeatableRead',
+  Serializable: 'Serializable'
+} as const)
+
+export type TransactionIsolationLevel = (typeof TransactionIsolationLevel)[keyof typeof TransactionIsolationLevel]
+
+
+export const UserScalarFieldEnum = {
+  id: 'id',
+  username: 'username',
+  email: 'email',
+  passwordHash: 'passwordHash',
+  displayName: 'displayName',
+  avatarUrl: 'avatarUrl',
+  skillTier: 'skillTier',
+  elo: 'elo',
+  totalWins: 'totalWins',
+  totalMatches: 'totalMatches',
+  createdAt: 'createdAt',
+  updatedAt: 'updatedAt'
+} as const
+
+export type UserScalarFieldEnum = (typeof UserScalarFieldEnum)[keyof typeof UserScalarFieldEnum]
+
+
+export const QueueEntryScalarFieldEnum = {
+  id: 'id',
+  userId: 'userId',
+  joinedAt: 'joinedAt',
+  active: 'active'
+} as const
+
+export type QueueEntryScalarFieldEnum = (typeof QueueEntryScalarFieldEnum)[keyof typeof QueueEntryScalarFieldEnum]
+
+
+export const MatchScalarFieldEnum = {
+  id: 'id',
+  status: 'status',
+  mode: 'mode',
+  startedAt: 'startedAt',
+  endedAt: 'endedAt',
+  createdAt: 'createdAt',
+  threadTimeComplexity: 'threadTimeComplexity',
+  threadSpaceComplexity: 'threadSpaceComplexity',
+  threadOriginality: 'threadOriginality',
+  threadRanking: 'threadRanking'
+} as const
+
+export type MatchScalarFieldEnum = (typeof MatchScalarFieldEnum)[keyof typeof MatchScalarFieldEnum]
+
+
+export const MatchPlayerScalarFieldEnum = {
+  id: 'id',
+  matchId: 'matchId',
+  userId: 'userId',
+  rank: 'rank',
+  score: 'score',
+  joinedAt: 'joinedAt'
+} as const
+
+export type MatchPlayerScalarFieldEnum = (typeof MatchPlayerScalarFieldEnum)[keyof typeof MatchPlayerScalarFieldEnum]
+
+
+export const QuestionScalarFieldEnum = {
+  id: 'id',
+  title: 'title',
+  description: 'description',
+  difficulty: 'difficulty',
+  mode: 'mode',
+  brokenCode: 'brokenCode',
+  brokenLanguage: 'brokenLanguage',
+  expectedOutput: 'expectedOutput',
+  testCases: 'testCases',
+  createdAt: 'createdAt',
+  updatedAt: 'updatedAt'
+} as const
+
+export type QuestionScalarFieldEnum = (typeof QuestionScalarFieldEnum)[keyof typeof QuestionScalarFieldEnum]
+
+
+export const MatchQuestionScalarFieldEnum = {
+  id: 'id',
+  matchId: 'matchId',
+  questionId: 'questionId',
+  order: 'order'
+} as const
+
+export type MatchQuestionScalarFieldEnum = (typeof MatchQuestionScalarFieldEnum)[keyof typeof MatchQuestionScalarFieldEnum]
+
+
+export const SubmissionScalarFieldEnum = {
+  id: 'id',
+  matchId: 'matchId',
+  userId: 'userId',
+  questionId: 'questionId',
+  code: 'code',
+  language: 'language',
+  charCount: 'charCount',
+  stdout: 'stdout',
+  stderr: 'stderr',
+  exitCode: 'exitCode',
+  execTimeMs: 'execTimeMs',
+  testsPassed: 'testsPassed',
+  testsTotal: 'testsTotal',
+  timeComplexity: 'timeComplexity',
+  timeScore: 'timeScore',
+  spaceComplexity: 'spaceComplexity',
+  spaceScore: 'spaceScore',
+  originalityScore: 'originalityScore',
+  relevanceScore: 'relevanceScore',
+  submittedAt: 'submittedAt'
+} as const
+
+export type SubmissionScalarFieldEnum = (typeof SubmissionScalarFieldEnum)[keyof typeof SubmissionScalarFieldEnum]
+
+
+export const SortOrder = {
+  asc: 'asc',
+  desc: 'desc'
+} as const
+
+export type SortOrder = (typeof SortOrder)[keyof typeof SortOrder]
+
+
+export const NullableJsonNullValueInput = {
+  DbNull: DbNull,
+  JsonNull: JsonNull
+} as const
+
+export type NullableJsonNullValueInput = (typeof NullableJsonNullValueInput)[keyof typeof NullableJsonNullValueInput]
+
+
+export const QueryMode = {
+  default: 'default',
+  insensitive: 'insensitive'
+} as const
+
+export type QueryMode = (typeof QueryMode)[keyof typeof QueryMode]
+
+
+export const NullsOrder = {
+  first: 'first',
+  last: 'last'
+} as const
+
+export type NullsOrder = (typeof NullsOrder)[keyof typeof NullsOrder]
+
+
+export const JsonNullValueFilter = {
+  DbNull: DbNull,
+  JsonNull: JsonNull,
+  AnyNull: AnyNull
+} as const
+
+export type JsonNullValueFilter = (typeof JsonNullValueFilter)[keyof typeof JsonNullValueFilter]
+
diff --git a/prisma/generated/prisma/models.ts b/prisma/generated/prisma/models.ts
new file mode 100644
index 0000000..77f61d8
--- /dev/null
+++ b/prisma/generated/prisma/models.ts
@@ -0,0 +1,18 @@
+
+/* !!! This is code generated by Prisma. Do not edit directly. !!! */
+/* eslint-disable */
+// biome-ignore-all lint: generated file
+// @ts-nocheck 
+/*
+ * This is a barrel export file for all models and their related types.
+ *
+ * 🟢 You can import this file directly.
+ */
+export type * from './models/User'
+export type * from './models/QueueEntry'
+export type * from './models/Match'
+export type * from './models/MatchPlayer'
+export type * from './models/Question'
+export type * from './models/MatchQuestion'
+export type * from './models/Submission'
+export type * from './commonInputTypes'
\ No newline at end of file
diff --git a/prisma/generated/prisma/models/Match.ts b/prisma/generated/prisma/models/Match.ts
new file mode 100644
index 0000000..b4de21a
--- /dev/null
+++ b/prisma/generated/prisma/models/Match.ts
@@ -0,0 +1,1770 @@
+
+/* !!! This is code generated by Prisma. Do not edit directly. !!! */
+/* eslint-disable */
+// biome-ignore-all lint: generated file
+// @ts-nocheck 
+/*
+ * This file exports the `Match` model and its related types.
+ *
+ * 🟢 You can import this file directly.
+ */
+import type * as runtime from "@prisma/client/runtime/client"
+import type * as $Enums from "../enums"
+import type * as Prisma from "../internal/prismaNamespace"
+
+/**
+ * Model Match
+ * 
+ */
+export type MatchModel = runtime.Types.Result.DefaultSelection<Prisma.$MatchPayload>
+
+export type AggregateMatch = {
+  _count: MatchCountAggregateOutputType | null
+  _min: MatchMinAggregateOutputType | null
+  _max: MatchMaxAggregateOutputType | null
+}
+
+export type MatchMinAggregateOutputType = {
+  id: string | null
+  status: $Enums.MatchStatus | null
+  mode: $Enums.GameMode | null
+  startedAt: Date | null
+  endedAt: Date | null
+  createdAt: Date | null
+  threadTimeComplexity: string | null
+  threadSpaceComplexity: string | null
+  threadOriginality: string | null
+  threadRanking: string | null
+}
+
+export type MatchMaxAggregateOutputType = {
+  id: string | null
+  status: $Enums.MatchStatus | null
+  mode: $Enums.GameMode | null
+  startedAt: Date | null
+  endedAt: Date | null
+  createdAt: Date | null
+  threadTimeComplexity: string | null
+  threadSpaceComplexity: string | null
+  threadOriginality: string | null
+  threadRanking: string | null
+}
+
+export type MatchCountAggregateOutputType = {
+  id: number
+  status: number
+  mode: number
+  startedAt: number
+  endedAt: number
+  createdAt: number
+  threadTimeComplexity: number
+  threadSpaceComplexity: number
+  threadOriginality: number
+  threadRanking: number
+  _all: number
+}
+
+
+export type MatchMinAggregateInputType = {
+  id?: true
+  status?: true
+  mode?: true
+  startedAt?: true
+  endedAt?: true
+  createdAt?: true
+  threadTimeComplexity?: true
+  threadSpaceComplexity?: true
+  threadOriginality?: true
+  threadRanking?: true
+}
+
+export type MatchMaxAggregateInputType = {
+  id?: true
+  status?: true
+  mode?: true
+  startedAt?: true
+  endedAt?: true
+  createdAt?: true
+  threadTimeComplexity?: true
+  threadSpaceComplexity?: true
+  threadOriginality?: true
+  threadRanking?: true
+}
+
+export type MatchCountAggregateInputType = {
+  id?: true
+  status?: true
+  mode?: true
+  startedAt?: true
+  endedAt?: true
+  createdAt?: true
+  threadTimeComplexity?: true
+  threadSpaceComplexity?: true
+  threadOriginality?: true
+  threadRanking?: true
+  _all?: true
+}
+
+export type MatchAggregateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Filter which Match to aggregate.
+   */
+  where?: Prisma.MatchWhereInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+   * 
+   * Determine the order of Matches to fetch.
+   */
+  orderBy?: Prisma.MatchOrderByWithRelationInput | Prisma.MatchOrderByWithRelationInput[]
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+   * 
+   * Sets the start position
+   */
+  cursor?: Prisma.MatchWhereUniqueInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Take `±n` Matches from the position of the cursor.
+   */
+  take?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Skip the first `n` Matches.
+   */
+  skip?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Count returned Matches
+  **/
+  _count?: true | MatchCountAggregateInputType
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Select which fields to find the minimum value
+  **/
+  _min?: MatchMinAggregateInputType
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Select which fields to find the maximum value
+  **/
+  _max?: MatchMaxAggregateInputType
+}
+
+export type GetMatchAggregateType<T extends MatchAggregateArgs> = {
+      [P in keyof T & keyof AggregateMatch]: P extends '_count' | 'count'
+    ? T[P] extends true
+      ? number
+      : Prisma.GetScalarType<T[P], AggregateMatch[P]>
+    : Prisma.GetScalarType<T[P], AggregateMatch[P]>
+}
+
+
+
+
+export type MatchGroupByArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  where?: Prisma.MatchWhereInput
+  orderBy?: Prisma.MatchOrderByWithAggregationInput | Prisma.MatchOrderByWithAggregationInput[]
+  by: Prisma.MatchScalarFieldEnum[] | Prisma.MatchScalarFieldEnum
+  having?: Prisma.MatchScalarWhereWithAggregatesInput
+  take?: number
+  skip?: number
+  _count?: MatchCountAggregateInputType | true
+  _min?: MatchMinAggregateInputType
+  _max?: MatchMaxAggregateInputType
+}
+
+export type MatchGroupByOutputType = {
+  id: string
+  status: $Enums.MatchStatus
+  mode: $Enums.GameMode
+  startedAt: Date | null
+  endedAt: Date | null
+  createdAt: Date
+  threadTimeComplexity: string | null
+  threadSpaceComplexity: string | null
+  threadOriginality: string | null
+  threadRanking: string | null
+  _count: MatchCountAggregateOutputType | null
+  _min: MatchMinAggregateOutputType | null
+  _max: MatchMaxAggregateOutputType | null
+}
+
+type GetMatchGroupByPayload<T extends MatchGroupByArgs> = Prisma.PrismaPromise<
+  Array<
+    Prisma.PickEnumerable<MatchGroupByOutputType, T['by']> &
+      {
+        [P in ((keyof T) & (keyof MatchGroupByOutputType))]: P extends '_count'
+          ? T[P] extends boolean
+            ? number
+            : Prisma.GetScalarType<T[P], MatchGroupByOutputType[P]>
+          : Prisma.GetScalarType<T[P], MatchGroupByOutputType[P]>
+      }
+    >
+  >
+
+
+
+export type MatchWhereInput = {
+  AND?: Prisma.MatchWhereInput | Prisma.MatchWhereInput[]
+  OR?: Prisma.MatchWhereInput[]
+  NOT?: Prisma.MatchWhereInput | Prisma.MatchWhereInput[]
+  id?: Prisma.StringFilter<"Match"> | string
+  status?: Prisma.EnumMatchStatusFilter<"Match"> | $Enums.MatchStatus
+  mode?: Prisma.EnumGameModeFilter<"Match"> | $Enums.GameMode
+  startedAt?: Prisma.DateTimeNullableFilter<"Match"> | Date | string | null
+  endedAt?: Prisma.DateTimeNullableFilter<"Match"> | Date | string | null
+  createdAt?: Prisma.DateTimeFilter<"Match"> | Date | string
+  threadTimeComplexity?: Prisma.StringNullableFilter<"Match"> | string | null
+  threadSpaceComplexity?: Prisma.StringNullableFilter<"Match"> | string | null
+  threadOriginality?: Prisma.StringNullableFilter<"Match"> | string | null
+  threadRanking?: Prisma.StringNullableFilter<"Match"> | string | null
+  players?: Prisma.MatchPlayerListRelationFilter
+  questions?: Prisma.MatchQuestionListRelationFilter
+  submissions?: Prisma.SubmissionListRelationFilter
+}
+
+export type MatchOrderByWithRelationInput = {
+  id?: Prisma.SortOrder
+  status?: Prisma.SortOrder
+  mode?: Prisma.SortOrder
+  startedAt?: Prisma.SortOrderInput | Prisma.SortOrder
+  endedAt?: Prisma.SortOrderInput | Prisma.SortOrder
+  createdAt?: Prisma.SortOrder
+  threadTimeComplexity?: Prisma.SortOrderInput | Prisma.SortOrder
+  threadSpaceComplexity?: Prisma.SortOrderInput | Prisma.SortOrder
+  threadOriginality?: Prisma.SortOrderInput | Prisma.SortOrder
+  threadRanking?: Prisma.SortOrderInput | Prisma.SortOrder
+  players?: Prisma.MatchPlayerOrderByRelationAggregateInput
+  questions?: Prisma.MatchQuestionOrderByRelationAggregateInput
+  submissions?: Prisma.SubmissionOrderByRelationAggregateInput
+}
+
+export type MatchWhereUniqueInput = Prisma.AtLeast<{
+  id?: string
+  AND?: Prisma.MatchWhereInput | Prisma.MatchWhereInput[]
+  OR?: Prisma.MatchWhereInput[]
+  NOT?: Prisma.MatchWhereInput | Prisma.MatchWhereInput[]
+  status?: Prisma.EnumMatchStatusFilter<"Match"> | $Enums.MatchStatus
+  mode?: Prisma.EnumGameModeFilter<"Match"> | $Enums.GameMode
+  startedAt?: Prisma.DateTimeNullableFilter<"Match"> | Date | string | null
+  endedAt?: Prisma.DateTimeNullableFilter<"Match"> | Date | string | null
+  createdAt?: Prisma.DateTimeFilter<"Match"> | Date | string
+  threadTimeComplexity?: Prisma.StringNullableFilter<"Match"> | string | null
+  threadSpaceComplexity?: Prisma.StringNullableFilter<"Match"> | string | null
+  threadOriginality?: Prisma.StringNullableFilter<"Match"> | string | null
+  threadRanking?: Prisma.StringNullableFilter<"Match"> | string | null
+  players?: Prisma.MatchPlayerListRelationFilter
+  questions?: Prisma.MatchQuestionListRelationFilter
+  submissions?: Prisma.SubmissionListRelationFilter
+}, "id">
+
+export type MatchOrderByWithAggregationInput = {
+  id?: Prisma.SortOrder
+  status?: Prisma.SortOrder
+  mode?: Prisma.SortOrder
+  startedAt?: Prisma.SortOrderInput | Prisma.SortOrder
+  endedAt?: Prisma.SortOrderInput | Prisma.SortOrder
+  createdAt?: Prisma.SortOrder
+  threadTimeComplexity?: Prisma.SortOrderInput | Prisma.SortOrder
+  threadSpaceComplexity?: Prisma.SortOrderInput | Prisma.SortOrder
+  threadOriginality?: Prisma.SortOrderInput | Prisma.SortOrder
+  threadRanking?: Prisma.SortOrderInput | Prisma.SortOrder
+  _count?: Prisma.MatchCountOrderByAggregateInput
+  _max?: Prisma.MatchMaxOrderByAggregateInput
+  _min?: Prisma.MatchMinOrderByAggregateInput
+}
+
+export type MatchScalarWhereWithAggregatesInput = {
+  AND?: Prisma.MatchScalarWhereWithAggregatesInput | Prisma.MatchScalarWhereWithAggregatesInput[]
+  OR?: Prisma.MatchScalarWhereWithAggregatesInput[]
+  NOT?: Prisma.MatchScalarWhereWithAggregatesInput | Prisma.MatchScalarWhereWithAggregatesInput[]
+  id?: Prisma.StringWithAggregatesFilter<"Match"> | string
+  status?: Prisma.EnumMatchStatusWithAggregatesFilter<"Match"> | $Enums.MatchStatus
+  mode?: Prisma.EnumGameModeWithAggregatesFilter<"Match"> | $Enums.GameMode
+  startedAt?: Prisma.DateTimeNullableWithAggregatesFilter<"Match"> | Date | string | null
+  endedAt?: Prisma.DateTimeNullableWithAggregatesFilter<"Match"> | Date | string | null
+  createdAt?: Prisma.DateTimeWithAggregatesFilter<"Match"> | Date | string
+  threadTimeComplexity?: Prisma.StringNullableWithAggregatesFilter<"Match"> | string | null
+  threadSpaceComplexity?: Prisma.StringNullableWithAggregatesFilter<"Match"> | string | null
+  threadOriginality?: Prisma.StringNullableWithAggregatesFilter<"Match"> | string | null
+  threadRanking?: Prisma.StringNullableWithAggregatesFilter<"Match"> | string | null
+}
+
+export type MatchCreateInput = {
+  id?: string
+  status?: $Enums.MatchStatus
+  mode?: $Enums.GameMode
+  startedAt?: Date | string | null
+  endedAt?: Date | string | null
+  createdAt?: Date | string
+  threadTimeComplexity?: string | null
+  threadSpaceComplexity?: string | null
+  threadOriginality?: string | null
+  threadRanking?: string | null
+  players?: Prisma.MatchPlayerCreateNestedManyWithoutMatchInput
+  questions?: Prisma.MatchQuestionCreateNestedManyWithoutMatchInput
+  submissions?: Prisma.SubmissionCreateNestedManyWithoutMatchInput
+}
+
+export type MatchUncheckedCreateInput = {
+  id?: string
+  status?: $Enums.MatchStatus
+  mode?: $Enums.GameMode
+  startedAt?: Date | string | null
+  endedAt?: Date | string | null
+  createdAt?: Date | string
+  threadTimeComplexity?: string | null
+  threadSpaceComplexity?: string | null
+  threadOriginality?: string | null
+  threadRanking?: string | null
+  players?: Prisma.MatchPlayerUncheckedCreateNestedManyWithoutMatchInput
+  questions?: Prisma.MatchQuestionUncheckedCreateNestedManyWithoutMatchInput
+  submissions?: Prisma.SubmissionUncheckedCreateNestedManyWithoutMatchInput
+}
+
+export type MatchUpdateInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  status?: Prisma.EnumMatchStatusFieldUpdateOperationsInput | $Enums.MatchStatus
+  mode?: Prisma.EnumGameModeFieldUpdateOperationsInput | $Enums.GameMode
+  startedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null
+  endedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  threadTimeComplexity?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  threadSpaceComplexity?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  threadOriginality?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  threadRanking?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  players?: Prisma.MatchPlayerUpdateManyWithoutMatchNestedInput
+  questions?: Prisma.MatchQuestionUpdateManyWithoutMatchNestedInput
+  submissions?: Prisma.SubmissionUpdateManyWithoutMatchNestedInput
+}
+
+export type MatchUncheckedUpdateInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  status?: Prisma.EnumMatchStatusFieldUpdateOperationsInput | $Enums.MatchStatus
+  mode?: Prisma.EnumGameModeFieldUpdateOperationsInput | $Enums.GameMode
+  startedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null
+  endedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  threadTimeComplexity?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  threadSpaceComplexity?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  threadOriginality?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  threadRanking?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  players?: Prisma.MatchPlayerUncheckedUpdateManyWithoutMatchNestedInput
+  questions?: Prisma.MatchQuestionUncheckedUpdateManyWithoutMatchNestedInput
+  submissions?: Prisma.SubmissionUncheckedUpdateManyWithoutMatchNestedInput
+}
+
+export type MatchCreateManyInput = {
+  id?: string
+  status?: $Enums.MatchStatus
+  mode?: $Enums.GameMode
+  startedAt?: Date | string | null
+  endedAt?: Date | string | null
+  createdAt?: Date | string
+  threadTimeComplexity?: string | null
+  threadSpaceComplexity?: string | null
+  threadOriginality?: string | null
+  threadRanking?: string | null
+}
+
+export type MatchUpdateManyMutationInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  status?: Prisma.EnumMatchStatusFieldUpdateOperationsInput | $Enums.MatchStatus
+  mode?: Prisma.EnumGameModeFieldUpdateOperationsInput | $Enums.GameMode
+  startedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null
+  endedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  threadTimeComplexity?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  threadSpaceComplexity?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  threadOriginality?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  threadRanking?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+}
+
+export type MatchUncheckedUpdateManyInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  status?: Prisma.EnumMatchStatusFieldUpdateOperationsInput | $Enums.MatchStatus
+  mode?: Prisma.EnumGameModeFieldUpdateOperationsInput | $Enums.GameMode
+  startedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null
+  endedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  threadTimeComplexity?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  threadSpaceComplexity?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  threadOriginality?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  threadRanking?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+}
+
+export type MatchCountOrderByAggregateInput = {
+  id?: Prisma.SortOrder
+  status?: Prisma.SortOrder
+  mode?: Prisma.SortOrder
+  startedAt?: Prisma.SortOrder
+  endedAt?: Prisma.SortOrder
+  createdAt?: Prisma.SortOrder
+  threadTimeComplexity?: Prisma.SortOrder
+  threadSpaceComplexity?: Prisma.SortOrder
+  threadOriginality?: Prisma.SortOrder
+  threadRanking?: Prisma.SortOrder
+}
+
+export type MatchMaxOrderByAggregateInput = {
+  id?: Prisma.SortOrder
+  status?: Prisma.SortOrder
+  mode?: Prisma.SortOrder
+  startedAt?: Prisma.SortOrder
+  endedAt?: Prisma.SortOrder
+  createdAt?: Prisma.SortOrder
+  threadTimeComplexity?: Prisma.SortOrder
+  threadSpaceComplexity?: Prisma.SortOrder
+  threadOriginality?: Prisma.SortOrder
+  threadRanking?: Prisma.SortOrder
+}
+
+export type MatchMinOrderByAggregateInput = {
+  id?: Prisma.SortOrder
+  status?: Prisma.SortOrder
+  mode?: Prisma.SortOrder
+  startedAt?: Prisma.SortOrder
+  endedAt?: Prisma.SortOrder
+  createdAt?: Prisma.SortOrder
+  threadTimeComplexity?: Prisma.SortOrder
+  threadSpaceComplexity?: Prisma.SortOrder
+  threadOriginality?: Prisma.SortOrder
+  threadRanking?: Prisma.SortOrder
+}
+
+export type MatchScalarRelationFilter = {
+  is?: Prisma.MatchWhereInput
+  isNot?: Prisma.MatchWhereInput
+}
+
+export type EnumMatchStatusFieldUpdateOperationsInput = {
+  set?: $Enums.MatchStatus
+}
+
+export type EnumGameModeFieldUpdateOperationsInput = {
+  set?: $Enums.GameMode
+}
+
+export type NullableDateTimeFieldUpdateOperationsInput = {
+  set?: Date | string | null
+}
+
+export type MatchCreateNestedOneWithoutPlayersInput = {
+  create?: Prisma.XOR<Prisma.MatchCreateWithoutPlayersInput, Prisma.MatchUncheckedCreateWithoutPlayersInput>
+  connectOrCreate?: Prisma.MatchCreateOrConnectWithoutPlayersInput
+  connect?: Prisma.MatchWhereUniqueInput
+}
+
+export type MatchUpdateOneRequiredWithoutPlayersNestedInput = {
+  create?: Prisma.XOR<Prisma.MatchCreateWithoutPlayersInput, Prisma.MatchUncheckedCreateWithoutPlayersInput>
+  connectOrCreate?: Prisma.MatchCreateOrConnectWithoutPlayersInput
+  upsert?: Prisma.MatchUpsertWithoutPlayersInput
+  connect?: Prisma.MatchWhereUniqueInput
+  update?: Prisma.XOR<Prisma.XOR<Prisma.MatchUpdateToOneWithWhereWithoutPlayersInput, Prisma.MatchUpdateWithoutPlayersInput>, Prisma.MatchUncheckedUpdateWithoutPlayersInput>
+}
+
+export type MatchCreateNestedOneWithoutQuestionsInput = {
+  create?: Prisma.XOR<Prisma.MatchCreateWithoutQuestionsInput, Prisma.MatchUncheckedCreateWithoutQuestionsInput>
+  connectOrCreate?: Prisma.MatchCreateOrConnectWithoutQuestionsInput
+  connect?: Prisma.MatchWhereUniqueInput
+}
+
+export type MatchUpdateOneRequiredWithoutQuestionsNestedInput = {
+  create?: Prisma.XOR<Prisma.MatchCreateWithoutQuestionsInput, Prisma.MatchUncheckedCreateWithoutQuestionsInput>
+  connectOrCreate?: Prisma.MatchCreateOrConnectWithoutQuestionsInput
+  upsert?: Prisma.MatchUpsertWithoutQuestionsInput
+  connect?: Prisma.MatchWhereUniqueInput
+  update?: Prisma.XOR<Prisma.XOR<Prisma.MatchUpdateToOneWithWhereWithoutQuestionsInput, Prisma.MatchUpdateWithoutQuestionsInput>, Prisma.MatchUncheckedUpdateWithoutQuestionsInput>
+}
+
+export type MatchCreateNestedOneWithoutSubmissionsInput = {
+  create?: Prisma.XOR<Prisma.MatchCreateWithoutSubmissionsInput, Prisma.MatchUncheckedCreateWithoutSubmissionsInput>
+  connectOrCreate?: Prisma.MatchCreateOrConnectWithoutSubmissionsInput
+  connect?: Prisma.MatchWhereUniqueInput
+}
+
+export type MatchUpdateOneRequiredWithoutSubmissionsNestedInput = {
+  create?: Prisma.XOR<Prisma.MatchCreateWithoutSubmissionsInput, Prisma.MatchUncheckedCreateWithoutSubmissionsInput>
+  connectOrCreate?: Prisma.MatchCreateOrConnectWithoutSubmissionsInput
+  upsert?: Prisma.MatchUpsertWithoutSubmissionsInput
+  connect?: Prisma.MatchWhereUniqueInput
+  update?: Prisma.XOR<Prisma.XOR<Prisma.MatchUpdateToOneWithWhereWithoutSubmissionsInput, Prisma.MatchUpdateWithoutSubmissionsInput>, Prisma.MatchUncheckedUpdateWithoutSubmissionsInput>
+}
+
+export type MatchCreateWithoutPlayersInput = {
+  id?: string
+  status?: $Enums.MatchStatus
+  mode?: $Enums.GameMode
+  startedAt?: Date | string | null
+  endedAt?: Date | string | null
+  createdAt?: Date | string
+  threadTimeComplexity?: string | null
+  threadSpaceComplexity?: string | null
+  threadOriginality?: string | null
+  threadRanking?: string | null
+  questions?: Prisma.MatchQuestionCreateNestedManyWithoutMatchInput
+  submissions?: Prisma.SubmissionCreateNestedManyWithoutMatchInput
+}
+
+export type MatchUncheckedCreateWithoutPlayersInput = {
+  id?: string
+  status?: $Enums.MatchStatus
+  mode?: $Enums.GameMode
+  startedAt?: Date | string | null
+  endedAt?: Date | string | null
+  createdAt?: Date | string
+  threadTimeComplexity?: string | null
+  threadSpaceComplexity?: string | null
+  threadOriginality?: string | null
+  threadRanking?: string | null
+  questions?: Prisma.MatchQuestionUncheckedCreateNestedManyWithoutMatchInput
+  submissions?: Prisma.SubmissionUncheckedCreateNestedManyWithoutMatchInput
+}
+
+export type MatchCreateOrConnectWithoutPlayersInput = {
+  where: Prisma.MatchWhereUniqueInput
+  create: Prisma.XOR<Prisma.MatchCreateWithoutPlayersInput, Prisma.MatchUncheckedCreateWithoutPlayersInput>
+}
+
+export type MatchUpsertWithoutPlayersInput = {
+  update: Prisma.XOR<Prisma.MatchUpdateWithoutPlayersInput, Prisma.MatchUncheckedUpdateWithoutPlayersInput>
+  create: Prisma.XOR<Prisma.MatchCreateWithoutPlayersInput, Prisma.MatchUncheckedCreateWithoutPlayersInput>
+  where?: Prisma.MatchWhereInput
+}
+
+export type MatchUpdateToOneWithWhereWithoutPlayersInput = {
+  where?: Prisma.MatchWhereInput
+  data: Prisma.XOR<Prisma.MatchUpdateWithoutPlayersInput, Prisma.MatchUncheckedUpdateWithoutPlayersInput>
+}
+
+export type MatchUpdateWithoutPlayersInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  status?: Prisma.EnumMatchStatusFieldUpdateOperationsInput | $Enums.MatchStatus
+  mode?: Prisma.EnumGameModeFieldUpdateOperationsInput | $Enums.GameMode
+  startedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null
+  endedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  threadTimeComplexity?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  threadSpaceComplexity?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  threadOriginality?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  threadRanking?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  questions?: Prisma.MatchQuestionUpdateManyWithoutMatchNestedInput
+  submissions?: Prisma.SubmissionUpdateManyWithoutMatchNestedInput
+}
+
+export type MatchUncheckedUpdateWithoutPlayersInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  status?: Prisma.EnumMatchStatusFieldUpdateOperationsInput | $Enums.MatchStatus
+  mode?: Prisma.EnumGameModeFieldUpdateOperationsInput | $Enums.GameMode
+  startedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null
+  endedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  threadTimeComplexity?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  threadSpaceComplexity?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  threadOriginality?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  threadRanking?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  questions?: Prisma.MatchQuestionUncheckedUpdateManyWithoutMatchNestedInput
+  submissions?: Prisma.SubmissionUncheckedUpdateManyWithoutMatchNestedInput
+}
+
+export type MatchCreateWithoutQuestionsInput = {
+  id?: string
+  status?: $Enums.MatchStatus
+  mode?: $Enums.GameMode
+  startedAt?: Date | string | null
+  endedAt?: Date | string | null
+  createdAt?: Date | string
+  threadTimeComplexity?: string | null
+  threadSpaceComplexity?: string | null
+  threadOriginality?: string | null
+  threadRanking?: string | null
+  players?: Prisma.MatchPlayerCreateNestedManyWithoutMatchInput
+  submissions?: Prisma.SubmissionCreateNestedManyWithoutMatchInput
+}
+
+export type MatchUncheckedCreateWithoutQuestionsInput = {
+  id?: string
+  status?: $Enums.MatchStatus
+  mode?: $Enums.GameMode
+  startedAt?: Date | string | null
+  endedAt?: Date | string | null
+  createdAt?: Date | string
+  threadTimeComplexity?: string | null
+  threadSpaceComplexity?: string | null
+  threadOriginality?: string | null
+  threadRanking?: string | null
+  players?: Prisma.MatchPlayerUncheckedCreateNestedManyWithoutMatchInput
+  submissions?: Prisma.SubmissionUncheckedCreateNestedManyWithoutMatchInput
+}
+
+export type MatchCreateOrConnectWithoutQuestionsInput = {
+  where: Prisma.MatchWhereUniqueInput
+  create: Prisma.XOR<Prisma.MatchCreateWithoutQuestionsInput, Prisma.MatchUncheckedCreateWithoutQuestionsInput>
+}
+
+export type MatchUpsertWithoutQuestionsInput = {
+  update: Prisma.XOR<Prisma.MatchUpdateWithoutQuestionsInput, Prisma.MatchUncheckedUpdateWithoutQuestionsInput>
+  create: Prisma.XOR<Prisma.MatchCreateWithoutQuestionsInput, Prisma.MatchUncheckedCreateWithoutQuestionsInput>
+  where?: Prisma.MatchWhereInput
+}
+
+export type MatchUpdateToOneWithWhereWithoutQuestionsInput = {
+  where?: Prisma.MatchWhereInput
+  data: Prisma.XOR<Prisma.MatchUpdateWithoutQuestionsInput, Prisma.MatchUncheckedUpdateWithoutQuestionsInput>
+}
+
+export type MatchUpdateWithoutQuestionsInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  status?: Prisma.EnumMatchStatusFieldUpdateOperationsInput | $Enums.MatchStatus
+  mode?: Prisma.EnumGameModeFieldUpdateOperationsInput | $Enums.GameMode
+  startedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null
+  endedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  threadTimeComplexity?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  threadSpaceComplexity?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  threadOriginality?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  threadRanking?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  players?: Prisma.MatchPlayerUpdateManyWithoutMatchNestedInput
+  submissions?: Prisma.SubmissionUpdateManyWithoutMatchNestedInput
+}
+
+export type MatchUncheckedUpdateWithoutQuestionsInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  status?: Prisma.EnumMatchStatusFieldUpdateOperationsInput | $Enums.MatchStatus
+  mode?: Prisma.EnumGameModeFieldUpdateOperationsInput | $Enums.GameMode
+  startedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null
+  endedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  threadTimeComplexity?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  threadSpaceComplexity?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  threadOriginality?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  threadRanking?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  players?: Prisma.MatchPlayerUncheckedUpdateManyWithoutMatchNestedInput
+  submissions?: Prisma.SubmissionUncheckedUpdateManyWithoutMatchNestedInput
+}
+
+export type MatchCreateWithoutSubmissionsInput = {
+  id?: string
+  status?: $Enums.MatchStatus
+  mode?: $Enums.GameMode
+  startedAt?: Date | string | null
+  endedAt?: Date | string | null
+  createdAt?: Date | string
+  threadTimeComplexity?: string | null
+  threadSpaceComplexity?: string | null
+  threadOriginality?: string | null
+  threadRanking?: string | null
+  players?: Prisma.MatchPlayerCreateNestedManyWithoutMatchInput
+  questions?: Prisma.MatchQuestionCreateNestedManyWithoutMatchInput
+}
+
+export type MatchUncheckedCreateWithoutSubmissionsInput = {
+  id?: string
+  status?: $Enums.MatchStatus
+  mode?: $Enums.GameMode
+  startedAt?: Date | string | null
+  endedAt?: Date | string | null
+  createdAt?: Date | string
+  threadTimeComplexity?: string | null
+  threadSpaceComplexity?: string | null
+  threadOriginality?: string | null
+  threadRanking?: string | null
+  players?: Prisma.MatchPlayerUncheckedCreateNestedManyWithoutMatchInput
+  questions?: Prisma.MatchQuestionUncheckedCreateNestedManyWithoutMatchInput
+}
+
+export type MatchCreateOrConnectWithoutSubmissionsInput = {
+  where: Prisma.MatchWhereUniqueInput
+  create: Prisma.XOR<Prisma.MatchCreateWithoutSubmissionsInput, Prisma.MatchUncheckedCreateWithoutSubmissionsInput>
+}
+
+export type MatchUpsertWithoutSubmissionsInput = {
+  update: Prisma.XOR<Prisma.MatchUpdateWithoutSubmissionsInput, Prisma.MatchUncheckedUpdateWithoutSubmissionsInput>
+  create: Prisma.XOR<Prisma.MatchCreateWithoutSubmissionsInput, Prisma.MatchUncheckedCreateWithoutSubmissionsInput>
+  where?: Prisma.MatchWhereInput
+}
+
+export type MatchUpdateToOneWithWhereWithoutSubmissionsInput = {
+  where?: Prisma.MatchWhereInput
+  data: Prisma.XOR<Prisma.MatchUpdateWithoutSubmissionsInput, Prisma.MatchUncheckedUpdateWithoutSubmissionsInput>
+}
+
+export type MatchUpdateWithoutSubmissionsInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  status?: Prisma.EnumMatchStatusFieldUpdateOperationsInput | $Enums.MatchStatus
+  mode?: Prisma.EnumGameModeFieldUpdateOperationsInput | $Enums.GameMode
+  startedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null
+  endedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  threadTimeComplexity?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  threadSpaceComplexity?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  threadOriginality?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  threadRanking?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  players?: Prisma.MatchPlayerUpdateManyWithoutMatchNestedInput
+  questions?: Prisma.MatchQuestionUpdateManyWithoutMatchNestedInput
+}
+
+export type MatchUncheckedUpdateWithoutSubmissionsInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  status?: Prisma.EnumMatchStatusFieldUpdateOperationsInput | $Enums.MatchStatus
+  mode?: Prisma.EnumGameModeFieldUpdateOperationsInput | $Enums.GameMode
+  startedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null
+  endedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  threadTimeComplexity?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  threadSpaceComplexity?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  threadOriginality?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  threadRanking?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  players?: Prisma.MatchPlayerUncheckedUpdateManyWithoutMatchNestedInput
+  questions?: Prisma.MatchQuestionUncheckedUpdateManyWithoutMatchNestedInput
+}
+
+
+/**
+ * Count Type MatchCountOutputType
+ */
+
+export type MatchCountOutputType = {
+  players: number
+  questions: number
+  submissions: number
+}
+
+export type MatchCountOutputTypeSelect<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  players?: boolean | MatchCountOutputTypeCountPlayersArgs
+  questions?: boolean | MatchCountOutputTypeCountQuestionsArgs
+  submissions?: boolean | MatchCountOutputTypeCountSubmissionsArgs
+}
+
+/**
+ * MatchCountOutputType without action
+ */
+export type MatchCountOutputTypeDefaultArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the MatchCountOutputType
+   */
+  select?: Prisma.MatchCountOutputTypeSelect<ExtArgs> | null
+}
+
+/**
+ * MatchCountOutputType without action
+ */
+export type MatchCountOutputTypeCountPlayersArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  where?: Prisma.MatchPlayerWhereInput
+}
+
+/**
+ * MatchCountOutputType without action
+ */
+export type MatchCountOutputTypeCountQuestionsArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  where?: Prisma.MatchQuestionWhereInput
+}
+
+/**
+ * MatchCountOutputType without action
+ */
+export type MatchCountOutputTypeCountSubmissionsArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  where?: Prisma.SubmissionWhereInput
+}
+
+
+export type MatchSelect<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
+  id?: boolean
+  status?: boolean
+  mode?: boolean
+  startedAt?: boolean
+  endedAt?: boolean
+  createdAt?: boolean
+  threadTimeComplexity?: boolean
+  threadSpaceComplexity?: boolean
+  threadOriginality?: boolean
+  threadRanking?: boolean
+  players?: boolean | Prisma.Match$playersArgs<ExtArgs>
+  questions?: boolean | Prisma.Match$questionsArgs<ExtArgs>
+  submissions?: boolean | Prisma.Match$submissionsArgs<ExtArgs>
+  _count?: boolean | Prisma.MatchCountOutputTypeDefaultArgs<ExtArgs>
+}, ExtArgs["result"]["match"]>
+
+export type MatchSelectCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
+  id?: boolean
+  status?: boolean
+  mode?: boolean
+  startedAt?: boolean
+  endedAt?: boolean
+  createdAt?: boolean
+  threadTimeComplexity?: boolean
+  threadSpaceComplexity?: boolean
+  threadOriginality?: boolean
+  threadRanking?: boolean
+}, ExtArgs["result"]["match"]>
+
+export type MatchSelectUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
+  id?: boolean
+  status?: boolean
+  mode?: boolean
+  startedAt?: boolean
+  endedAt?: boolean
+  createdAt?: boolean
+  threadTimeComplexity?: boolean
+  threadSpaceComplexity?: boolean
+  threadOriginality?: boolean
+  threadRanking?: boolean
+}, ExtArgs["result"]["match"]>
+
+export type MatchSelectScalar = {
+  id?: boolean
+  status?: boolean
+  mode?: boolean
+  startedAt?: boolean
+  endedAt?: boolean
+  createdAt?: boolean
+  threadTimeComplexity?: boolean
+  threadSpaceComplexity?: boolean
+  threadOriginality?: boolean
+  threadRanking?: boolean
+}
+
+export type MatchOmit<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetOmit<"id" | "status" | "mode" | "startedAt" | "endedAt" | "createdAt" | "threadTimeComplexity" | "threadSpaceComplexity" | "threadOriginality" | "threadRanking", ExtArgs["result"]["match"]>
+export type MatchInclude<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  players?: boolean | Prisma.Match$playersArgs<ExtArgs>
+  questions?: boolean | Prisma.Match$questionsArgs<ExtArgs>
+  submissions?: boolean | Prisma.Match$submissionsArgs<ExtArgs>
+  _count?: boolean | Prisma.MatchCountOutputTypeDefaultArgs<ExtArgs>
+}
+export type MatchIncludeCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {}
+export type MatchIncludeUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {}
+
+export type $MatchPayload<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  name: "Match"
+  objects: {
+    players: Prisma.$MatchPlayerPayload<ExtArgs>[]
+    questions: Prisma.$MatchQuestionPayload<ExtArgs>[]
+    submissions: Prisma.$SubmissionPayload<ExtArgs>[]
+  }
+  scalars: runtime.Types.Extensions.GetPayloadResult<{
+    id: string
+    status: $Enums.MatchStatus
+    mode: $Enums.GameMode
+    startedAt: Date | null
+    endedAt: Date | null
+    createdAt: Date
+    threadTimeComplexity: string | null
+    threadSpaceComplexity: string | null
+    threadOriginality: string | null
+    threadRanking: string | null
+  }, ExtArgs["result"]["match"]>
+  composites: {}
+}
+
+export type MatchGetPayload<S extends boolean | null | undefined | MatchDefaultArgs> = runtime.Types.Result.GetResult<Prisma.$MatchPayload, S>
+
+export type MatchCountArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> =
+  Omit<MatchFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
+    select?: MatchCountAggregateInputType | true
+  }
+
+export interface MatchDelegate<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> {
+  [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Match'], meta: { name: 'Match' } }
+  /**
+   * Find zero or one Match that matches the filter.
+   * @param {MatchFindUniqueArgs} args - Arguments to find a Match
+   * @example
+   * // Get one Match
+   * const match = await prisma.match.findUnique({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   */
+  findUnique<T extends MatchFindUniqueArgs>(args: Prisma.SelectSubset<T, MatchFindUniqueArgs<ExtArgs>>): Prisma.Prisma__MatchClient<runtime.Types.Result.GetResult<Prisma.$MatchPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Find one Match that matches the filter or throw an error with `error.code='P2025'`
+   * if no matches were found.
+   * @param {MatchFindUniqueOrThrowArgs} args - Arguments to find a Match
+   * @example
+   * // Get one Match
+   * const match = await prisma.match.findUniqueOrThrow({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   */
+  findUniqueOrThrow<T extends MatchFindUniqueOrThrowArgs>(args: Prisma.SelectSubset<T, MatchFindUniqueOrThrowArgs<ExtArgs>>): Prisma.Prisma__MatchClient<runtime.Types.Result.GetResult<Prisma.$MatchPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Find the first Match that matches the filter.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {MatchFindFirstArgs} args - Arguments to find a Match
+   * @example
+   * // Get one Match
+   * const match = await prisma.match.findFirst({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   */
+  findFirst<T extends MatchFindFirstArgs>(args?: Prisma.SelectSubset<T, MatchFindFirstArgs<ExtArgs>>): Prisma.Prisma__MatchClient<runtime.Types.Result.GetResult<Prisma.$MatchPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Find the first Match that matches the filter or
+   * throw `PrismaKnownClientError` with `P2025` code if no matches were found.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {MatchFindFirstOrThrowArgs} args - Arguments to find a Match
+   * @example
+   * // Get one Match
+   * const match = await prisma.match.findFirstOrThrow({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   */
+  findFirstOrThrow<T extends MatchFindFirstOrThrowArgs>(args?: Prisma.SelectSubset<T, MatchFindFirstOrThrowArgs<ExtArgs>>): Prisma.Prisma__MatchClient<runtime.Types.Result.GetResult<Prisma.$MatchPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Find zero or more Matches that matches the filter.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {MatchFindManyArgs} args - Arguments to filter and select certain fields only.
+   * @example
+   * // Get all Matches
+   * const matches = await prisma.match.findMany()
+   * 
+   * // Get first 10 Matches
+   * const matches = await prisma.match.findMany({ take: 10 })
+   * 
+   * // Only select the `id`
+   * const matchWithIdOnly = await prisma.match.findMany({ select: { id: true } })
+   * 
+   */
+  findMany<T extends MatchFindManyArgs>(args?: Prisma.SelectSubset<T, MatchFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$MatchPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>
+
+  /**
+   * Create a Match.
+   * @param {MatchCreateArgs} args - Arguments to create a Match.
+   * @example
+   * // Create one Match
+   * const Match = await prisma.match.create({
+   *   data: {
+   *     // ... data to create a Match
+   *   }
+   * })
+   * 
+   */
+  create<T extends MatchCreateArgs>(args: Prisma.SelectSubset<T, MatchCreateArgs<ExtArgs>>): Prisma.Prisma__MatchClient<runtime.Types.Result.GetResult<Prisma.$MatchPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Create many Matches.
+   * @param {MatchCreateManyArgs} args - Arguments to create many Matches.
+   * @example
+   * // Create many Matches
+   * const match = await prisma.match.createMany({
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   *     
+   */
+  createMany<T extends MatchCreateManyArgs>(args?: Prisma.SelectSubset<T, MatchCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>
+
+  /**
+   * Create many Matches and returns the data saved in the database.
+   * @param {MatchCreateManyAndReturnArgs} args - Arguments to create many Matches.
+   * @example
+   * // Create many Matches
+   * const match = await prisma.match.createManyAndReturn({
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   * 
+   * // Create many Matches and only return the `id`
+   * const matchWithIdOnly = await prisma.match.createManyAndReturn({
+   *   select: { id: true },
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * 
+   */
+  createManyAndReturn<T extends MatchCreateManyAndReturnArgs>(args?: Prisma.SelectSubset<T, MatchCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$MatchPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>
+
+  /**
+   * Delete a Match.
+   * @param {MatchDeleteArgs} args - Arguments to delete one Match.
+   * @example
+   * // Delete one Match
+   * const Match = await prisma.match.delete({
+   *   where: {
+   *     // ... filter to delete one Match
+   *   }
+   * })
+   * 
+   */
+  delete<T extends MatchDeleteArgs>(args: Prisma.SelectSubset<T, MatchDeleteArgs<ExtArgs>>): Prisma.Prisma__MatchClient<runtime.Types.Result.GetResult<Prisma.$MatchPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Update one Match.
+   * @param {MatchUpdateArgs} args - Arguments to update one Match.
+   * @example
+   * // Update one Match
+   * const match = await prisma.match.update({
+   *   where: {
+   *     // ... provide filter here
+   *   },
+   *   data: {
+   *     // ... provide data here
+   *   }
+   * })
+   * 
+   */
+  update<T extends MatchUpdateArgs>(args: Prisma.SelectSubset<T, MatchUpdateArgs<ExtArgs>>): Prisma.Prisma__MatchClient<runtime.Types.Result.GetResult<Prisma.$MatchPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Delete zero or more Matches.
+   * @param {MatchDeleteManyArgs} args - Arguments to filter Matches to delete.
+   * @example
+   * // Delete a few Matches
+   * const { count } = await prisma.match.deleteMany({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   * 
+   */
+  deleteMany<T extends MatchDeleteManyArgs>(args?: Prisma.SelectSubset<T, MatchDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>
+
+  /**
+   * Update zero or more Matches.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {MatchUpdateManyArgs} args - Arguments to update one or more rows.
+   * @example
+   * // Update many Matches
+   * const match = await prisma.match.updateMany({
+   *   where: {
+   *     // ... provide filter here
+   *   },
+   *   data: {
+   *     // ... provide data here
+   *   }
+   * })
+   * 
+   */
+  updateMany<T extends MatchUpdateManyArgs>(args: Prisma.SelectSubset<T, MatchUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>
+
+  /**
+   * Update zero or more Matches and returns the data updated in the database.
+   * @param {MatchUpdateManyAndReturnArgs} args - Arguments to update many Matches.
+   * @example
+   * // Update many Matches
+   * const match = await prisma.match.updateManyAndReturn({
+   *   where: {
+   *     // ... provide filter here
+   *   },
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   * 
+   * // Update zero or more Matches and only return the `id`
+   * const matchWithIdOnly = await prisma.match.updateManyAndReturn({
+   *   select: { id: true },
+   *   where: {
+   *     // ... provide filter here
+   *   },
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * 
+   */
+  updateManyAndReturn<T extends MatchUpdateManyAndReturnArgs>(args: Prisma.SelectSubset<T, MatchUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$MatchPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>
+
+  /**
+   * Create or update one Match.
+   * @param {MatchUpsertArgs} args - Arguments to update or create a Match.
+   * @example
+   * // Update or create a Match
+   * const match = await prisma.match.upsert({
+   *   create: {
+   *     // ... data to create a Match
+   *   },
+   *   update: {
+   *     // ... in case it already exists, update
+   *   },
+   *   where: {
+   *     // ... the filter for the Match we want to update
+   *   }
+   * })
+   */
+  upsert<T extends MatchUpsertArgs>(args: Prisma.SelectSubset<T, MatchUpsertArgs<ExtArgs>>): Prisma.Prisma__MatchClient<runtime.Types.Result.GetResult<Prisma.$MatchPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+
+  /**
+   * Count the number of Matches.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {MatchCountArgs} args - Arguments to filter Matches to count.
+   * @example
+   * // Count the number of Matches
+   * const count = await prisma.match.count({
+   *   where: {
+   *     // ... the filter for the Matches we want to count
+   *   }
+   * })
+  **/
+  count<T extends MatchCountArgs>(
+    args?: Prisma.Subset<T, MatchCountArgs>,
+  ): Prisma.PrismaPromise<
+    T extends runtime.Types.Utils.Record<'select', any>
+      ? T['select'] extends true
+        ? number
+        : Prisma.GetScalarType<T['select'], MatchCountAggregateOutputType>
+      : number
+  >
+
+  /**
+   * Allows you to perform aggregations operations on a Match.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {MatchAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
+   * @example
+   * // Ordered by age ascending
+   * // Where email contains prisma.io
+   * // Limited to the 10 users
+   * const aggregations = await prisma.user.aggregate({
+   *   _avg: {
+   *     age: true,
+   *   },
+   *   where: {
+   *     email: {
+   *       contains: "prisma.io",
+   *     },
+   *   },
+   *   orderBy: {
+   *     age: "asc",
+   *   },
+   *   take: 10,
+   * })
+  **/
+  aggregate<T extends MatchAggregateArgs>(args: Prisma.Subset<T, MatchAggregateArgs>): Prisma.PrismaPromise<GetMatchAggregateType<T>>
+
+  /**
+   * Group by Match.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {MatchGroupByArgs} args - Group by arguments.
+   * @example
+   * // Group by city, order by createdAt, get count
+   * const result = await prisma.user.groupBy({
+   *   by: ['city', 'createdAt'],
+   *   orderBy: {
+   *     createdAt: true
+   *   },
+   *   _count: {
+   *     _all: true
+   *   },
+   * })
+   * 
+  **/
+  groupBy<
+    T extends MatchGroupByArgs,
+    HasSelectOrTake extends Prisma.Or<
+      Prisma.Extends<'skip', Prisma.Keys<T>>,
+      Prisma.Extends<'take', Prisma.Keys<T>>
+    >,
+    OrderByArg extends Prisma.True extends HasSelectOrTake
+      ? { orderBy: MatchGroupByArgs['orderBy'] }
+      : { orderBy?: MatchGroupByArgs['orderBy'] },
+    OrderFields extends Prisma.ExcludeUnderscoreKeys<Prisma.Keys<Prisma.MaybeTupleToUnion<T['orderBy']>>>,
+    ByFields extends Prisma.MaybeTupleToUnion<T['by']>,
+    ByValid extends Prisma.Has<ByFields, OrderFields>,
+    HavingFields extends Prisma.GetHavingFields<T['having']>,
+    HavingValid extends Prisma.Has<ByFields, HavingFields>,
+    ByEmpty extends T['by'] extends never[] ? Prisma.True : Prisma.False,
+    InputErrors extends ByEmpty extends Prisma.True
+    ? `Error: "by" must not be empty.`
+    : HavingValid extends Prisma.False
+    ? {
+        [P in HavingFields]: P extends ByFields
+          ? never
+          : P extends string
+          ? `Error: Field "${P}" used in "having" needs to be provided in "by".`
+          : [
+              Error,
+              'Field ',
+              P,
+              ` in "having" needs to be provided in "by"`,
+            ]
+      }[HavingFields]
+    : 'take' extends Prisma.Keys<T>
+    ? 'orderBy' extends Prisma.Keys<T>
+      ? ByValid extends Prisma.True
+        ? {}
+        : {
+            [P in OrderFields]: P extends ByFields
+              ? never
+              : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
+          }[OrderFields]
+      : 'Error: If you provide "take", you also need to provide "orderBy"'
+    : 'skip' extends Prisma.Keys<T>
+    ? 'orderBy' extends Prisma.Keys<T>
+      ? ByValid extends Prisma.True
+        ? {}
+        : {
+            [P in OrderFields]: P extends ByFields
+              ? never
+              : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
+          }[OrderFields]
+      : 'Error: If you provide "skip", you also need to provide "orderBy"'
+    : ByValid extends Prisma.True
+    ? {}
+    : {
+        [P in OrderFields]: P extends ByFields
+          ? never
+          : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
+      }[OrderFields]
+  >(args: Prisma.SubsetIntersection<T, MatchGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetMatchGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
+/**
+ * Fields of the Match model
+ */
+readonly fields: MatchFieldRefs;
+}
+
+/**
+ * The delegate class that acts as a "Promise-like" for Match.
+ * Why is this prefixed with `Prisma__`?
+ * Because we want to prevent naming conflicts as mentioned in
+ * https://github.com/prisma/prisma-client-js/issues/707
+ */
+export interface Prisma__MatchClient<T, Null = never, ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
+  readonly [Symbol.toStringTag]: "PrismaPromise"
+  players<T extends Prisma.Match$playersArgs<ExtArgs> = {}>(args?: Prisma.Subset<T, Prisma.Match$playersArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$MatchPlayerPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
+  questions<T extends Prisma.Match$questionsArgs<ExtArgs> = {}>(args?: Prisma.Subset<T, Prisma.Match$questionsArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$MatchQuestionPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
+  submissions<T extends Prisma.Match$submissionsArgs<ExtArgs> = {}>(args?: Prisma.Subset<T, Prisma.Match$submissionsArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$SubmissionPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
+  /**
+   * Attaches callbacks for the resolution and/or rejection of the Promise.
+   * @param onfulfilled The callback to execute when the Promise is resolved.
+   * @param onrejected The callback to execute when the Promise is rejected.
+   * @returns A Promise for the completion of which ever callback is executed.
+   */
+  then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): runtime.Types.Utils.JsPromise<TResult1 | TResult2>
+  /**
+   * Attaches a callback for only the rejection of the Promise.
+   * @param onrejected The callback to execute when the Promise is rejected.
+   * @returns A Promise for the completion of the callback.
+   */
+  catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): runtime.Types.Utils.JsPromise<T | TResult>
+  /**
+   * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
+   * resolved value cannot be modified from the callback.
+   * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
+   * @returns A Promise for the completion of the callback.
+   */
+  finally(onfinally?: (() => void) | undefined | null): runtime.Types.Utils.JsPromise<T>
+}
+
+
+
+
+/**
+ * Fields of the Match model
+ */
+export interface MatchFieldRefs {
+  readonly id: Prisma.FieldRef<"Match", 'String'>
+  readonly status: Prisma.FieldRef<"Match", 'MatchStatus'>
+  readonly mode: Prisma.FieldRef<"Match", 'GameMode'>
+  readonly startedAt: Prisma.FieldRef<"Match", 'DateTime'>
+  readonly endedAt: Prisma.FieldRef<"Match", 'DateTime'>
+  readonly createdAt: Prisma.FieldRef<"Match", 'DateTime'>
+  readonly threadTimeComplexity: Prisma.FieldRef<"Match", 'String'>
+  readonly threadSpaceComplexity: Prisma.FieldRef<"Match", 'String'>
+  readonly threadOriginality: Prisma.FieldRef<"Match", 'String'>
+  readonly threadRanking: Prisma.FieldRef<"Match", 'String'>
+}
+    
+
+// Custom InputTypes
+/**
+ * Match findUnique
+ */
+export type MatchFindUniqueArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Match
+   */
+  select?: Prisma.MatchSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Match
+   */
+  omit?: Prisma.MatchOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.MatchInclude<ExtArgs> | null
+  /**
+   * Filter, which Match to fetch.
+   */
+  where: Prisma.MatchWhereUniqueInput
+}
+
+/**
+ * Match findUniqueOrThrow
+ */
+export type MatchFindUniqueOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Match
+   */
+  select?: Prisma.MatchSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Match
+   */
+  omit?: Prisma.MatchOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.MatchInclude<ExtArgs> | null
+  /**
+   * Filter, which Match to fetch.
+   */
+  where: Prisma.MatchWhereUniqueInput
+}
+
+/**
+ * Match findFirst
+ */
+export type MatchFindFirstArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Match
+   */
+  select?: Prisma.MatchSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Match
+   */
+  omit?: Prisma.MatchOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.MatchInclude<ExtArgs> | null
+  /**
+   * Filter, which Match to fetch.
+   */
+  where?: Prisma.MatchWhereInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+   * 
+   * Determine the order of Matches to fetch.
+   */
+  orderBy?: Prisma.MatchOrderByWithRelationInput | Prisma.MatchOrderByWithRelationInput[]
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+   * 
+   * Sets the position for searching for Matches.
+   */
+  cursor?: Prisma.MatchWhereUniqueInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Take `±n` Matches from the position of the cursor.
+   */
+  take?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Skip the first `n` Matches.
+   */
+  skip?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+   * 
+   * Filter by unique combinations of Matches.
+   */
+  distinct?: Prisma.MatchScalarFieldEnum | Prisma.MatchScalarFieldEnum[]
+}
+
+/**
+ * Match findFirstOrThrow
+ */
+export type MatchFindFirstOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Match
+   */
+  select?: Prisma.MatchSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Match
+   */
+  omit?: Prisma.MatchOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.MatchInclude<ExtArgs> | null
+  /**
+   * Filter, which Match to fetch.
+   */
+  where?: Prisma.MatchWhereInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+   * 
+   * Determine the order of Matches to fetch.
+   */
+  orderBy?: Prisma.MatchOrderByWithRelationInput | Prisma.MatchOrderByWithRelationInput[]
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+   * 
+   * Sets the position for searching for Matches.
+   */
+  cursor?: Prisma.MatchWhereUniqueInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Take `±n` Matches from the position of the cursor.
+   */
+  take?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Skip the first `n` Matches.
+   */
+  skip?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+   * 
+   * Filter by unique combinations of Matches.
+   */
+  distinct?: Prisma.MatchScalarFieldEnum | Prisma.MatchScalarFieldEnum[]
+}
+
+/**
+ * Match findMany
+ */
+export type MatchFindManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Match
+   */
+  select?: Prisma.MatchSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Match
+   */
+  omit?: Prisma.MatchOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.MatchInclude<ExtArgs> | null
+  /**
+   * Filter, which Matches to fetch.
+   */
+  where?: Prisma.MatchWhereInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+   * 
+   * Determine the order of Matches to fetch.
+   */
+  orderBy?: Prisma.MatchOrderByWithRelationInput | Prisma.MatchOrderByWithRelationInput[]
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+   * 
+   * Sets the position for listing Matches.
+   */
+  cursor?: Prisma.MatchWhereUniqueInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Take `±n` Matches from the position of the cursor.
+   */
+  take?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Skip the first `n` Matches.
+   */
+  skip?: number
+  distinct?: Prisma.MatchScalarFieldEnum | Prisma.MatchScalarFieldEnum[]
+}
+
+/**
+ * Match create
+ */
+export type MatchCreateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Match
+   */
+  select?: Prisma.MatchSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Match
+   */
+  omit?: Prisma.MatchOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.MatchInclude<ExtArgs> | null
+  /**
+   * The data needed to create a Match.
+   */
+  data?: Prisma.XOR<Prisma.MatchCreateInput, Prisma.MatchUncheckedCreateInput>
+}
+
+/**
+ * Match createMany
+ */
+export type MatchCreateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * The data used to create many Matches.
+   */
+  data: Prisma.MatchCreateManyInput | Prisma.MatchCreateManyInput[]
+  skipDuplicates?: boolean
+}
+
+/**
+ * Match createManyAndReturn
+ */
+export type MatchCreateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Match
+   */
+  select?: Prisma.MatchSelectCreateManyAndReturn<ExtArgs> | null
+  /**
+   * Omit specific fields from the Match
+   */
+  omit?: Prisma.MatchOmit<ExtArgs> | null
+  /**
+   * The data used to create many Matches.
+   */
+  data: Prisma.MatchCreateManyInput | Prisma.MatchCreateManyInput[]
+  skipDuplicates?: boolean
+}
+
+/**
+ * Match update
+ */
+export type MatchUpdateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Match
+   */
+  select?: Prisma.MatchSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Match
+   */
+  omit?: Prisma.MatchOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.MatchInclude<ExtArgs> | null
+  /**
+   * The data needed to update a Match.
+   */
+  data: Prisma.XOR<Prisma.MatchUpdateInput, Prisma.MatchUncheckedUpdateInput>
+  /**
+   * Choose, which Match to update.
+   */
+  where: Prisma.MatchWhereUniqueInput
+}
+
+/**
+ * Match updateMany
+ */
+export type MatchUpdateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * The data used to update Matches.
+   */
+  data: Prisma.XOR<Prisma.MatchUpdateManyMutationInput, Prisma.MatchUncheckedUpdateManyInput>
+  /**
+   * Filter which Matches to update
+   */
+  where?: Prisma.MatchWhereInput
+  /**
+   * Limit how many Matches to update.
+   */
+  limit?: number
+}
+
+/**
+ * Match updateManyAndReturn
+ */
+export type MatchUpdateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Match
+   */
+  select?: Prisma.MatchSelectUpdateManyAndReturn<ExtArgs> | null
+  /**
+   * Omit specific fields from the Match
+   */
+  omit?: Prisma.MatchOmit<ExtArgs> | null
+  /**
+   * The data used to update Matches.
+   */
+  data: Prisma.XOR<Prisma.MatchUpdateManyMutationInput, Prisma.MatchUncheckedUpdateManyInput>
+  /**
+   * Filter which Matches to update
+   */
+  where?: Prisma.MatchWhereInput
+  /**
+   * Limit how many Matches to update.
+   */
+  limit?: number
+}
+
+/**
+ * Match upsert
+ */
+export type MatchUpsertArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Match
+   */
+  select?: Prisma.MatchSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Match
+   */
+  omit?: Prisma.MatchOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.MatchInclude<ExtArgs> | null
+  /**
+   * The filter to search for the Match to update in case it exists.
+   */
+  where: Prisma.MatchWhereUniqueInput
+  /**
+   * In case the Match found by the `where` argument doesn't exist, create a new Match with this data.
+   */
+  create: Prisma.XOR<Prisma.MatchCreateInput, Prisma.MatchUncheckedCreateInput>
+  /**
+   * In case the Match was found with the provided `where` argument, update it with this data.
+   */
+  update: Prisma.XOR<Prisma.MatchUpdateInput, Prisma.MatchUncheckedUpdateInput>
+}
+
+/**
+ * Match delete
+ */
+export type MatchDeleteArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Match
+   */
+  select?: Prisma.MatchSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Match
+   */
+  omit?: Prisma.MatchOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.MatchInclude<ExtArgs> | null
+  /**
+   * Filter which Match to delete.
+   */
+  where: Prisma.MatchWhereUniqueInput
+}
+
+/**
+ * Match deleteMany
+ */
+export type MatchDeleteManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Filter which Matches to delete
+   */
+  where?: Prisma.MatchWhereInput
+  /**
+   * Limit how many Matches to delete.
+   */
+  limit?: number
+}
+
+/**
+ * Match.players
+ */
+export type Match$playersArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the MatchPlayer
+   */
+  select?: Prisma.MatchPlayerSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the MatchPlayer
+   */
+  omit?: Prisma.MatchPlayerOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.MatchPlayerInclude<ExtArgs> | null
+  where?: Prisma.MatchPlayerWhereInput
+  orderBy?: Prisma.MatchPlayerOrderByWithRelationInput | Prisma.MatchPlayerOrderByWithRelationInput[]
+  cursor?: Prisma.MatchPlayerWhereUniqueInput
+  take?: number
+  skip?: number
+  distinct?: Prisma.MatchPlayerScalarFieldEnum | Prisma.MatchPlayerScalarFieldEnum[]
+}
+
+/**
+ * Match.questions
+ */
+export type Match$questionsArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the MatchQuestion
+   */
+  select?: Prisma.MatchQuestionSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the MatchQuestion
+   */
+  omit?: Prisma.MatchQuestionOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.MatchQuestionInclude<ExtArgs> | null
+  where?: Prisma.MatchQuestionWhereInput
+  orderBy?: Prisma.MatchQuestionOrderByWithRelationInput | Prisma.MatchQuestionOrderByWithRelationInput[]
+  cursor?: Prisma.MatchQuestionWhereUniqueInput
+  take?: number
+  skip?: number
+  distinct?: Prisma.MatchQuestionScalarFieldEnum | Prisma.MatchQuestionScalarFieldEnum[]
+}
+
+/**
+ * Match.submissions
+ */
+export type Match$submissionsArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Submission
+   */
+  select?: Prisma.SubmissionSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Submission
+   */
+  omit?: Prisma.SubmissionOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.SubmissionInclude<ExtArgs> | null
+  where?: Prisma.SubmissionWhereInput
+  orderBy?: Prisma.SubmissionOrderByWithRelationInput | Prisma.SubmissionOrderByWithRelationInput[]
+  cursor?: Prisma.SubmissionWhereUniqueInput
+  take?: number
+  skip?: number
+  distinct?: Prisma.SubmissionScalarFieldEnum | Prisma.SubmissionScalarFieldEnum[]
+}
+
+/**
+ * Match without action
+ */
+export type MatchDefaultArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Match
+   */
+  select?: Prisma.MatchSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Match
+   */
+  omit?: Prisma.MatchOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.MatchInclude<ExtArgs> | null
+}
diff --git a/prisma/generated/prisma/models/MatchPlayer.ts b/prisma/generated/prisma/models/MatchPlayer.ts
new file mode 100644
index 0000000..66840d7
--- /dev/null
+++ b/prisma/generated/prisma/models/MatchPlayer.ts
@@ -0,0 +1,1573 @@
+
+/* !!! This is code generated by Prisma. Do not edit directly. !!! */
+/* eslint-disable */
+// biome-ignore-all lint: generated file
+// @ts-nocheck 
+/*
+ * This file exports the `MatchPlayer` model and its related types.
+ *
+ * 🟢 You can import this file directly.
+ */
+import type * as runtime from "@prisma/client/runtime/client"
+import type * as $Enums from "../enums"
+import type * as Prisma from "../internal/prismaNamespace"
+
+/**
+ * Model MatchPlayer
+ * 
+ */
+export type MatchPlayerModel = runtime.Types.Result.DefaultSelection<Prisma.$MatchPlayerPayload>
+
+export type AggregateMatchPlayer = {
+  _count: MatchPlayerCountAggregateOutputType | null
+  _avg: MatchPlayerAvgAggregateOutputType | null
+  _sum: MatchPlayerSumAggregateOutputType | null
+  _min: MatchPlayerMinAggregateOutputType | null
+  _max: MatchPlayerMaxAggregateOutputType | null
+}
+
+export type MatchPlayerAvgAggregateOutputType = {
+  rank: number | null
+  score: number | null
+}
+
+export type MatchPlayerSumAggregateOutputType = {
+  rank: number | null
+  score: number | null
+}
+
+export type MatchPlayerMinAggregateOutputType = {
+  id: string | null
+  matchId: string | null
+  userId: string | null
+  rank: number | null
+  score: number | null
+  joinedAt: Date | null
+}
+
+export type MatchPlayerMaxAggregateOutputType = {
+  id: string | null
+  matchId: string | null
+  userId: string | null
+  rank: number | null
+  score: number | null
+  joinedAt: Date | null
+}
+
+export type MatchPlayerCountAggregateOutputType = {
+  id: number
+  matchId: number
+  userId: number
+  rank: number
+  score: number
+  joinedAt: number
+  _all: number
+}
+
+
+export type MatchPlayerAvgAggregateInputType = {
+  rank?: true
+  score?: true
+}
+
+export type MatchPlayerSumAggregateInputType = {
+  rank?: true
+  score?: true
+}
+
+export type MatchPlayerMinAggregateInputType = {
+  id?: true
+  matchId?: true
+  userId?: true
+  rank?: true
+  score?: true
+  joinedAt?: true
+}
+
+export type MatchPlayerMaxAggregateInputType = {
+  id?: true
+  matchId?: true
+  userId?: true
+  rank?: true
+  score?: true
+  joinedAt?: true
+}
+
+export type MatchPlayerCountAggregateInputType = {
+  id?: true
+  matchId?: true
+  userId?: true
+  rank?: true
+  score?: true
+  joinedAt?: true
+  _all?: true
+}
+
+export type MatchPlayerAggregateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Filter which MatchPlayer to aggregate.
+   */
+  where?: Prisma.MatchPlayerWhereInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+   * 
+   * Determine the order of MatchPlayers to fetch.
+   */
+  orderBy?: Prisma.MatchPlayerOrderByWithRelationInput | Prisma.MatchPlayerOrderByWithRelationInput[]
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+   * 
+   * Sets the start position
+   */
+  cursor?: Prisma.MatchPlayerWhereUniqueInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Take `±n` MatchPlayers from the position of the cursor.
+   */
+  take?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Skip the first `n` MatchPlayers.
+   */
+  skip?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Count returned MatchPlayers
+  **/
+  _count?: true | MatchPlayerCountAggregateInputType
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Select which fields to average
+  **/
+  _avg?: MatchPlayerAvgAggregateInputType
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Select which fields to sum
+  **/
+  _sum?: MatchPlayerSumAggregateInputType
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Select which fields to find the minimum value
+  **/
+  _min?: MatchPlayerMinAggregateInputType
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Select which fields to find the maximum value
+  **/
+  _max?: MatchPlayerMaxAggregateInputType
+}
+
+export type GetMatchPlayerAggregateType<T extends MatchPlayerAggregateArgs> = {
+      [P in keyof T & keyof AggregateMatchPlayer]: P extends '_count' | 'count'
+    ? T[P] extends true
+      ? number
+      : Prisma.GetScalarType<T[P], AggregateMatchPlayer[P]>
+    : Prisma.GetScalarType<T[P], AggregateMatchPlayer[P]>
+}
+
+
+
+
+export type MatchPlayerGroupByArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  where?: Prisma.MatchPlayerWhereInput
+  orderBy?: Prisma.MatchPlayerOrderByWithAggregationInput | Prisma.MatchPlayerOrderByWithAggregationInput[]
+  by: Prisma.MatchPlayerScalarFieldEnum[] | Prisma.MatchPlayerScalarFieldEnum
+  having?: Prisma.MatchPlayerScalarWhereWithAggregatesInput
+  take?: number
+  skip?: number
+  _count?: MatchPlayerCountAggregateInputType | true
+  _avg?: MatchPlayerAvgAggregateInputType
+  _sum?: MatchPlayerSumAggregateInputType
+  _min?: MatchPlayerMinAggregateInputType
+  _max?: MatchPlayerMaxAggregateInputType
+}
+
+export type MatchPlayerGroupByOutputType = {
+  id: string
+  matchId: string
+  userId: string
+  rank: number | null
+  score: number | null
+  joinedAt: Date
+  _count: MatchPlayerCountAggregateOutputType | null
+  _avg: MatchPlayerAvgAggregateOutputType | null
+  _sum: MatchPlayerSumAggregateOutputType | null
+  _min: MatchPlayerMinAggregateOutputType | null
+  _max: MatchPlayerMaxAggregateOutputType | null
+}
+
+type GetMatchPlayerGroupByPayload<T extends MatchPlayerGroupByArgs> = Prisma.PrismaPromise<
+  Array<
+    Prisma.PickEnumerable<MatchPlayerGroupByOutputType, T['by']> &
+      {
+        [P in ((keyof T) & (keyof MatchPlayerGroupByOutputType))]: P extends '_count'
+          ? T[P] extends boolean
+            ? number
+            : Prisma.GetScalarType<T[P], MatchPlayerGroupByOutputType[P]>
+          : Prisma.GetScalarType<T[P], MatchPlayerGroupByOutputType[P]>
+      }
+    >
+  >
+
+
+
+export type MatchPlayerWhereInput = {
+  AND?: Prisma.MatchPlayerWhereInput | Prisma.MatchPlayerWhereInput[]
+  OR?: Prisma.MatchPlayerWhereInput[]
+  NOT?: Prisma.MatchPlayerWhereInput | Prisma.MatchPlayerWhereInput[]
+  id?: Prisma.StringFilter<"MatchPlayer"> | string
+  matchId?: Prisma.StringFilter<"MatchPlayer"> | string
+  userId?: Prisma.StringFilter<"MatchPlayer"> | string
+  rank?: Prisma.IntNullableFilter<"MatchPlayer"> | number | null
+  score?: Prisma.FloatNullableFilter<"MatchPlayer"> | number | null
+  joinedAt?: Prisma.DateTimeFilter<"MatchPlayer"> | Date | string
+  match?: Prisma.XOR<Prisma.MatchScalarRelationFilter, Prisma.MatchWhereInput>
+  user?: Prisma.XOR<Prisma.UserScalarRelationFilter, Prisma.UserWhereInput>
+}
+
+export type MatchPlayerOrderByWithRelationInput = {
+  id?: Prisma.SortOrder
+  matchId?: Prisma.SortOrder
+  userId?: Prisma.SortOrder
+  rank?: Prisma.SortOrderInput | Prisma.SortOrder
+  score?: Prisma.SortOrderInput | Prisma.SortOrder
+  joinedAt?: Prisma.SortOrder
+  match?: Prisma.MatchOrderByWithRelationInput
+  user?: Prisma.UserOrderByWithRelationInput
+}
+
+export type MatchPlayerWhereUniqueInput = Prisma.AtLeast<{
+  id?: string
+  matchId_userId?: Prisma.MatchPlayerMatchIdUserIdCompoundUniqueInput
+  AND?: Prisma.MatchPlayerWhereInput | Prisma.MatchPlayerWhereInput[]
+  OR?: Prisma.MatchPlayerWhereInput[]
+  NOT?: Prisma.MatchPlayerWhereInput | Prisma.MatchPlayerWhereInput[]
+  matchId?: Prisma.StringFilter<"MatchPlayer"> | string
+  userId?: Prisma.StringFilter<"MatchPlayer"> | string
+  rank?: Prisma.IntNullableFilter<"MatchPlayer"> | number | null
+  score?: Prisma.FloatNullableFilter<"MatchPlayer"> | number | null
+  joinedAt?: Prisma.DateTimeFilter<"MatchPlayer"> | Date | string
+  match?: Prisma.XOR<Prisma.MatchScalarRelationFilter, Prisma.MatchWhereInput>
+  user?: Prisma.XOR<Prisma.UserScalarRelationFilter, Prisma.UserWhereInput>
+}, "id" | "matchId_userId">
+
+export type MatchPlayerOrderByWithAggregationInput = {
+  id?: Prisma.SortOrder
+  matchId?: Prisma.SortOrder
+  userId?: Prisma.SortOrder
+  rank?: Prisma.SortOrderInput | Prisma.SortOrder
+  score?: Prisma.SortOrderInput | Prisma.SortOrder
+  joinedAt?: Prisma.SortOrder
+  _count?: Prisma.MatchPlayerCountOrderByAggregateInput
+  _avg?: Prisma.MatchPlayerAvgOrderByAggregateInput
+  _max?: Prisma.MatchPlayerMaxOrderByAggregateInput
+  _min?: Prisma.MatchPlayerMinOrderByAggregateInput
+  _sum?: Prisma.MatchPlayerSumOrderByAggregateInput
+}
+
+export type MatchPlayerScalarWhereWithAggregatesInput = {
+  AND?: Prisma.MatchPlayerScalarWhereWithAggregatesInput | Prisma.MatchPlayerScalarWhereWithAggregatesInput[]
+  OR?: Prisma.MatchPlayerScalarWhereWithAggregatesInput[]
+  NOT?: Prisma.MatchPlayerScalarWhereWithAggregatesInput | Prisma.MatchPlayerScalarWhereWithAggregatesInput[]
+  id?: Prisma.StringWithAggregatesFilter<"MatchPlayer"> | string
+  matchId?: Prisma.StringWithAggregatesFilter<"MatchPlayer"> | string
+  userId?: Prisma.StringWithAggregatesFilter<"MatchPlayer"> | string
+  rank?: Prisma.IntNullableWithAggregatesFilter<"MatchPlayer"> | number | null
+  score?: Prisma.FloatNullableWithAggregatesFilter<"MatchPlayer"> | number | null
+  joinedAt?: Prisma.DateTimeWithAggregatesFilter<"MatchPlayer"> | Date | string
+}
+
+export type MatchPlayerCreateInput = {
+  id?: string
+  rank?: number | null
+  score?: number | null
+  joinedAt?: Date | string
+  match: Prisma.MatchCreateNestedOneWithoutPlayersInput
+  user: Prisma.UserCreateNestedOneWithoutMatchPlayersInput
+}
+
+export type MatchPlayerUncheckedCreateInput = {
+  id?: string
+  matchId: string
+  userId: string
+  rank?: number | null
+  score?: number | null
+  joinedAt?: Date | string
+}
+
+export type MatchPlayerUpdateInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  rank?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
+  score?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  joinedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  match?: Prisma.MatchUpdateOneRequiredWithoutPlayersNestedInput
+  user?: Prisma.UserUpdateOneRequiredWithoutMatchPlayersNestedInput
+}
+
+export type MatchPlayerUncheckedUpdateInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  matchId?: Prisma.StringFieldUpdateOperationsInput | string
+  userId?: Prisma.StringFieldUpdateOperationsInput | string
+  rank?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
+  score?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  joinedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+}
+
+export type MatchPlayerCreateManyInput = {
+  id?: string
+  matchId: string
+  userId: string
+  rank?: number | null
+  score?: number | null
+  joinedAt?: Date | string
+}
+
+export type MatchPlayerUpdateManyMutationInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  rank?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
+  score?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  joinedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+}
+
+export type MatchPlayerUncheckedUpdateManyInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  matchId?: Prisma.StringFieldUpdateOperationsInput | string
+  userId?: Prisma.StringFieldUpdateOperationsInput | string
+  rank?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
+  score?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  joinedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+}
+
+export type MatchPlayerListRelationFilter = {
+  every?: Prisma.MatchPlayerWhereInput
+  some?: Prisma.MatchPlayerWhereInput
+  none?: Prisma.MatchPlayerWhereInput
+}
+
+export type MatchPlayerOrderByRelationAggregateInput = {
+  _count?: Prisma.SortOrder
+}
+
+export type MatchPlayerMatchIdUserIdCompoundUniqueInput = {
+  matchId: string
+  userId: string
+}
+
+export type MatchPlayerCountOrderByAggregateInput = {
+  id?: Prisma.SortOrder
+  matchId?: Prisma.SortOrder
+  userId?: Prisma.SortOrder
+  rank?: Prisma.SortOrder
+  score?: Prisma.SortOrder
+  joinedAt?: Prisma.SortOrder
+}
+
+export type MatchPlayerAvgOrderByAggregateInput = {
+  rank?: Prisma.SortOrder
+  score?: Prisma.SortOrder
+}
+
+export type MatchPlayerMaxOrderByAggregateInput = {
+  id?: Prisma.SortOrder
+  matchId?: Prisma.SortOrder
+  userId?: Prisma.SortOrder
+  rank?: Prisma.SortOrder
+  score?: Prisma.SortOrder
+  joinedAt?: Prisma.SortOrder
+}
+
+export type MatchPlayerMinOrderByAggregateInput = {
+  id?: Prisma.SortOrder
+  matchId?: Prisma.SortOrder
+  userId?: Prisma.SortOrder
+  rank?: Prisma.SortOrder
+  score?: Prisma.SortOrder
+  joinedAt?: Prisma.SortOrder
+}
+
+export type MatchPlayerSumOrderByAggregateInput = {
+  rank?: Prisma.SortOrder
+  score?: Prisma.SortOrder
+}
+
+export type MatchPlayerCreateNestedManyWithoutUserInput = {
+  create?: Prisma.XOR<Prisma.MatchPlayerCreateWithoutUserInput, Prisma.MatchPlayerUncheckedCreateWithoutUserInput> | Prisma.MatchPlayerCreateWithoutUserInput[] | Prisma.MatchPlayerUncheckedCreateWithoutUserInput[]
+  connectOrCreate?: Prisma.MatchPlayerCreateOrConnectWithoutUserInput | Prisma.MatchPlayerCreateOrConnectWithoutUserInput[]
+  createMany?: Prisma.MatchPlayerCreateManyUserInputEnvelope
+  connect?: Prisma.MatchPlayerWhereUniqueInput | Prisma.MatchPlayerWhereUniqueInput[]
+}
+
+export type MatchPlayerUncheckedCreateNestedManyWithoutUserInput = {
+  create?: Prisma.XOR<Prisma.MatchPlayerCreateWithoutUserInput, Prisma.MatchPlayerUncheckedCreateWithoutUserInput> | Prisma.MatchPlayerCreateWithoutUserInput[] | Prisma.MatchPlayerUncheckedCreateWithoutUserInput[]
+  connectOrCreate?: Prisma.MatchPlayerCreateOrConnectWithoutUserInput | Prisma.MatchPlayerCreateOrConnectWithoutUserInput[]
+  createMany?: Prisma.MatchPlayerCreateManyUserInputEnvelope
+  connect?: Prisma.MatchPlayerWhereUniqueInput | Prisma.MatchPlayerWhereUniqueInput[]
+}
+
+export type MatchPlayerUpdateManyWithoutUserNestedInput = {
+  create?: Prisma.XOR<Prisma.MatchPlayerCreateWithoutUserInput, Prisma.MatchPlayerUncheckedCreateWithoutUserInput> | Prisma.MatchPlayerCreateWithoutUserInput[] | Prisma.MatchPlayerUncheckedCreateWithoutUserInput[]
+  connectOrCreate?: Prisma.MatchPlayerCreateOrConnectWithoutUserInput | Prisma.MatchPlayerCreateOrConnectWithoutUserInput[]
+  upsert?: Prisma.MatchPlayerUpsertWithWhereUniqueWithoutUserInput | Prisma.MatchPlayerUpsertWithWhereUniqueWithoutUserInput[]
+  createMany?: Prisma.MatchPlayerCreateManyUserInputEnvelope
+  set?: Prisma.MatchPlayerWhereUniqueInput | Prisma.MatchPlayerWhereUniqueInput[]
+  disconnect?: Prisma.MatchPlayerWhereUniqueInput | Prisma.MatchPlayerWhereUniqueInput[]
+  delete?: Prisma.MatchPlayerWhereUniqueInput | Prisma.MatchPlayerWhereUniqueInput[]
+  connect?: Prisma.MatchPlayerWhereUniqueInput | Prisma.MatchPlayerWhereUniqueInput[]
+  update?: Prisma.MatchPlayerUpdateWithWhereUniqueWithoutUserInput | Prisma.MatchPlayerUpdateWithWhereUniqueWithoutUserInput[]
+  updateMany?: Prisma.MatchPlayerUpdateManyWithWhereWithoutUserInput | Prisma.MatchPlayerUpdateManyWithWhereWithoutUserInput[]
+  deleteMany?: Prisma.MatchPlayerScalarWhereInput | Prisma.MatchPlayerScalarWhereInput[]
+}
+
+export type MatchPlayerUncheckedUpdateManyWithoutUserNestedInput = {
+  create?: Prisma.XOR<Prisma.MatchPlayerCreateWithoutUserInput, Prisma.MatchPlayerUncheckedCreateWithoutUserInput> | Prisma.MatchPlayerCreateWithoutUserInput[] | Prisma.MatchPlayerUncheckedCreateWithoutUserInput[]
+  connectOrCreate?: Prisma.MatchPlayerCreateOrConnectWithoutUserInput | Prisma.MatchPlayerCreateOrConnectWithoutUserInput[]
+  upsert?: Prisma.MatchPlayerUpsertWithWhereUniqueWithoutUserInput | Prisma.MatchPlayerUpsertWithWhereUniqueWithoutUserInput[]
+  createMany?: Prisma.MatchPlayerCreateManyUserInputEnvelope
+  set?: Prisma.MatchPlayerWhereUniqueInput | Prisma.MatchPlayerWhereUniqueInput[]
+  disconnect?: Prisma.MatchPlayerWhereUniqueInput | Prisma.MatchPlayerWhereUniqueInput[]
+  delete?: Prisma.MatchPlayerWhereUniqueInput | Prisma.MatchPlayerWhereUniqueInput[]
+  connect?: Prisma.MatchPlayerWhereUniqueInput | Prisma.MatchPlayerWhereUniqueInput[]
+  update?: Prisma.MatchPlayerUpdateWithWhereUniqueWithoutUserInput | Prisma.MatchPlayerUpdateWithWhereUniqueWithoutUserInput[]
+  updateMany?: Prisma.MatchPlayerUpdateManyWithWhereWithoutUserInput | Prisma.MatchPlayerUpdateManyWithWhereWithoutUserInput[]
+  deleteMany?: Prisma.MatchPlayerScalarWhereInput | Prisma.MatchPlayerScalarWhereInput[]
+}
+
+export type MatchPlayerCreateNestedManyWithoutMatchInput = {
+  create?: Prisma.XOR<Prisma.MatchPlayerCreateWithoutMatchInput, Prisma.MatchPlayerUncheckedCreateWithoutMatchInput> | Prisma.MatchPlayerCreateWithoutMatchInput[] | Prisma.MatchPlayerUncheckedCreateWithoutMatchInput[]
+  connectOrCreate?: Prisma.MatchPlayerCreateOrConnectWithoutMatchInput | Prisma.MatchPlayerCreateOrConnectWithoutMatchInput[]
+  createMany?: Prisma.MatchPlayerCreateManyMatchInputEnvelope
+  connect?: Prisma.MatchPlayerWhereUniqueInput | Prisma.MatchPlayerWhereUniqueInput[]
+}
+
+export type MatchPlayerUncheckedCreateNestedManyWithoutMatchInput = {
+  create?: Prisma.XOR<Prisma.MatchPlayerCreateWithoutMatchInput, Prisma.MatchPlayerUncheckedCreateWithoutMatchInput> | Prisma.MatchPlayerCreateWithoutMatchInput[] | Prisma.MatchPlayerUncheckedCreateWithoutMatchInput[]
+  connectOrCreate?: Prisma.MatchPlayerCreateOrConnectWithoutMatchInput | Prisma.MatchPlayerCreateOrConnectWithoutMatchInput[]
+  createMany?: Prisma.MatchPlayerCreateManyMatchInputEnvelope
+  connect?: Prisma.MatchPlayerWhereUniqueInput | Prisma.MatchPlayerWhereUniqueInput[]
+}
+
+export type MatchPlayerUpdateManyWithoutMatchNestedInput = {
+  create?: Prisma.XOR<Prisma.MatchPlayerCreateWithoutMatchInput, Prisma.MatchPlayerUncheckedCreateWithoutMatchInput> | Prisma.MatchPlayerCreateWithoutMatchInput[] | Prisma.MatchPlayerUncheckedCreateWithoutMatchInput[]
+  connectOrCreate?: Prisma.MatchPlayerCreateOrConnectWithoutMatchInput | Prisma.MatchPlayerCreateOrConnectWithoutMatchInput[]
+  upsert?: Prisma.MatchPlayerUpsertWithWhereUniqueWithoutMatchInput | Prisma.MatchPlayerUpsertWithWhereUniqueWithoutMatchInput[]
+  createMany?: Prisma.MatchPlayerCreateManyMatchInputEnvelope
+  set?: Prisma.MatchPlayerWhereUniqueInput | Prisma.MatchPlayerWhereUniqueInput[]
+  disconnect?: Prisma.MatchPlayerWhereUniqueInput | Prisma.MatchPlayerWhereUniqueInput[]
+  delete?: Prisma.MatchPlayerWhereUniqueInput | Prisma.MatchPlayerWhereUniqueInput[]
+  connect?: Prisma.MatchPlayerWhereUniqueInput | Prisma.MatchPlayerWhereUniqueInput[]
+  update?: Prisma.MatchPlayerUpdateWithWhereUniqueWithoutMatchInput | Prisma.MatchPlayerUpdateWithWhereUniqueWithoutMatchInput[]
+  updateMany?: Prisma.MatchPlayerUpdateManyWithWhereWithoutMatchInput | Prisma.MatchPlayerUpdateManyWithWhereWithoutMatchInput[]
+  deleteMany?: Prisma.MatchPlayerScalarWhereInput | Prisma.MatchPlayerScalarWhereInput[]
+}
+
+export type MatchPlayerUncheckedUpdateManyWithoutMatchNestedInput = {
+  create?: Prisma.XOR<Prisma.MatchPlayerCreateWithoutMatchInput, Prisma.MatchPlayerUncheckedCreateWithoutMatchInput> | Prisma.MatchPlayerCreateWithoutMatchInput[] | Prisma.MatchPlayerUncheckedCreateWithoutMatchInput[]
+  connectOrCreate?: Prisma.MatchPlayerCreateOrConnectWithoutMatchInput | Prisma.MatchPlayerCreateOrConnectWithoutMatchInput[]
+  upsert?: Prisma.MatchPlayerUpsertWithWhereUniqueWithoutMatchInput | Prisma.MatchPlayerUpsertWithWhereUniqueWithoutMatchInput[]
+  createMany?: Prisma.MatchPlayerCreateManyMatchInputEnvelope
+  set?: Prisma.MatchPlayerWhereUniqueInput | Prisma.MatchPlayerWhereUniqueInput[]
+  disconnect?: Prisma.MatchPlayerWhereUniqueInput | Prisma.MatchPlayerWhereUniqueInput[]
+  delete?: Prisma.MatchPlayerWhereUniqueInput | Prisma.MatchPlayerWhereUniqueInput[]
+  connect?: Prisma.MatchPlayerWhereUniqueInput | Prisma.MatchPlayerWhereUniqueInput[]
+  update?: Prisma.MatchPlayerUpdateWithWhereUniqueWithoutMatchInput | Prisma.MatchPlayerUpdateWithWhereUniqueWithoutMatchInput[]
+  updateMany?: Prisma.MatchPlayerUpdateManyWithWhereWithoutMatchInput | Prisma.MatchPlayerUpdateManyWithWhereWithoutMatchInput[]
+  deleteMany?: Prisma.MatchPlayerScalarWhereInput | Prisma.MatchPlayerScalarWhereInput[]
+}
+
+export type NullableIntFieldUpdateOperationsInput = {
+  set?: number | null
+  increment?: number
+  decrement?: number
+  multiply?: number
+  divide?: number
+}
+
+export type NullableFloatFieldUpdateOperationsInput = {
+  set?: number | null
+  increment?: number
+  decrement?: number
+  multiply?: number
+  divide?: number
+}
+
+export type MatchPlayerCreateWithoutUserInput = {
+  id?: string
+  rank?: number | null
+  score?: number | null
+  joinedAt?: Date | string
+  match: Prisma.MatchCreateNestedOneWithoutPlayersInput
+}
+
+export type MatchPlayerUncheckedCreateWithoutUserInput = {
+  id?: string
+  matchId: string
+  rank?: number | null
+  score?: number | null
+  joinedAt?: Date | string
+}
+
+export type MatchPlayerCreateOrConnectWithoutUserInput = {
+  where: Prisma.MatchPlayerWhereUniqueInput
+  create: Prisma.XOR<Prisma.MatchPlayerCreateWithoutUserInput, Prisma.MatchPlayerUncheckedCreateWithoutUserInput>
+}
+
+export type MatchPlayerCreateManyUserInputEnvelope = {
+  data: Prisma.MatchPlayerCreateManyUserInput | Prisma.MatchPlayerCreateManyUserInput[]
+  skipDuplicates?: boolean
+}
+
+export type MatchPlayerUpsertWithWhereUniqueWithoutUserInput = {
+  where: Prisma.MatchPlayerWhereUniqueInput
+  update: Prisma.XOR<Prisma.MatchPlayerUpdateWithoutUserInput, Prisma.MatchPlayerUncheckedUpdateWithoutUserInput>
+  create: Prisma.XOR<Prisma.MatchPlayerCreateWithoutUserInput, Prisma.MatchPlayerUncheckedCreateWithoutUserInput>
+}
+
+export type MatchPlayerUpdateWithWhereUniqueWithoutUserInput = {
+  where: Prisma.MatchPlayerWhereUniqueInput
+  data: Prisma.XOR<Prisma.MatchPlayerUpdateWithoutUserInput, Prisma.MatchPlayerUncheckedUpdateWithoutUserInput>
+}
+
+export type MatchPlayerUpdateManyWithWhereWithoutUserInput = {
+  where: Prisma.MatchPlayerScalarWhereInput
+  data: Prisma.XOR<Prisma.MatchPlayerUpdateManyMutationInput, Prisma.MatchPlayerUncheckedUpdateManyWithoutUserInput>
+}
+
+export type MatchPlayerScalarWhereInput = {
+  AND?: Prisma.MatchPlayerScalarWhereInput | Prisma.MatchPlayerScalarWhereInput[]
+  OR?: Prisma.MatchPlayerScalarWhereInput[]
+  NOT?: Prisma.MatchPlayerScalarWhereInput | Prisma.MatchPlayerScalarWhereInput[]
+  id?: Prisma.StringFilter<"MatchPlayer"> | string
+  matchId?: Prisma.StringFilter<"MatchPlayer"> | string
+  userId?: Prisma.StringFilter<"MatchPlayer"> | string
+  rank?: Prisma.IntNullableFilter<"MatchPlayer"> | number | null
+  score?: Prisma.FloatNullableFilter<"MatchPlayer"> | number | null
+  joinedAt?: Prisma.DateTimeFilter<"MatchPlayer"> | Date | string
+}
+
+export type MatchPlayerCreateWithoutMatchInput = {
+  id?: string
+  rank?: number | null
+  score?: number | null
+  joinedAt?: Date | string
+  user: Prisma.UserCreateNestedOneWithoutMatchPlayersInput
+}
+
+export type MatchPlayerUncheckedCreateWithoutMatchInput = {
+  id?: string
+  userId: string
+  rank?: number | null
+  score?: number | null
+  joinedAt?: Date | string
+}
+
+export type MatchPlayerCreateOrConnectWithoutMatchInput = {
+  where: Prisma.MatchPlayerWhereUniqueInput
+  create: Prisma.XOR<Prisma.MatchPlayerCreateWithoutMatchInput, Prisma.MatchPlayerUncheckedCreateWithoutMatchInput>
+}
+
+export type MatchPlayerCreateManyMatchInputEnvelope = {
+  data: Prisma.MatchPlayerCreateManyMatchInput | Prisma.MatchPlayerCreateManyMatchInput[]
+  skipDuplicates?: boolean
+}
+
+export type MatchPlayerUpsertWithWhereUniqueWithoutMatchInput = {
+  where: Prisma.MatchPlayerWhereUniqueInput
+  update: Prisma.XOR<Prisma.MatchPlayerUpdateWithoutMatchInput, Prisma.MatchPlayerUncheckedUpdateWithoutMatchInput>
+  create: Prisma.XOR<Prisma.MatchPlayerCreateWithoutMatchInput, Prisma.MatchPlayerUncheckedCreateWithoutMatchInput>
+}
+
+export type MatchPlayerUpdateWithWhereUniqueWithoutMatchInput = {
+  where: Prisma.MatchPlayerWhereUniqueInput
+  data: Prisma.XOR<Prisma.MatchPlayerUpdateWithoutMatchInput, Prisma.MatchPlayerUncheckedUpdateWithoutMatchInput>
+}
+
+export type MatchPlayerUpdateManyWithWhereWithoutMatchInput = {
+  where: Prisma.MatchPlayerScalarWhereInput
+  data: Prisma.XOR<Prisma.MatchPlayerUpdateManyMutationInput, Prisma.MatchPlayerUncheckedUpdateManyWithoutMatchInput>
+}
+
+export type MatchPlayerCreateManyUserInput = {
+  id?: string
+  matchId: string
+  rank?: number | null
+  score?: number | null
+  joinedAt?: Date | string
+}
+
+export type MatchPlayerUpdateWithoutUserInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  rank?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
+  score?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  joinedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  match?: Prisma.MatchUpdateOneRequiredWithoutPlayersNestedInput
+}
+
+export type MatchPlayerUncheckedUpdateWithoutUserInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  matchId?: Prisma.StringFieldUpdateOperationsInput | string
+  rank?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
+  score?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  joinedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+}
+
+export type MatchPlayerUncheckedUpdateManyWithoutUserInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  matchId?: Prisma.StringFieldUpdateOperationsInput | string
+  rank?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
+  score?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  joinedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+}
+
+export type MatchPlayerCreateManyMatchInput = {
+  id?: string
+  userId: string
+  rank?: number | null
+  score?: number | null
+  joinedAt?: Date | string
+}
+
+export type MatchPlayerUpdateWithoutMatchInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  rank?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
+  score?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  joinedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  user?: Prisma.UserUpdateOneRequiredWithoutMatchPlayersNestedInput
+}
+
+export type MatchPlayerUncheckedUpdateWithoutMatchInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  userId?: Prisma.StringFieldUpdateOperationsInput | string
+  rank?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
+  score?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  joinedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+}
+
+export type MatchPlayerUncheckedUpdateManyWithoutMatchInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  userId?: Prisma.StringFieldUpdateOperationsInput | string
+  rank?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
+  score?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  joinedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+}
+
+
+
+export type MatchPlayerSelect<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
+  id?: boolean
+  matchId?: boolean
+  userId?: boolean
+  rank?: boolean
+  score?: boolean
+  joinedAt?: boolean
+  match?: boolean | Prisma.MatchDefaultArgs<ExtArgs>
+  user?: boolean | Prisma.UserDefaultArgs<ExtArgs>
+}, ExtArgs["result"]["matchPlayer"]>
+
+export type MatchPlayerSelectCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
+  id?: boolean
+  matchId?: boolean
+  userId?: boolean
+  rank?: boolean
+  score?: boolean
+  joinedAt?: boolean
+  match?: boolean | Prisma.MatchDefaultArgs<ExtArgs>
+  user?: boolean | Prisma.UserDefaultArgs<ExtArgs>
+}, ExtArgs["result"]["matchPlayer"]>
+
+export type MatchPlayerSelectUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
+  id?: boolean
+  matchId?: boolean
+  userId?: boolean
+  rank?: boolean
+  score?: boolean
+  joinedAt?: boolean
+  match?: boolean | Prisma.MatchDefaultArgs<ExtArgs>
+  user?: boolean | Prisma.UserDefaultArgs<ExtArgs>
+}, ExtArgs["result"]["matchPlayer"]>
+
+export type MatchPlayerSelectScalar = {
+  id?: boolean
+  matchId?: boolean
+  userId?: boolean
+  rank?: boolean
+  score?: boolean
+  joinedAt?: boolean
+}
+
+export type MatchPlayerOmit<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetOmit<"id" | "matchId" | "userId" | "rank" | "score" | "joinedAt", ExtArgs["result"]["matchPlayer"]>
+export type MatchPlayerInclude<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  match?: boolean | Prisma.MatchDefaultArgs<ExtArgs>
+  user?: boolean | Prisma.UserDefaultArgs<ExtArgs>
+}
+export type MatchPlayerIncludeCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  match?: boolean | Prisma.MatchDefaultArgs<ExtArgs>
+  user?: boolean | Prisma.UserDefaultArgs<ExtArgs>
+}
+export type MatchPlayerIncludeUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  match?: boolean | Prisma.MatchDefaultArgs<ExtArgs>
+  user?: boolean | Prisma.UserDefaultArgs<ExtArgs>
+}
+
+export type $MatchPlayerPayload<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  name: "MatchPlayer"
+  objects: {
+    match: Prisma.$MatchPayload<ExtArgs>
+    user: Prisma.$UserPayload<ExtArgs>
+  }
+  scalars: runtime.Types.Extensions.GetPayloadResult<{
+    id: string
+    matchId: string
+    userId: string
+    rank: number | null
+    score: number | null
+    joinedAt: Date
+  }, ExtArgs["result"]["matchPlayer"]>
+  composites: {}
+}
+
+export type MatchPlayerGetPayload<S extends boolean | null | undefined | MatchPlayerDefaultArgs> = runtime.Types.Result.GetResult<Prisma.$MatchPlayerPayload, S>
+
+export type MatchPlayerCountArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> =
+  Omit<MatchPlayerFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
+    select?: MatchPlayerCountAggregateInputType | true
+  }
+
+export interface MatchPlayerDelegate<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> {
+  [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['MatchPlayer'], meta: { name: 'MatchPlayer' } }
+  /**
+   * Find zero or one MatchPlayer that matches the filter.
+   * @param {MatchPlayerFindUniqueArgs} args - Arguments to find a MatchPlayer
+   * @example
+   * // Get one MatchPlayer
+   * const matchPlayer = await prisma.matchPlayer.findUnique({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   */
+  findUnique<T extends MatchPlayerFindUniqueArgs>(args: Prisma.SelectSubset<T, MatchPlayerFindUniqueArgs<ExtArgs>>): Prisma.Prisma__MatchPlayerClient<runtime.Types.Result.GetResult<Prisma.$MatchPlayerPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Find one MatchPlayer that matches the filter or throw an error with `error.code='P2025'`
+   * if no matches were found.
+   * @param {MatchPlayerFindUniqueOrThrowArgs} args - Arguments to find a MatchPlayer
+   * @example
+   * // Get one MatchPlayer
+   * const matchPlayer = await prisma.matchPlayer.findUniqueOrThrow({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   */
+  findUniqueOrThrow<T extends MatchPlayerFindUniqueOrThrowArgs>(args: Prisma.SelectSubset<T, MatchPlayerFindUniqueOrThrowArgs<ExtArgs>>): Prisma.Prisma__MatchPlayerClient<runtime.Types.Result.GetResult<Prisma.$MatchPlayerPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Find the first MatchPlayer that matches the filter.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {MatchPlayerFindFirstArgs} args - Arguments to find a MatchPlayer
+   * @example
+   * // Get one MatchPlayer
+   * const matchPlayer = await prisma.matchPlayer.findFirst({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   */
+  findFirst<T extends MatchPlayerFindFirstArgs>(args?: Prisma.SelectSubset<T, MatchPlayerFindFirstArgs<ExtArgs>>): Prisma.Prisma__MatchPlayerClient<runtime.Types.Result.GetResult<Prisma.$MatchPlayerPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Find the first MatchPlayer that matches the filter or
+   * throw `PrismaKnownClientError` with `P2025` code if no matches were found.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {MatchPlayerFindFirstOrThrowArgs} args - Arguments to find a MatchPlayer
+   * @example
+   * // Get one MatchPlayer
+   * const matchPlayer = await prisma.matchPlayer.findFirstOrThrow({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   */
+  findFirstOrThrow<T extends MatchPlayerFindFirstOrThrowArgs>(args?: Prisma.SelectSubset<T, MatchPlayerFindFirstOrThrowArgs<ExtArgs>>): Prisma.Prisma__MatchPlayerClient<runtime.Types.Result.GetResult<Prisma.$MatchPlayerPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Find zero or more MatchPlayers that matches the filter.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {MatchPlayerFindManyArgs} args - Arguments to filter and select certain fields only.
+   * @example
+   * // Get all MatchPlayers
+   * const matchPlayers = await prisma.matchPlayer.findMany()
+   * 
+   * // Get first 10 MatchPlayers
+   * const matchPlayers = await prisma.matchPlayer.findMany({ take: 10 })
+   * 
+   * // Only select the `id`
+   * const matchPlayerWithIdOnly = await prisma.matchPlayer.findMany({ select: { id: true } })
+   * 
+   */
+  findMany<T extends MatchPlayerFindManyArgs>(args?: Prisma.SelectSubset<T, MatchPlayerFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$MatchPlayerPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>
+
+  /**
+   * Create a MatchPlayer.
+   * @param {MatchPlayerCreateArgs} args - Arguments to create a MatchPlayer.
+   * @example
+   * // Create one MatchPlayer
+   * const MatchPlayer = await prisma.matchPlayer.create({
+   *   data: {
+   *     // ... data to create a MatchPlayer
+   *   }
+   * })
+   * 
+   */
+  create<T extends MatchPlayerCreateArgs>(args: Prisma.SelectSubset<T, MatchPlayerCreateArgs<ExtArgs>>): Prisma.Prisma__MatchPlayerClient<runtime.Types.Result.GetResult<Prisma.$MatchPlayerPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Create many MatchPlayers.
+   * @param {MatchPlayerCreateManyArgs} args - Arguments to create many MatchPlayers.
+   * @example
+   * // Create many MatchPlayers
+   * const matchPlayer = await prisma.matchPlayer.createMany({
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   *     
+   */
+  createMany<T extends MatchPlayerCreateManyArgs>(args?: Prisma.SelectSubset<T, MatchPlayerCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>
+
+  /**
+   * Create many MatchPlayers and returns the data saved in the database.
+   * @param {MatchPlayerCreateManyAndReturnArgs} args - Arguments to create many MatchPlayers.
+   * @example
+   * // Create many MatchPlayers
+   * const matchPlayer = await prisma.matchPlayer.createManyAndReturn({
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   * 
+   * // Create many MatchPlayers and only return the `id`
+   * const matchPlayerWithIdOnly = await prisma.matchPlayer.createManyAndReturn({
+   *   select: { id: true },
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * 
+   */
+  createManyAndReturn<T extends MatchPlayerCreateManyAndReturnArgs>(args?: Prisma.SelectSubset<T, MatchPlayerCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$MatchPlayerPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>
+
+  /**
+   * Delete a MatchPlayer.
+   * @param {MatchPlayerDeleteArgs} args - Arguments to delete one MatchPlayer.
+   * @example
+   * // Delete one MatchPlayer
+   * const MatchPlayer = await prisma.matchPlayer.delete({
+   *   where: {
+   *     // ... filter to delete one MatchPlayer
+   *   }
+   * })
+   * 
+   */
+  delete<T extends MatchPlayerDeleteArgs>(args: Prisma.SelectSubset<T, MatchPlayerDeleteArgs<ExtArgs>>): Prisma.Prisma__MatchPlayerClient<runtime.Types.Result.GetResult<Prisma.$MatchPlayerPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Update one MatchPlayer.
+   * @param {MatchPlayerUpdateArgs} args - Arguments to update one MatchPlayer.
+   * @example
+   * // Update one MatchPlayer
+   * const matchPlayer = await prisma.matchPlayer.update({
+   *   where: {
+   *     // ... provide filter here
+   *   },
+   *   data: {
+   *     // ... provide data here
+   *   }
+   * })
+   * 
+   */
+  update<T extends MatchPlayerUpdateArgs>(args: Prisma.SelectSubset<T, MatchPlayerUpdateArgs<ExtArgs>>): Prisma.Prisma__MatchPlayerClient<runtime.Types.Result.GetResult<Prisma.$MatchPlayerPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Delete zero or more MatchPlayers.
+   * @param {MatchPlayerDeleteManyArgs} args - Arguments to filter MatchPlayers to delete.
+   * @example
+   * // Delete a few MatchPlayers
+   * const { count } = await prisma.matchPlayer.deleteMany({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   * 
+   */
+  deleteMany<T extends MatchPlayerDeleteManyArgs>(args?: Prisma.SelectSubset<T, MatchPlayerDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>
+
+  /**
+   * Update zero or more MatchPlayers.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {MatchPlayerUpdateManyArgs} args - Arguments to update one or more rows.
+   * @example
+   * // Update many MatchPlayers
+   * const matchPlayer = await prisma.matchPlayer.updateMany({
+   *   where: {
+   *     // ... provide filter here
+   *   },
+   *   data: {
+   *     // ... provide data here
+   *   }
+   * })
+   * 
+   */
+  updateMany<T extends MatchPlayerUpdateManyArgs>(args: Prisma.SelectSubset<T, MatchPlayerUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>
+
+  /**
+   * Update zero or more MatchPlayers and returns the data updated in the database.
+   * @param {MatchPlayerUpdateManyAndReturnArgs} args - Arguments to update many MatchPlayers.
+   * @example
+   * // Update many MatchPlayers
+   * const matchPlayer = await prisma.matchPlayer.updateManyAndReturn({
+   *   where: {
+   *     // ... provide filter here
+   *   },
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   * 
+   * // Update zero or more MatchPlayers and only return the `id`
+   * const matchPlayerWithIdOnly = await prisma.matchPlayer.updateManyAndReturn({
+   *   select: { id: true },
+   *   where: {
+   *     // ... provide filter here
+   *   },
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * 
+   */
+  updateManyAndReturn<T extends MatchPlayerUpdateManyAndReturnArgs>(args: Prisma.SelectSubset<T, MatchPlayerUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$MatchPlayerPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>
+
+  /**
+   * Create or update one MatchPlayer.
+   * @param {MatchPlayerUpsertArgs} args - Arguments to update or create a MatchPlayer.
+   * @example
+   * // Update or create a MatchPlayer
+   * const matchPlayer = await prisma.matchPlayer.upsert({
+   *   create: {
+   *     // ... data to create a MatchPlayer
+   *   },
+   *   update: {
+   *     // ... in case it already exists, update
+   *   },
+   *   where: {
+   *     // ... the filter for the MatchPlayer we want to update
+   *   }
+   * })
+   */
+  upsert<T extends MatchPlayerUpsertArgs>(args: Prisma.SelectSubset<T, MatchPlayerUpsertArgs<ExtArgs>>): Prisma.Prisma__MatchPlayerClient<runtime.Types.Result.GetResult<Prisma.$MatchPlayerPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+
+  /**
+   * Count the number of MatchPlayers.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {MatchPlayerCountArgs} args - Arguments to filter MatchPlayers to count.
+   * @example
+   * // Count the number of MatchPlayers
+   * const count = await prisma.matchPlayer.count({
+   *   where: {
+   *     // ... the filter for the MatchPlayers we want to count
+   *   }
+   * })
+  **/
+  count<T extends MatchPlayerCountArgs>(
+    args?: Prisma.Subset<T, MatchPlayerCountArgs>,
+  ): Prisma.PrismaPromise<
+    T extends runtime.Types.Utils.Record<'select', any>
+      ? T['select'] extends true
+        ? number
+        : Prisma.GetScalarType<T['select'], MatchPlayerCountAggregateOutputType>
+      : number
+  >
+
+  /**
+   * Allows you to perform aggregations operations on a MatchPlayer.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {MatchPlayerAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
+   * @example
+   * // Ordered by age ascending
+   * // Where email contains prisma.io
+   * // Limited to the 10 users
+   * const aggregations = await prisma.user.aggregate({
+   *   _avg: {
+   *     age: true,
+   *   },
+   *   where: {
+   *     email: {
+   *       contains: "prisma.io",
+   *     },
+   *   },
+   *   orderBy: {
+   *     age: "asc",
+   *   },
+   *   take: 10,
+   * })
+  **/
+  aggregate<T extends MatchPlayerAggregateArgs>(args: Prisma.Subset<T, MatchPlayerAggregateArgs>): Prisma.PrismaPromise<GetMatchPlayerAggregateType<T>>
+
+  /**
+   * Group by MatchPlayer.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {MatchPlayerGroupByArgs} args - Group by arguments.
+   * @example
+   * // Group by city, order by createdAt, get count
+   * const result = await prisma.user.groupBy({
+   *   by: ['city', 'createdAt'],
+   *   orderBy: {
+   *     createdAt: true
+   *   },
+   *   _count: {
+   *     _all: true
+   *   },
+   * })
+   * 
+  **/
+  groupBy<
+    T extends MatchPlayerGroupByArgs,
+    HasSelectOrTake extends Prisma.Or<
+      Prisma.Extends<'skip', Prisma.Keys<T>>,
+      Prisma.Extends<'take', Prisma.Keys<T>>
+    >,
+    OrderByArg extends Prisma.True extends HasSelectOrTake
+      ? { orderBy: MatchPlayerGroupByArgs['orderBy'] }
+      : { orderBy?: MatchPlayerGroupByArgs['orderBy'] },
+    OrderFields extends Prisma.ExcludeUnderscoreKeys<Prisma.Keys<Prisma.MaybeTupleToUnion<T['orderBy']>>>,
+    ByFields extends Prisma.MaybeTupleToUnion<T['by']>,
+    ByValid extends Prisma.Has<ByFields, OrderFields>,
+    HavingFields extends Prisma.GetHavingFields<T['having']>,
+    HavingValid extends Prisma.Has<ByFields, HavingFields>,
+    ByEmpty extends T['by'] extends never[] ? Prisma.True : Prisma.False,
+    InputErrors extends ByEmpty extends Prisma.True
+    ? `Error: "by" must not be empty.`
+    : HavingValid extends Prisma.False
+    ? {
+        [P in HavingFields]: P extends ByFields
+          ? never
+          : P extends string
+          ? `Error: Field "${P}" used in "having" needs to be provided in "by".`
+          : [
+              Error,
+              'Field ',
+              P,
+              ` in "having" needs to be provided in "by"`,
+            ]
+      }[HavingFields]
+    : 'take' extends Prisma.Keys<T>
+    ? 'orderBy' extends Prisma.Keys<T>
+      ? ByValid extends Prisma.True
+        ? {}
+        : {
+            [P in OrderFields]: P extends ByFields
+              ? never
+              : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
+          }[OrderFields]
+      : 'Error: If you provide "take", you also need to provide "orderBy"'
+    : 'skip' extends Prisma.Keys<T>
+    ? 'orderBy' extends Prisma.Keys<T>
+      ? ByValid extends Prisma.True
+        ? {}
+        : {
+            [P in OrderFields]: P extends ByFields
+              ? never
+              : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
+          }[OrderFields]
+      : 'Error: If you provide "skip", you also need to provide "orderBy"'
+    : ByValid extends Prisma.True
+    ? {}
+    : {
+        [P in OrderFields]: P extends ByFields
+          ? never
+          : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
+      }[OrderFields]
+  >(args: Prisma.SubsetIntersection<T, MatchPlayerGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetMatchPlayerGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
+/**
+ * Fields of the MatchPlayer model
+ */
+readonly fields: MatchPlayerFieldRefs;
+}
+
+/**
+ * The delegate class that acts as a "Promise-like" for MatchPlayer.
+ * Why is this prefixed with `Prisma__`?
+ * Because we want to prevent naming conflicts as mentioned in
+ * https://github.com/prisma/prisma-client-js/issues/707
+ */
+export interface Prisma__MatchPlayerClient<T, Null = never, ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
+  readonly [Symbol.toStringTag]: "PrismaPromise"
+  match<T extends Prisma.MatchDefaultArgs<ExtArgs> = {}>(args?: Prisma.Subset<T, Prisma.MatchDefaultArgs<ExtArgs>>): Prisma.Prisma__MatchClient<runtime.Types.Result.GetResult<Prisma.$MatchPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
+  user<T extends Prisma.UserDefaultArgs<ExtArgs> = {}>(args?: Prisma.Subset<T, Prisma.UserDefaultArgs<ExtArgs>>): Prisma.Prisma__UserClient<runtime.Types.Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
+  /**
+   * Attaches callbacks for the resolution and/or rejection of the Promise.
+   * @param onfulfilled The callback to execute when the Promise is resolved.
+   * @param onrejected The callback to execute when the Promise is rejected.
+   * @returns A Promise for the completion of which ever callback is executed.
+   */
+  then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): runtime.Types.Utils.JsPromise<TResult1 | TResult2>
+  /**
+   * Attaches a callback for only the rejection of the Promise.
+   * @param onrejected The callback to execute when the Promise is rejected.
+   * @returns A Promise for the completion of the callback.
+   */
+  catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): runtime.Types.Utils.JsPromise<T | TResult>
+  /**
+   * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
+   * resolved value cannot be modified from the callback.
+   * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
+   * @returns A Promise for the completion of the callback.
+   */
+  finally(onfinally?: (() => void) | undefined | null): runtime.Types.Utils.JsPromise<T>
+}
+
+
+
+
+/**
+ * Fields of the MatchPlayer model
+ */
+export interface MatchPlayerFieldRefs {
+  readonly id: Prisma.FieldRef<"MatchPlayer", 'String'>
+  readonly matchId: Prisma.FieldRef<"MatchPlayer", 'String'>
+  readonly userId: Prisma.FieldRef<"MatchPlayer", 'String'>
+  readonly rank: Prisma.FieldRef<"MatchPlayer", 'Int'>
+  readonly score: Prisma.FieldRef<"MatchPlayer", 'Float'>
+  readonly joinedAt: Prisma.FieldRef<"MatchPlayer", 'DateTime'>
+}
+    
+
+// Custom InputTypes
+/**
+ * MatchPlayer findUnique
+ */
+export type MatchPlayerFindUniqueArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the MatchPlayer
+   */
+  select?: Prisma.MatchPlayerSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the MatchPlayer
+   */
+  omit?: Prisma.MatchPlayerOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.MatchPlayerInclude<ExtArgs> | null
+  /**
+   * Filter, which MatchPlayer to fetch.
+   */
+  where: Prisma.MatchPlayerWhereUniqueInput
+}
+
+/**
+ * MatchPlayer findUniqueOrThrow
+ */
+export type MatchPlayerFindUniqueOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the MatchPlayer
+   */
+  select?: Prisma.MatchPlayerSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the MatchPlayer
+   */
+  omit?: Prisma.MatchPlayerOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.MatchPlayerInclude<ExtArgs> | null
+  /**
+   * Filter, which MatchPlayer to fetch.
+   */
+  where: Prisma.MatchPlayerWhereUniqueInput
+}
+
+/**
+ * MatchPlayer findFirst
+ */
+export type MatchPlayerFindFirstArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the MatchPlayer
+   */
+  select?: Prisma.MatchPlayerSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the MatchPlayer
+   */
+  omit?: Prisma.MatchPlayerOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.MatchPlayerInclude<ExtArgs> | null
+  /**
+   * Filter, which MatchPlayer to fetch.
+   */
+  where?: Prisma.MatchPlayerWhereInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+   * 
+   * Determine the order of MatchPlayers to fetch.
+   */
+  orderBy?: Prisma.MatchPlayerOrderByWithRelationInput | Prisma.MatchPlayerOrderByWithRelationInput[]
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+   * 
+   * Sets the position for searching for MatchPlayers.
+   */
+  cursor?: Prisma.MatchPlayerWhereUniqueInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Take `±n` MatchPlayers from the position of the cursor.
+   */
+  take?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Skip the first `n` MatchPlayers.
+   */
+  skip?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+   * 
+   * Filter by unique combinations of MatchPlayers.
+   */
+  distinct?: Prisma.MatchPlayerScalarFieldEnum | Prisma.MatchPlayerScalarFieldEnum[]
+}
+
+/**
+ * MatchPlayer findFirstOrThrow
+ */
+export type MatchPlayerFindFirstOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the MatchPlayer
+   */
+  select?: Prisma.MatchPlayerSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the MatchPlayer
+   */
+  omit?: Prisma.MatchPlayerOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.MatchPlayerInclude<ExtArgs> | null
+  /**
+   * Filter, which MatchPlayer to fetch.
+   */
+  where?: Prisma.MatchPlayerWhereInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+   * 
+   * Determine the order of MatchPlayers to fetch.
+   */
+  orderBy?: Prisma.MatchPlayerOrderByWithRelationInput | Prisma.MatchPlayerOrderByWithRelationInput[]
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+   * 
+   * Sets the position for searching for MatchPlayers.
+   */
+  cursor?: Prisma.MatchPlayerWhereUniqueInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Take `±n` MatchPlayers from the position of the cursor.
+   */
+  take?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Skip the first `n` MatchPlayers.
+   */
+  skip?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+   * 
+   * Filter by unique combinations of MatchPlayers.
+   */
+  distinct?: Prisma.MatchPlayerScalarFieldEnum | Prisma.MatchPlayerScalarFieldEnum[]
+}
+
+/**
+ * MatchPlayer findMany
+ */
+export type MatchPlayerFindManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the MatchPlayer
+   */
+  select?: Prisma.MatchPlayerSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the MatchPlayer
+   */
+  omit?: Prisma.MatchPlayerOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.MatchPlayerInclude<ExtArgs> | null
+  /**
+   * Filter, which MatchPlayers to fetch.
+   */
+  where?: Prisma.MatchPlayerWhereInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+   * 
+   * Determine the order of MatchPlayers to fetch.
+   */
+  orderBy?: Prisma.MatchPlayerOrderByWithRelationInput | Prisma.MatchPlayerOrderByWithRelationInput[]
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+   * 
+   * Sets the position for listing MatchPlayers.
+   */
+  cursor?: Prisma.MatchPlayerWhereUniqueInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Take `±n` MatchPlayers from the position of the cursor.
+   */
+  take?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Skip the first `n` MatchPlayers.
+   */
+  skip?: number
+  distinct?: Prisma.MatchPlayerScalarFieldEnum | Prisma.MatchPlayerScalarFieldEnum[]
+}
+
+/**
+ * MatchPlayer create
+ */
+export type MatchPlayerCreateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the MatchPlayer
+   */
+  select?: Prisma.MatchPlayerSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the MatchPlayer
+   */
+  omit?: Prisma.MatchPlayerOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.MatchPlayerInclude<ExtArgs> | null
+  /**
+   * The data needed to create a MatchPlayer.
+   */
+  data: Prisma.XOR<Prisma.MatchPlayerCreateInput, Prisma.MatchPlayerUncheckedCreateInput>
+}
+
+/**
+ * MatchPlayer createMany
+ */
+export type MatchPlayerCreateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * The data used to create many MatchPlayers.
+   */
+  data: Prisma.MatchPlayerCreateManyInput | Prisma.MatchPlayerCreateManyInput[]
+  skipDuplicates?: boolean
+}
+
+/**
+ * MatchPlayer createManyAndReturn
+ */
+export type MatchPlayerCreateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the MatchPlayer
+   */
+  select?: Prisma.MatchPlayerSelectCreateManyAndReturn<ExtArgs> | null
+  /**
+   * Omit specific fields from the MatchPlayer
+   */
+  omit?: Prisma.MatchPlayerOmit<ExtArgs> | null
+  /**
+   * The data used to create many MatchPlayers.
+   */
+  data: Prisma.MatchPlayerCreateManyInput | Prisma.MatchPlayerCreateManyInput[]
+  skipDuplicates?: boolean
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.MatchPlayerIncludeCreateManyAndReturn<ExtArgs> | null
+}
+
+/**
+ * MatchPlayer update
+ */
+export type MatchPlayerUpdateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the MatchPlayer
+   */
+  select?: Prisma.MatchPlayerSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the MatchPlayer
+   */
+  omit?: Prisma.MatchPlayerOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.MatchPlayerInclude<ExtArgs> | null
+  /**
+   * The data needed to update a MatchPlayer.
+   */
+  data: Prisma.XOR<Prisma.MatchPlayerUpdateInput, Prisma.MatchPlayerUncheckedUpdateInput>
+  /**
+   * Choose, which MatchPlayer to update.
+   */
+  where: Prisma.MatchPlayerWhereUniqueInput
+}
+
+/**
+ * MatchPlayer updateMany
+ */
+export type MatchPlayerUpdateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * The data used to update MatchPlayers.
+   */
+  data: Prisma.XOR<Prisma.MatchPlayerUpdateManyMutationInput, Prisma.MatchPlayerUncheckedUpdateManyInput>
+  /**
+   * Filter which MatchPlayers to update
+   */
+  where?: Prisma.MatchPlayerWhereInput
+  /**
+   * Limit how many MatchPlayers to update.
+   */
+  limit?: number
+}
+
+/**
+ * MatchPlayer updateManyAndReturn
+ */
+export type MatchPlayerUpdateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the MatchPlayer
+   */
+  select?: Prisma.MatchPlayerSelectUpdateManyAndReturn<ExtArgs> | null
+  /**
+   * Omit specific fields from the MatchPlayer
+   */
+  omit?: Prisma.MatchPlayerOmit<ExtArgs> | null
+  /**
+   * The data used to update MatchPlayers.
+   */
+  data: Prisma.XOR<Prisma.MatchPlayerUpdateManyMutationInput, Prisma.MatchPlayerUncheckedUpdateManyInput>
+  /**
+   * Filter which MatchPlayers to update
+   */
+  where?: Prisma.MatchPlayerWhereInput
+  /**
+   * Limit how many MatchPlayers to update.
+   */
+  limit?: number
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.MatchPlayerIncludeUpdateManyAndReturn<ExtArgs> | null
+}
+
+/**
+ * MatchPlayer upsert
+ */
+export type MatchPlayerUpsertArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the MatchPlayer
+   */
+  select?: Prisma.MatchPlayerSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the MatchPlayer
+   */
+  omit?: Prisma.MatchPlayerOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.MatchPlayerInclude<ExtArgs> | null
+  /**
+   * The filter to search for the MatchPlayer to update in case it exists.
+   */
+  where: Prisma.MatchPlayerWhereUniqueInput
+  /**
+   * In case the MatchPlayer found by the `where` argument doesn't exist, create a new MatchPlayer with this data.
+   */
+  create: Prisma.XOR<Prisma.MatchPlayerCreateInput, Prisma.MatchPlayerUncheckedCreateInput>
+  /**
+   * In case the MatchPlayer was found with the provided `where` argument, update it with this data.
+   */
+  update: Prisma.XOR<Prisma.MatchPlayerUpdateInput, Prisma.MatchPlayerUncheckedUpdateInput>
+}
+
+/**
+ * MatchPlayer delete
+ */
+export type MatchPlayerDeleteArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the MatchPlayer
+   */
+  select?: Prisma.MatchPlayerSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the MatchPlayer
+   */
+  omit?: Prisma.MatchPlayerOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.MatchPlayerInclude<ExtArgs> | null
+  /**
+   * Filter which MatchPlayer to delete.
+   */
+  where: Prisma.MatchPlayerWhereUniqueInput
+}
+
+/**
+ * MatchPlayer deleteMany
+ */
+export type MatchPlayerDeleteManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Filter which MatchPlayers to delete
+   */
+  where?: Prisma.MatchPlayerWhereInput
+  /**
+   * Limit how many MatchPlayers to delete.
+   */
+  limit?: number
+}
+
+/**
+ * MatchPlayer without action
+ */
+export type MatchPlayerDefaultArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the MatchPlayer
+   */
+  select?: Prisma.MatchPlayerSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the MatchPlayer
+   */
+  omit?: Prisma.MatchPlayerOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.MatchPlayerInclude<ExtArgs> | null
+}
diff --git a/prisma/generated/prisma/models/MatchQuestion.ts b/prisma/generated/prisma/models/MatchQuestion.ts
new file mode 100644
index 0000000..94273df
--- /dev/null
+++ b/prisma/generated/prisma/models/MatchQuestion.ts
@@ -0,0 +1,1469 @@
+
+/* !!! This is code generated by Prisma. Do not edit directly. !!! */
+/* eslint-disable */
+// biome-ignore-all lint: generated file
+// @ts-nocheck 
+/*
+ * This file exports the `MatchQuestion` model and its related types.
+ *
+ * 🟢 You can import this file directly.
+ */
+import type * as runtime from "@prisma/client/runtime/client"
+import type * as $Enums from "../enums"
+import type * as Prisma from "../internal/prismaNamespace"
+
+/**
+ * Model MatchQuestion
+ * 
+ */
+export type MatchQuestionModel = runtime.Types.Result.DefaultSelection<Prisma.$MatchQuestionPayload>
+
+export type AggregateMatchQuestion = {
+  _count: MatchQuestionCountAggregateOutputType | null
+  _avg: MatchQuestionAvgAggregateOutputType | null
+  _sum: MatchQuestionSumAggregateOutputType | null
+  _min: MatchQuestionMinAggregateOutputType | null
+  _max: MatchQuestionMaxAggregateOutputType | null
+}
+
+export type MatchQuestionAvgAggregateOutputType = {
+  order: number | null
+}
+
+export type MatchQuestionSumAggregateOutputType = {
+  order: number | null
+}
+
+export type MatchQuestionMinAggregateOutputType = {
+  id: string | null
+  matchId: string | null
+  questionId: string | null
+  order: number | null
+}
+
+export type MatchQuestionMaxAggregateOutputType = {
+  id: string | null
+  matchId: string | null
+  questionId: string | null
+  order: number | null
+}
+
+export type MatchQuestionCountAggregateOutputType = {
+  id: number
+  matchId: number
+  questionId: number
+  order: number
+  _all: number
+}
+
+
+export type MatchQuestionAvgAggregateInputType = {
+  order?: true
+}
+
+export type MatchQuestionSumAggregateInputType = {
+  order?: true
+}
+
+export type MatchQuestionMinAggregateInputType = {
+  id?: true
+  matchId?: true
+  questionId?: true
+  order?: true
+}
+
+export type MatchQuestionMaxAggregateInputType = {
+  id?: true
+  matchId?: true
+  questionId?: true
+  order?: true
+}
+
+export type MatchQuestionCountAggregateInputType = {
+  id?: true
+  matchId?: true
+  questionId?: true
+  order?: true
+  _all?: true
+}
+
+export type MatchQuestionAggregateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Filter which MatchQuestion to aggregate.
+   */
+  where?: Prisma.MatchQuestionWhereInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+   * 
+   * Determine the order of MatchQuestions to fetch.
+   */
+  orderBy?: Prisma.MatchQuestionOrderByWithRelationInput | Prisma.MatchQuestionOrderByWithRelationInput[]
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+   * 
+   * Sets the start position
+   */
+  cursor?: Prisma.MatchQuestionWhereUniqueInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Take `±n` MatchQuestions from the position of the cursor.
+   */
+  take?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Skip the first `n` MatchQuestions.
+   */
+  skip?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Count returned MatchQuestions
+  **/
+  _count?: true | MatchQuestionCountAggregateInputType
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Select which fields to average
+  **/
+  _avg?: MatchQuestionAvgAggregateInputType
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Select which fields to sum
+  **/
+  _sum?: MatchQuestionSumAggregateInputType
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Select which fields to find the minimum value
+  **/
+  _min?: MatchQuestionMinAggregateInputType
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Select which fields to find the maximum value
+  **/
+  _max?: MatchQuestionMaxAggregateInputType
+}
+
+export type GetMatchQuestionAggregateType<T extends MatchQuestionAggregateArgs> = {
+      [P in keyof T & keyof AggregateMatchQuestion]: P extends '_count' | 'count'
+    ? T[P] extends true
+      ? number
+      : Prisma.GetScalarType<T[P], AggregateMatchQuestion[P]>
+    : Prisma.GetScalarType<T[P], AggregateMatchQuestion[P]>
+}
+
+
+
+
+export type MatchQuestionGroupByArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  where?: Prisma.MatchQuestionWhereInput
+  orderBy?: Prisma.MatchQuestionOrderByWithAggregationInput | Prisma.MatchQuestionOrderByWithAggregationInput[]
+  by: Prisma.MatchQuestionScalarFieldEnum[] | Prisma.MatchQuestionScalarFieldEnum
+  having?: Prisma.MatchQuestionScalarWhereWithAggregatesInput
+  take?: number
+  skip?: number
+  _count?: MatchQuestionCountAggregateInputType | true
+  _avg?: MatchQuestionAvgAggregateInputType
+  _sum?: MatchQuestionSumAggregateInputType
+  _min?: MatchQuestionMinAggregateInputType
+  _max?: MatchQuestionMaxAggregateInputType
+}
+
+export type MatchQuestionGroupByOutputType = {
+  id: string
+  matchId: string
+  questionId: string
+  order: number
+  _count: MatchQuestionCountAggregateOutputType | null
+  _avg: MatchQuestionAvgAggregateOutputType | null
+  _sum: MatchQuestionSumAggregateOutputType | null
+  _min: MatchQuestionMinAggregateOutputType | null
+  _max: MatchQuestionMaxAggregateOutputType | null
+}
+
+type GetMatchQuestionGroupByPayload<T extends MatchQuestionGroupByArgs> = Prisma.PrismaPromise<
+  Array<
+    Prisma.PickEnumerable<MatchQuestionGroupByOutputType, T['by']> &
+      {
+        [P in ((keyof T) & (keyof MatchQuestionGroupByOutputType))]: P extends '_count'
+          ? T[P] extends boolean
+            ? number
+            : Prisma.GetScalarType<T[P], MatchQuestionGroupByOutputType[P]>
+          : Prisma.GetScalarType<T[P], MatchQuestionGroupByOutputType[P]>
+      }
+    >
+  >
+
+
+
+export type MatchQuestionWhereInput = {
+  AND?: Prisma.MatchQuestionWhereInput | Prisma.MatchQuestionWhereInput[]
+  OR?: Prisma.MatchQuestionWhereInput[]
+  NOT?: Prisma.MatchQuestionWhereInput | Prisma.MatchQuestionWhereInput[]
+  id?: Prisma.StringFilter<"MatchQuestion"> | string
+  matchId?: Prisma.StringFilter<"MatchQuestion"> | string
+  questionId?: Prisma.StringFilter<"MatchQuestion"> | string
+  order?: Prisma.IntFilter<"MatchQuestion"> | number
+  match?: Prisma.XOR<Prisma.MatchScalarRelationFilter, Prisma.MatchWhereInput>
+  question?: Prisma.XOR<Prisma.QuestionScalarRelationFilter, Prisma.QuestionWhereInput>
+}
+
+export type MatchQuestionOrderByWithRelationInput = {
+  id?: Prisma.SortOrder
+  matchId?: Prisma.SortOrder
+  questionId?: Prisma.SortOrder
+  order?: Prisma.SortOrder
+  match?: Prisma.MatchOrderByWithRelationInput
+  question?: Prisma.QuestionOrderByWithRelationInput
+}
+
+export type MatchQuestionWhereUniqueInput = Prisma.AtLeast<{
+  id?: string
+  matchId_questionId?: Prisma.MatchQuestionMatchIdQuestionIdCompoundUniqueInput
+  AND?: Prisma.MatchQuestionWhereInput | Prisma.MatchQuestionWhereInput[]
+  OR?: Prisma.MatchQuestionWhereInput[]
+  NOT?: Prisma.MatchQuestionWhereInput | Prisma.MatchQuestionWhereInput[]
+  matchId?: Prisma.StringFilter<"MatchQuestion"> | string
+  questionId?: Prisma.StringFilter<"MatchQuestion"> | string
+  order?: Prisma.IntFilter<"MatchQuestion"> | number
+  match?: Prisma.XOR<Prisma.MatchScalarRelationFilter, Prisma.MatchWhereInput>
+  question?: Prisma.XOR<Prisma.QuestionScalarRelationFilter, Prisma.QuestionWhereInput>
+}, "id" | "matchId_questionId">
+
+export type MatchQuestionOrderByWithAggregationInput = {
+  id?: Prisma.SortOrder
+  matchId?: Prisma.SortOrder
+  questionId?: Prisma.SortOrder
+  order?: Prisma.SortOrder
+  _count?: Prisma.MatchQuestionCountOrderByAggregateInput
+  _avg?: Prisma.MatchQuestionAvgOrderByAggregateInput
+  _max?: Prisma.MatchQuestionMaxOrderByAggregateInput
+  _min?: Prisma.MatchQuestionMinOrderByAggregateInput
+  _sum?: Prisma.MatchQuestionSumOrderByAggregateInput
+}
+
+export type MatchQuestionScalarWhereWithAggregatesInput = {
+  AND?: Prisma.MatchQuestionScalarWhereWithAggregatesInput | Prisma.MatchQuestionScalarWhereWithAggregatesInput[]
+  OR?: Prisma.MatchQuestionScalarWhereWithAggregatesInput[]
+  NOT?: Prisma.MatchQuestionScalarWhereWithAggregatesInput | Prisma.MatchQuestionScalarWhereWithAggregatesInput[]
+  id?: Prisma.StringWithAggregatesFilter<"MatchQuestion"> | string
+  matchId?: Prisma.StringWithAggregatesFilter<"MatchQuestion"> | string
+  questionId?: Prisma.StringWithAggregatesFilter<"MatchQuestion"> | string
+  order?: Prisma.IntWithAggregatesFilter<"MatchQuestion"> | number
+}
+
+export type MatchQuestionCreateInput = {
+  id?: string
+  order?: number
+  match: Prisma.MatchCreateNestedOneWithoutQuestionsInput
+  question: Prisma.QuestionCreateNestedOneWithoutMatchQuestionsInput
+}
+
+export type MatchQuestionUncheckedCreateInput = {
+  id?: string
+  matchId: string
+  questionId: string
+  order?: number
+}
+
+export type MatchQuestionUpdateInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  order?: Prisma.IntFieldUpdateOperationsInput | number
+  match?: Prisma.MatchUpdateOneRequiredWithoutQuestionsNestedInput
+  question?: Prisma.QuestionUpdateOneRequiredWithoutMatchQuestionsNestedInput
+}
+
+export type MatchQuestionUncheckedUpdateInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  matchId?: Prisma.StringFieldUpdateOperationsInput | string
+  questionId?: Prisma.StringFieldUpdateOperationsInput | string
+  order?: Prisma.IntFieldUpdateOperationsInput | number
+}
+
+export type MatchQuestionCreateManyInput = {
+  id?: string
+  matchId: string
+  questionId: string
+  order?: number
+}
+
+export type MatchQuestionUpdateManyMutationInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  order?: Prisma.IntFieldUpdateOperationsInput | number
+}
+
+export type MatchQuestionUncheckedUpdateManyInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  matchId?: Prisma.StringFieldUpdateOperationsInput | string
+  questionId?: Prisma.StringFieldUpdateOperationsInput | string
+  order?: Prisma.IntFieldUpdateOperationsInput | number
+}
+
+export type MatchQuestionListRelationFilter = {
+  every?: Prisma.MatchQuestionWhereInput
+  some?: Prisma.MatchQuestionWhereInput
+  none?: Prisma.MatchQuestionWhereInput
+}
+
+export type MatchQuestionOrderByRelationAggregateInput = {
+  _count?: Prisma.SortOrder
+}
+
+export type MatchQuestionMatchIdQuestionIdCompoundUniqueInput = {
+  matchId: string
+  questionId: string
+}
+
+export type MatchQuestionCountOrderByAggregateInput = {
+  id?: Prisma.SortOrder
+  matchId?: Prisma.SortOrder
+  questionId?: Prisma.SortOrder
+  order?: Prisma.SortOrder
+}
+
+export type MatchQuestionAvgOrderByAggregateInput = {
+  order?: Prisma.SortOrder
+}
+
+export type MatchQuestionMaxOrderByAggregateInput = {
+  id?: Prisma.SortOrder
+  matchId?: Prisma.SortOrder
+  questionId?: Prisma.SortOrder
+  order?: Prisma.SortOrder
+}
+
+export type MatchQuestionMinOrderByAggregateInput = {
+  id?: Prisma.SortOrder
+  matchId?: Prisma.SortOrder
+  questionId?: Prisma.SortOrder
+  order?: Prisma.SortOrder
+}
+
+export type MatchQuestionSumOrderByAggregateInput = {
+  order?: Prisma.SortOrder
+}
+
+export type MatchQuestionCreateNestedManyWithoutMatchInput = {
+  create?: Prisma.XOR<Prisma.MatchQuestionCreateWithoutMatchInput, Prisma.MatchQuestionUncheckedCreateWithoutMatchInput> | Prisma.MatchQuestionCreateWithoutMatchInput[] | Prisma.MatchQuestionUncheckedCreateWithoutMatchInput[]
+  connectOrCreate?: Prisma.MatchQuestionCreateOrConnectWithoutMatchInput | Prisma.MatchQuestionCreateOrConnectWithoutMatchInput[]
+  createMany?: Prisma.MatchQuestionCreateManyMatchInputEnvelope
+  connect?: Prisma.MatchQuestionWhereUniqueInput | Prisma.MatchQuestionWhereUniqueInput[]
+}
+
+export type MatchQuestionUncheckedCreateNestedManyWithoutMatchInput = {
+  create?: Prisma.XOR<Prisma.MatchQuestionCreateWithoutMatchInput, Prisma.MatchQuestionUncheckedCreateWithoutMatchInput> | Prisma.MatchQuestionCreateWithoutMatchInput[] | Prisma.MatchQuestionUncheckedCreateWithoutMatchInput[]
+  connectOrCreate?: Prisma.MatchQuestionCreateOrConnectWithoutMatchInput | Prisma.MatchQuestionCreateOrConnectWithoutMatchInput[]
+  createMany?: Prisma.MatchQuestionCreateManyMatchInputEnvelope
+  connect?: Prisma.MatchQuestionWhereUniqueInput | Prisma.MatchQuestionWhereUniqueInput[]
+}
+
+export type MatchQuestionUpdateManyWithoutMatchNestedInput = {
+  create?: Prisma.XOR<Prisma.MatchQuestionCreateWithoutMatchInput, Prisma.MatchQuestionUncheckedCreateWithoutMatchInput> | Prisma.MatchQuestionCreateWithoutMatchInput[] | Prisma.MatchQuestionUncheckedCreateWithoutMatchInput[]
+  connectOrCreate?: Prisma.MatchQuestionCreateOrConnectWithoutMatchInput | Prisma.MatchQuestionCreateOrConnectWithoutMatchInput[]
+  upsert?: Prisma.MatchQuestionUpsertWithWhereUniqueWithoutMatchInput | Prisma.MatchQuestionUpsertWithWhereUniqueWithoutMatchInput[]
+  createMany?: Prisma.MatchQuestionCreateManyMatchInputEnvelope
+  set?: Prisma.MatchQuestionWhereUniqueInput | Prisma.MatchQuestionWhereUniqueInput[]
+  disconnect?: Prisma.MatchQuestionWhereUniqueInput | Prisma.MatchQuestionWhereUniqueInput[]
+  delete?: Prisma.MatchQuestionWhereUniqueInput | Prisma.MatchQuestionWhereUniqueInput[]
+  connect?: Prisma.MatchQuestionWhereUniqueInput | Prisma.MatchQuestionWhereUniqueInput[]
+  update?: Prisma.MatchQuestionUpdateWithWhereUniqueWithoutMatchInput | Prisma.MatchQuestionUpdateWithWhereUniqueWithoutMatchInput[]
+  updateMany?: Prisma.MatchQuestionUpdateManyWithWhereWithoutMatchInput | Prisma.MatchQuestionUpdateManyWithWhereWithoutMatchInput[]
+  deleteMany?: Prisma.MatchQuestionScalarWhereInput | Prisma.MatchQuestionScalarWhereInput[]
+}
+
+export type MatchQuestionUncheckedUpdateManyWithoutMatchNestedInput = {
+  create?: Prisma.XOR<Prisma.MatchQuestionCreateWithoutMatchInput, Prisma.MatchQuestionUncheckedCreateWithoutMatchInput> | Prisma.MatchQuestionCreateWithoutMatchInput[] | Prisma.MatchQuestionUncheckedCreateWithoutMatchInput[]
+  connectOrCreate?: Prisma.MatchQuestionCreateOrConnectWithoutMatchInput | Prisma.MatchQuestionCreateOrConnectWithoutMatchInput[]
+  upsert?: Prisma.MatchQuestionUpsertWithWhereUniqueWithoutMatchInput | Prisma.MatchQuestionUpsertWithWhereUniqueWithoutMatchInput[]
+  createMany?: Prisma.MatchQuestionCreateManyMatchInputEnvelope
+  set?: Prisma.MatchQuestionWhereUniqueInput | Prisma.MatchQuestionWhereUniqueInput[]
+  disconnect?: Prisma.MatchQuestionWhereUniqueInput | Prisma.MatchQuestionWhereUniqueInput[]
+  delete?: Prisma.MatchQuestionWhereUniqueInput | Prisma.MatchQuestionWhereUniqueInput[]
+  connect?: Prisma.MatchQuestionWhereUniqueInput | Prisma.MatchQuestionWhereUniqueInput[]
+  update?: Prisma.MatchQuestionUpdateWithWhereUniqueWithoutMatchInput | Prisma.MatchQuestionUpdateWithWhereUniqueWithoutMatchInput[]
+  updateMany?: Prisma.MatchQuestionUpdateManyWithWhereWithoutMatchInput | Prisma.MatchQuestionUpdateManyWithWhereWithoutMatchInput[]
+  deleteMany?: Prisma.MatchQuestionScalarWhereInput | Prisma.MatchQuestionScalarWhereInput[]
+}
+
+export type MatchQuestionCreateNestedManyWithoutQuestionInput = {
+  create?: Prisma.XOR<Prisma.MatchQuestionCreateWithoutQuestionInput, Prisma.MatchQuestionUncheckedCreateWithoutQuestionInput> | Prisma.MatchQuestionCreateWithoutQuestionInput[] | Prisma.MatchQuestionUncheckedCreateWithoutQuestionInput[]
+  connectOrCreate?: Prisma.MatchQuestionCreateOrConnectWithoutQuestionInput | Prisma.MatchQuestionCreateOrConnectWithoutQuestionInput[]
+  createMany?: Prisma.MatchQuestionCreateManyQuestionInputEnvelope
+  connect?: Prisma.MatchQuestionWhereUniqueInput | Prisma.MatchQuestionWhereUniqueInput[]
+}
+
+export type MatchQuestionUncheckedCreateNestedManyWithoutQuestionInput = {
+  create?: Prisma.XOR<Prisma.MatchQuestionCreateWithoutQuestionInput, Prisma.MatchQuestionUncheckedCreateWithoutQuestionInput> | Prisma.MatchQuestionCreateWithoutQuestionInput[] | Prisma.MatchQuestionUncheckedCreateWithoutQuestionInput[]
+  connectOrCreate?: Prisma.MatchQuestionCreateOrConnectWithoutQuestionInput | Prisma.MatchQuestionCreateOrConnectWithoutQuestionInput[]
+  createMany?: Prisma.MatchQuestionCreateManyQuestionInputEnvelope
+  connect?: Prisma.MatchQuestionWhereUniqueInput | Prisma.MatchQuestionWhereUniqueInput[]
+}
+
+export type MatchQuestionUpdateManyWithoutQuestionNestedInput = {
+  create?: Prisma.XOR<Prisma.MatchQuestionCreateWithoutQuestionInput, Prisma.MatchQuestionUncheckedCreateWithoutQuestionInput> | Prisma.MatchQuestionCreateWithoutQuestionInput[] | Prisma.MatchQuestionUncheckedCreateWithoutQuestionInput[]
+  connectOrCreate?: Prisma.MatchQuestionCreateOrConnectWithoutQuestionInput | Prisma.MatchQuestionCreateOrConnectWithoutQuestionInput[]
+  upsert?: Prisma.MatchQuestionUpsertWithWhereUniqueWithoutQuestionInput | Prisma.MatchQuestionUpsertWithWhereUniqueWithoutQuestionInput[]
+  createMany?: Prisma.MatchQuestionCreateManyQuestionInputEnvelope
+  set?: Prisma.MatchQuestionWhereUniqueInput | Prisma.MatchQuestionWhereUniqueInput[]
+  disconnect?: Prisma.MatchQuestionWhereUniqueInput | Prisma.MatchQuestionWhereUniqueInput[]
+  delete?: Prisma.MatchQuestionWhereUniqueInput | Prisma.MatchQuestionWhereUniqueInput[]
+  connect?: Prisma.MatchQuestionWhereUniqueInput | Prisma.MatchQuestionWhereUniqueInput[]
+  update?: Prisma.MatchQuestionUpdateWithWhereUniqueWithoutQuestionInput | Prisma.MatchQuestionUpdateWithWhereUniqueWithoutQuestionInput[]
+  updateMany?: Prisma.MatchQuestionUpdateManyWithWhereWithoutQuestionInput | Prisma.MatchQuestionUpdateManyWithWhereWithoutQuestionInput[]
+  deleteMany?: Prisma.MatchQuestionScalarWhereInput | Prisma.MatchQuestionScalarWhereInput[]
+}
+
+export type MatchQuestionUncheckedUpdateManyWithoutQuestionNestedInput = {
+  create?: Prisma.XOR<Prisma.MatchQuestionCreateWithoutQuestionInput, Prisma.MatchQuestionUncheckedCreateWithoutQuestionInput> | Prisma.MatchQuestionCreateWithoutQuestionInput[] | Prisma.MatchQuestionUncheckedCreateWithoutQuestionInput[]
+  connectOrCreate?: Prisma.MatchQuestionCreateOrConnectWithoutQuestionInput | Prisma.MatchQuestionCreateOrConnectWithoutQuestionInput[]
+  upsert?: Prisma.MatchQuestionUpsertWithWhereUniqueWithoutQuestionInput | Prisma.MatchQuestionUpsertWithWhereUniqueWithoutQuestionInput[]
+  createMany?: Prisma.MatchQuestionCreateManyQuestionInputEnvelope
+  set?: Prisma.MatchQuestionWhereUniqueInput | Prisma.MatchQuestionWhereUniqueInput[]
+  disconnect?: Prisma.MatchQuestionWhereUniqueInput | Prisma.MatchQuestionWhereUniqueInput[]
+  delete?: Prisma.MatchQuestionWhereUniqueInput | Prisma.MatchQuestionWhereUniqueInput[]
+  connect?: Prisma.MatchQuestionWhereUniqueInput | Prisma.MatchQuestionWhereUniqueInput[]
+  update?: Prisma.MatchQuestionUpdateWithWhereUniqueWithoutQuestionInput | Prisma.MatchQuestionUpdateWithWhereUniqueWithoutQuestionInput[]
+  updateMany?: Prisma.MatchQuestionUpdateManyWithWhereWithoutQuestionInput | Prisma.MatchQuestionUpdateManyWithWhereWithoutQuestionInput[]
+  deleteMany?: Prisma.MatchQuestionScalarWhereInput | Prisma.MatchQuestionScalarWhereInput[]
+}
+
+export type MatchQuestionCreateWithoutMatchInput = {
+  id?: string
+  order?: number
+  question: Prisma.QuestionCreateNestedOneWithoutMatchQuestionsInput
+}
+
+export type MatchQuestionUncheckedCreateWithoutMatchInput = {
+  id?: string
+  questionId: string
+  order?: number
+}
+
+export type MatchQuestionCreateOrConnectWithoutMatchInput = {
+  where: Prisma.MatchQuestionWhereUniqueInput
+  create: Prisma.XOR<Prisma.MatchQuestionCreateWithoutMatchInput, Prisma.MatchQuestionUncheckedCreateWithoutMatchInput>
+}
+
+export type MatchQuestionCreateManyMatchInputEnvelope = {
+  data: Prisma.MatchQuestionCreateManyMatchInput | Prisma.MatchQuestionCreateManyMatchInput[]
+  skipDuplicates?: boolean
+}
+
+export type MatchQuestionUpsertWithWhereUniqueWithoutMatchInput = {
+  where: Prisma.MatchQuestionWhereUniqueInput
+  update: Prisma.XOR<Prisma.MatchQuestionUpdateWithoutMatchInput, Prisma.MatchQuestionUncheckedUpdateWithoutMatchInput>
+  create: Prisma.XOR<Prisma.MatchQuestionCreateWithoutMatchInput, Prisma.MatchQuestionUncheckedCreateWithoutMatchInput>
+}
+
+export type MatchQuestionUpdateWithWhereUniqueWithoutMatchInput = {
+  where: Prisma.MatchQuestionWhereUniqueInput
+  data: Prisma.XOR<Prisma.MatchQuestionUpdateWithoutMatchInput, Prisma.MatchQuestionUncheckedUpdateWithoutMatchInput>
+}
+
+export type MatchQuestionUpdateManyWithWhereWithoutMatchInput = {
+  where: Prisma.MatchQuestionScalarWhereInput
+  data: Prisma.XOR<Prisma.MatchQuestionUpdateManyMutationInput, Prisma.MatchQuestionUncheckedUpdateManyWithoutMatchInput>
+}
+
+export type MatchQuestionScalarWhereInput = {
+  AND?: Prisma.MatchQuestionScalarWhereInput | Prisma.MatchQuestionScalarWhereInput[]
+  OR?: Prisma.MatchQuestionScalarWhereInput[]
+  NOT?: Prisma.MatchQuestionScalarWhereInput | Prisma.MatchQuestionScalarWhereInput[]
+  id?: Prisma.StringFilter<"MatchQuestion"> | string
+  matchId?: Prisma.StringFilter<"MatchQuestion"> | string
+  questionId?: Prisma.StringFilter<"MatchQuestion"> | string
+  order?: Prisma.IntFilter<"MatchQuestion"> | number
+}
+
+export type MatchQuestionCreateWithoutQuestionInput = {
+  id?: string
+  order?: number
+  match: Prisma.MatchCreateNestedOneWithoutQuestionsInput
+}
+
+export type MatchQuestionUncheckedCreateWithoutQuestionInput = {
+  id?: string
+  matchId: string
+  order?: number
+}
+
+export type MatchQuestionCreateOrConnectWithoutQuestionInput = {
+  where: Prisma.MatchQuestionWhereUniqueInput
+  create: Prisma.XOR<Prisma.MatchQuestionCreateWithoutQuestionInput, Prisma.MatchQuestionUncheckedCreateWithoutQuestionInput>
+}
+
+export type MatchQuestionCreateManyQuestionInputEnvelope = {
+  data: Prisma.MatchQuestionCreateManyQuestionInput | Prisma.MatchQuestionCreateManyQuestionInput[]
+  skipDuplicates?: boolean
+}
+
+export type MatchQuestionUpsertWithWhereUniqueWithoutQuestionInput = {
+  where: Prisma.MatchQuestionWhereUniqueInput
+  update: Prisma.XOR<Prisma.MatchQuestionUpdateWithoutQuestionInput, Prisma.MatchQuestionUncheckedUpdateWithoutQuestionInput>
+  create: Prisma.XOR<Prisma.MatchQuestionCreateWithoutQuestionInput, Prisma.MatchQuestionUncheckedCreateWithoutQuestionInput>
+}
+
+export type MatchQuestionUpdateWithWhereUniqueWithoutQuestionInput = {
+  where: Prisma.MatchQuestionWhereUniqueInput
+  data: Prisma.XOR<Prisma.MatchQuestionUpdateWithoutQuestionInput, Prisma.MatchQuestionUncheckedUpdateWithoutQuestionInput>
+}
+
+export type MatchQuestionUpdateManyWithWhereWithoutQuestionInput = {
+  where: Prisma.MatchQuestionScalarWhereInput
+  data: Prisma.XOR<Prisma.MatchQuestionUpdateManyMutationInput, Prisma.MatchQuestionUncheckedUpdateManyWithoutQuestionInput>
+}
+
+export type MatchQuestionCreateManyMatchInput = {
+  id?: string
+  questionId: string
+  order?: number
+}
+
+export type MatchQuestionUpdateWithoutMatchInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  order?: Prisma.IntFieldUpdateOperationsInput | number
+  question?: Prisma.QuestionUpdateOneRequiredWithoutMatchQuestionsNestedInput
+}
+
+export type MatchQuestionUncheckedUpdateWithoutMatchInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  questionId?: Prisma.StringFieldUpdateOperationsInput | string
+  order?: Prisma.IntFieldUpdateOperationsInput | number
+}
+
+export type MatchQuestionUncheckedUpdateManyWithoutMatchInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  questionId?: Prisma.StringFieldUpdateOperationsInput | string
+  order?: Prisma.IntFieldUpdateOperationsInput | number
+}
+
+export type MatchQuestionCreateManyQuestionInput = {
+  id?: string
+  matchId: string
+  order?: number
+}
+
+export type MatchQuestionUpdateWithoutQuestionInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  order?: Prisma.IntFieldUpdateOperationsInput | number
+  match?: Prisma.MatchUpdateOneRequiredWithoutQuestionsNestedInput
+}
+
+export type MatchQuestionUncheckedUpdateWithoutQuestionInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  matchId?: Prisma.StringFieldUpdateOperationsInput | string
+  order?: Prisma.IntFieldUpdateOperationsInput | number
+}
+
+export type MatchQuestionUncheckedUpdateManyWithoutQuestionInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  matchId?: Prisma.StringFieldUpdateOperationsInput | string
+  order?: Prisma.IntFieldUpdateOperationsInput | number
+}
+
+
+
+export type MatchQuestionSelect<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
+  id?: boolean
+  matchId?: boolean
+  questionId?: boolean
+  order?: boolean
+  match?: boolean | Prisma.MatchDefaultArgs<ExtArgs>
+  question?: boolean | Prisma.QuestionDefaultArgs<ExtArgs>
+}, ExtArgs["result"]["matchQuestion"]>
+
+export type MatchQuestionSelectCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
+  id?: boolean
+  matchId?: boolean
+  questionId?: boolean
+  order?: boolean
+  match?: boolean | Prisma.MatchDefaultArgs<ExtArgs>
+  question?: boolean | Prisma.QuestionDefaultArgs<ExtArgs>
+}, ExtArgs["result"]["matchQuestion"]>
+
+export type MatchQuestionSelectUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
+  id?: boolean
+  matchId?: boolean
+  questionId?: boolean
+  order?: boolean
+  match?: boolean | Prisma.MatchDefaultArgs<ExtArgs>
+  question?: boolean | Prisma.QuestionDefaultArgs<ExtArgs>
+}, ExtArgs["result"]["matchQuestion"]>
+
+export type MatchQuestionSelectScalar = {
+  id?: boolean
+  matchId?: boolean
+  questionId?: boolean
+  order?: boolean
+}
+
+export type MatchQuestionOmit<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetOmit<"id" | "matchId" | "questionId" | "order", ExtArgs["result"]["matchQuestion"]>
+export type MatchQuestionInclude<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  match?: boolean | Prisma.MatchDefaultArgs<ExtArgs>
+  question?: boolean | Prisma.QuestionDefaultArgs<ExtArgs>
+}
+export type MatchQuestionIncludeCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  match?: boolean | Prisma.MatchDefaultArgs<ExtArgs>
+  question?: boolean | Prisma.QuestionDefaultArgs<ExtArgs>
+}
+export type MatchQuestionIncludeUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  match?: boolean | Prisma.MatchDefaultArgs<ExtArgs>
+  question?: boolean | Prisma.QuestionDefaultArgs<ExtArgs>
+}
+
+export type $MatchQuestionPayload<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  name: "MatchQuestion"
+  objects: {
+    match: Prisma.$MatchPayload<ExtArgs>
+    question: Prisma.$QuestionPayload<ExtArgs>
+  }
+  scalars: runtime.Types.Extensions.GetPayloadResult<{
+    id: string
+    matchId: string
+    questionId: string
+    order: number
+  }, ExtArgs["result"]["matchQuestion"]>
+  composites: {}
+}
+
+export type MatchQuestionGetPayload<S extends boolean | null | undefined | MatchQuestionDefaultArgs> = runtime.Types.Result.GetResult<Prisma.$MatchQuestionPayload, S>
+
+export type MatchQuestionCountArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> =
+  Omit<MatchQuestionFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
+    select?: MatchQuestionCountAggregateInputType | true
+  }
+
+export interface MatchQuestionDelegate<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> {
+  [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['MatchQuestion'], meta: { name: 'MatchQuestion' } }
+  /**
+   * Find zero or one MatchQuestion that matches the filter.
+   * @param {MatchQuestionFindUniqueArgs} args - Arguments to find a MatchQuestion
+   * @example
+   * // Get one MatchQuestion
+   * const matchQuestion = await prisma.matchQuestion.findUnique({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   */
+  findUnique<T extends MatchQuestionFindUniqueArgs>(args: Prisma.SelectSubset<T, MatchQuestionFindUniqueArgs<ExtArgs>>): Prisma.Prisma__MatchQuestionClient<runtime.Types.Result.GetResult<Prisma.$MatchQuestionPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Find one MatchQuestion that matches the filter or throw an error with `error.code='P2025'`
+   * if no matches were found.
+   * @param {MatchQuestionFindUniqueOrThrowArgs} args - Arguments to find a MatchQuestion
+   * @example
+   * // Get one MatchQuestion
+   * const matchQuestion = await prisma.matchQuestion.findUniqueOrThrow({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   */
+  findUniqueOrThrow<T extends MatchQuestionFindUniqueOrThrowArgs>(args: Prisma.SelectSubset<T, MatchQuestionFindUniqueOrThrowArgs<ExtArgs>>): Prisma.Prisma__MatchQuestionClient<runtime.Types.Result.GetResult<Prisma.$MatchQuestionPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Find the first MatchQuestion that matches the filter.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {MatchQuestionFindFirstArgs} args - Arguments to find a MatchQuestion
+   * @example
+   * // Get one MatchQuestion
+   * const matchQuestion = await prisma.matchQuestion.findFirst({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   */
+  findFirst<T extends MatchQuestionFindFirstArgs>(args?: Prisma.SelectSubset<T, MatchQuestionFindFirstArgs<ExtArgs>>): Prisma.Prisma__MatchQuestionClient<runtime.Types.Result.GetResult<Prisma.$MatchQuestionPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Find the first MatchQuestion that matches the filter or
+   * throw `PrismaKnownClientError` with `P2025` code if no matches were found.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {MatchQuestionFindFirstOrThrowArgs} args - Arguments to find a MatchQuestion
+   * @example
+   * // Get one MatchQuestion
+   * const matchQuestion = await prisma.matchQuestion.findFirstOrThrow({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   */
+  findFirstOrThrow<T extends MatchQuestionFindFirstOrThrowArgs>(args?: Prisma.SelectSubset<T, MatchQuestionFindFirstOrThrowArgs<ExtArgs>>): Prisma.Prisma__MatchQuestionClient<runtime.Types.Result.GetResult<Prisma.$MatchQuestionPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Find zero or more MatchQuestions that matches the filter.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {MatchQuestionFindManyArgs} args - Arguments to filter and select certain fields only.
+   * @example
+   * // Get all MatchQuestions
+   * const matchQuestions = await prisma.matchQuestion.findMany()
+   * 
+   * // Get first 10 MatchQuestions
+   * const matchQuestions = await prisma.matchQuestion.findMany({ take: 10 })
+   * 
+   * // Only select the `id`
+   * const matchQuestionWithIdOnly = await prisma.matchQuestion.findMany({ select: { id: true } })
+   * 
+   */
+  findMany<T extends MatchQuestionFindManyArgs>(args?: Prisma.SelectSubset<T, MatchQuestionFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$MatchQuestionPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>
+
+  /**
+   * Create a MatchQuestion.
+   * @param {MatchQuestionCreateArgs} args - Arguments to create a MatchQuestion.
+   * @example
+   * // Create one MatchQuestion
+   * const MatchQuestion = await prisma.matchQuestion.create({
+   *   data: {
+   *     // ... data to create a MatchQuestion
+   *   }
+   * })
+   * 
+   */
+  create<T extends MatchQuestionCreateArgs>(args: Prisma.SelectSubset<T, MatchQuestionCreateArgs<ExtArgs>>): Prisma.Prisma__MatchQuestionClient<runtime.Types.Result.GetResult<Prisma.$MatchQuestionPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Create many MatchQuestions.
+   * @param {MatchQuestionCreateManyArgs} args - Arguments to create many MatchQuestions.
+   * @example
+   * // Create many MatchQuestions
+   * const matchQuestion = await prisma.matchQuestion.createMany({
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   *     
+   */
+  createMany<T extends MatchQuestionCreateManyArgs>(args?: Prisma.SelectSubset<T, MatchQuestionCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>
+
+  /**
+   * Create many MatchQuestions and returns the data saved in the database.
+   * @param {MatchQuestionCreateManyAndReturnArgs} args - Arguments to create many MatchQuestions.
+   * @example
+   * // Create many MatchQuestions
+   * const matchQuestion = await prisma.matchQuestion.createManyAndReturn({
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   * 
+   * // Create many MatchQuestions and only return the `id`
+   * const matchQuestionWithIdOnly = await prisma.matchQuestion.createManyAndReturn({
+   *   select: { id: true },
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * 
+   */
+  createManyAndReturn<T extends MatchQuestionCreateManyAndReturnArgs>(args?: Prisma.SelectSubset<T, MatchQuestionCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$MatchQuestionPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>
+
+  /**
+   * Delete a MatchQuestion.
+   * @param {MatchQuestionDeleteArgs} args - Arguments to delete one MatchQuestion.
+   * @example
+   * // Delete one MatchQuestion
+   * const MatchQuestion = await prisma.matchQuestion.delete({
+   *   where: {
+   *     // ... filter to delete one MatchQuestion
+   *   }
+   * })
+   * 
+   */
+  delete<T extends MatchQuestionDeleteArgs>(args: Prisma.SelectSubset<T, MatchQuestionDeleteArgs<ExtArgs>>): Prisma.Prisma__MatchQuestionClient<runtime.Types.Result.GetResult<Prisma.$MatchQuestionPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Update one MatchQuestion.
+   * @param {MatchQuestionUpdateArgs} args - Arguments to update one MatchQuestion.
+   * @example
+   * // Update one MatchQuestion
+   * const matchQuestion = await prisma.matchQuestion.update({
+   *   where: {
+   *     // ... provide filter here
+   *   },
+   *   data: {
+   *     // ... provide data here
+   *   }
+   * })
+   * 
+   */
+  update<T extends MatchQuestionUpdateArgs>(args: Prisma.SelectSubset<T, MatchQuestionUpdateArgs<ExtArgs>>): Prisma.Prisma__MatchQuestionClient<runtime.Types.Result.GetResult<Prisma.$MatchQuestionPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Delete zero or more MatchQuestions.
+   * @param {MatchQuestionDeleteManyArgs} args - Arguments to filter MatchQuestions to delete.
+   * @example
+   * // Delete a few MatchQuestions
+   * const { count } = await prisma.matchQuestion.deleteMany({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   * 
+   */
+  deleteMany<T extends MatchQuestionDeleteManyArgs>(args?: Prisma.SelectSubset<T, MatchQuestionDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>
+
+  /**
+   * Update zero or more MatchQuestions.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {MatchQuestionUpdateManyArgs} args - Arguments to update one or more rows.
+   * @example
+   * // Update many MatchQuestions
+   * const matchQuestion = await prisma.matchQuestion.updateMany({
+   *   where: {
+   *     // ... provide filter here
+   *   },
+   *   data: {
+   *     // ... provide data here
+   *   }
+   * })
+   * 
+   */
+  updateMany<T extends MatchQuestionUpdateManyArgs>(args: Prisma.SelectSubset<T, MatchQuestionUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>
+
+  /**
+   * Update zero or more MatchQuestions and returns the data updated in the database.
+   * @param {MatchQuestionUpdateManyAndReturnArgs} args - Arguments to update many MatchQuestions.
+   * @example
+   * // Update many MatchQuestions
+   * const matchQuestion = await prisma.matchQuestion.updateManyAndReturn({
+   *   where: {
+   *     // ... provide filter here
+   *   },
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   * 
+   * // Update zero or more MatchQuestions and only return the `id`
+   * const matchQuestionWithIdOnly = await prisma.matchQuestion.updateManyAndReturn({
+   *   select: { id: true },
+   *   where: {
+   *     // ... provide filter here
+   *   },
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * 
+   */
+  updateManyAndReturn<T extends MatchQuestionUpdateManyAndReturnArgs>(args: Prisma.SelectSubset<T, MatchQuestionUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$MatchQuestionPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>
+
+  /**
+   * Create or update one MatchQuestion.
+   * @param {MatchQuestionUpsertArgs} args - Arguments to update or create a MatchQuestion.
+   * @example
+   * // Update or create a MatchQuestion
+   * const matchQuestion = await prisma.matchQuestion.upsert({
+   *   create: {
+   *     // ... data to create a MatchQuestion
+   *   },
+   *   update: {
+   *     // ... in case it already exists, update
+   *   },
+   *   where: {
+   *     // ... the filter for the MatchQuestion we want to update
+   *   }
+   * })
+   */
+  upsert<T extends MatchQuestionUpsertArgs>(args: Prisma.SelectSubset<T, MatchQuestionUpsertArgs<ExtArgs>>): Prisma.Prisma__MatchQuestionClient<runtime.Types.Result.GetResult<Prisma.$MatchQuestionPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+
+  /**
+   * Count the number of MatchQuestions.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {MatchQuestionCountArgs} args - Arguments to filter MatchQuestions to count.
+   * @example
+   * // Count the number of MatchQuestions
+   * const count = await prisma.matchQuestion.count({
+   *   where: {
+   *     // ... the filter for the MatchQuestions we want to count
+   *   }
+   * })
+  **/
+  count<T extends MatchQuestionCountArgs>(
+    args?: Prisma.Subset<T, MatchQuestionCountArgs>,
+  ): Prisma.PrismaPromise<
+    T extends runtime.Types.Utils.Record<'select', any>
+      ? T['select'] extends true
+        ? number
+        : Prisma.GetScalarType<T['select'], MatchQuestionCountAggregateOutputType>
+      : number
+  >
+
+  /**
+   * Allows you to perform aggregations operations on a MatchQuestion.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {MatchQuestionAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
+   * @example
+   * // Ordered by age ascending
+   * // Where email contains prisma.io
+   * // Limited to the 10 users
+   * const aggregations = await prisma.user.aggregate({
+   *   _avg: {
+   *     age: true,
+   *   },
+   *   where: {
+   *     email: {
+   *       contains: "prisma.io",
+   *     },
+   *   },
+   *   orderBy: {
+   *     age: "asc",
+   *   },
+   *   take: 10,
+   * })
+  **/
+  aggregate<T extends MatchQuestionAggregateArgs>(args: Prisma.Subset<T, MatchQuestionAggregateArgs>): Prisma.PrismaPromise<GetMatchQuestionAggregateType<T>>
+
+  /**
+   * Group by MatchQuestion.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {MatchQuestionGroupByArgs} args - Group by arguments.
+   * @example
+   * // Group by city, order by createdAt, get count
+   * const result = await prisma.user.groupBy({
+   *   by: ['city', 'createdAt'],
+   *   orderBy: {
+   *     createdAt: true
+   *   },
+   *   _count: {
+   *     _all: true
+   *   },
+   * })
+   * 
+  **/
+  groupBy<
+    T extends MatchQuestionGroupByArgs,
+    HasSelectOrTake extends Prisma.Or<
+      Prisma.Extends<'skip', Prisma.Keys<T>>,
+      Prisma.Extends<'take', Prisma.Keys<T>>
+    >,
+    OrderByArg extends Prisma.True extends HasSelectOrTake
+      ? { orderBy: MatchQuestionGroupByArgs['orderBy'] }
+      : { orderBy?: MatchQuestionGroupByArgs['orderBy'] },
+    OrderFields extends Prisma.ExcludeUnderscoreKeys<Prisma.Keys<Prisma.MaybeTupleToUnion<T['orderBy']>>>,
+    ByFields extends Prisma.MaybeTupleToUnion<T['by']>,
+    ByValid extends Prisma.Has<ByFields, OrderFields>,
+    HavingFields extends Prisma.GetHavingFields<T['having']>,
+    HavingValid extends Prisma.Has<ByFields, HavingFields>,
+    ByEmpty extends T['by'] extends never[] ? Prisma.True : Prisma.False,
+    InputErrors extends ByEmpty extends Prisma.True
+    ? `Error: "by" must not be empty.`
+    : HavingValid extends Prisma.False
+    ? {
+        [P in HavingFields]: P extends ByFields
+          ? never
+          : P extends string
+          ? `Error: Field "${P}" used in "having" needs to be provided in "by".`
+          : [
+              Error,
+              'Field ',
+              P,
+              ` in "having" needs to be provided in "by"`,
+            ]
+      }[HavingFields]
+    : 'take' extends Prisma.Keys<T>
+    ? 'orderBy' extends Prisma.Keys<T>
+      ? ByValid extends Prisma.True
+        ? {}
+        : {
+            [P in OrderFields]: P extends ByFields
+              ? never
+              : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
+          }[OrderFields]
+      : 'Error: If you provide "take", you also need to provide "orderBy"'
+    : 'skip' extends Prisma.Keys<T>
+    ? 'orderBy' extends Prisma.Keys<T>
+      ? ByValid extends Prisma.True
+        ? {}
+        : {
+            [P in OrderFields]: P extends ByFields
+              ? never
+              : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
+          }[OrderFields]
+      : 'Error: If you provide "skip", you also need to provide "orderBy"'
+    : ByValid extends Prisma.True
+    ? {}
+    : {
+        [P in OrderFields]: P extends ByFields
+          ? never
+          : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
+      }[OrderFields]
+  >(args: Prisma.SubsetIntersection<T, MatchQuestionGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetMatchQuestionGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
+/**
+ * Fields of the MatchQuestion model
+ */
+readonly fields: MatchQuestionFieldRefs;
+}
+
+/**
+ * The delegate class that acts as a "Promise-like" for MatchQuestion.
+ * Why is this prefixed with `Prisma__`?
+ * Because we want to prevent naming conflicts as mentioned in
+ * https://github.com/prisma/prisma-client-js/issues/707
+ */
+export interface Prisma__MatchQuestionClient<T, Null = never, ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
+  readonly [Symbol.toStringTag]: "PrismaPromise"
+  match<T extends Prisma.MatchDefaultArgs<ExtArgs> = {}>(args?: Prisma.Subset<T, Prisma.MatchDefaultArgs<ExtArgs>>): Prisma.Prisma__MatchClient<runtime.Types.Result.GetResult<Prisma.$MatchPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
+  question<T extends Prisma.QuestionDefaultArgs<ExtArgs> = {}>(args?: Prisma.Subset<T, Prisma.QuestionDefaultArgs<ExtArgs>>): Prisma.Prisma__QuestionClient<runtime.Types.Result.GetResult<Prisma.$QuestionPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
+  /**
+   * Attaches callbacks for the resolution and/or rejection of the Promise.
+   * @param onfulfilled The callback to execute when the Promise is resolved.
+   * @param onrejected The callback to execute when the Promise is rejected.
+   * @returns A Promise for the completion of which ever callback is executed.
+   */
+  then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): runtime.Types.Utils.JsPromise<TResult1 | TResult2>
+  /**
+   * Attaches a callback for only the rejection of the Promise.
+   * @param onrejected The callback to execute when the Promise is rejected.
+   * @returns A Promise for the completion of the callback.
+   */
+  catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): runtime.Types.Utils.JsPromise<T | TResult>
+  /**
+   * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
+   * resolved value cannot be modified from the callback.
+   * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
+   * @returns A Promise for the completion of the callback.
+   */
+  finally(onfinally?: (() => void) | undefined | null): runtime.Types.Utils.JsPromise<T>
+}
+
+
+
+
+/**
+ * Fields of the MatchQuestion model
+ */
+export interface MatchQuestionFieldRefs {
+  readonly id: Prisma.FieldRef<"MatchQuestion", 'String'>
+  readonly matchId: Prisma.FieldRef<"MatchQuestion", 'String'>
+  readonly questionId: Prisma.FieldRef<"MatchQuestion", 'String'>
+  readonly order: Prisma.FieldRef<"MatchQuestion", 'Int'>
+}
+    
+
+// Custom InputTypes
+/**
+ * MatchQuestion findUnique
+ */
+export type MatchQuestionFindUniqueArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the MatchQuestion
+   */
+  select?: Prisma.MatchQuestionSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the MatchQuestion
+   */
+  omit?: Prisma.MatchQuestionOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.MatchQuestionInclude<ExtArgs> | null
+  /**
+   * Filter, which MatchQuestion to fetch.
+   */
+  where: Prisma.MatchQuestionWhereUniqueInput
+}
+
+/**
+ * MatchQuestion findUniqueOrThrow
+ */
+export type MatchQuestionFindUniqueOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the MatchQuestion
+   */
+  select?: Prisma.MatchQuestionSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the MatchQuestion
+   */
+  omit?: Prisma.MatchQuestionOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.MatchQuestionInclude<ExtArgs> | null
+  /**
+   * Filter, which MatchQuestion to fetch.
+   */
+  where: Prisma.MatchQuestionWhereUniqueInput
+}
+
+/**
+ * MatchQuestion findFirst
+ */
+export type MatchQuestionFindFirstArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the MatchQuestion
+   */
+  select?: Prisma.MatchQuestionSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the MatchQuestion
+   */
+  omit?: Prisma.MatchQuestionOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.MatchQuestionInclude<ExtArgs> | null
+  /**
+   * Filter, which MatchQuestion to fetch.
+   */
+  where?: Prisma.MatchQuestionWhereInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+   * 
+   * Determine the order of MatchQuestions to fetch.
+   */
+  orderBy?: Prisma.MatchQuestionOrderByWithRelationInput | Prisma.MatchQuestionOrderByWithRelationInput[]
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+   * 
+   * Sets the position for searching for MatchQuestions.
+   */
+  cursor?: Prisma.MatchQuestionWhereUniqueInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Take `±n` MatchQuestions from the position of the cursor.
+   */
+  take?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Skip the first `n` MatchQuestions.
+   */
+  skip?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+   * 
+   * Filter by unique combinations of MatchQuestions.
+   */
+  distinct?: Prisma.MatchQuestionScalarFieldEnum | Prisma.MatchQuestionScalarFieldEnum[]
+}
+
+/**
+ * MatchQuestion findFirstOrThrow
+ */
+export type MatchQuestionFindFirstOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the MatchQuestion
+   */
+  select?: Prisma.MatchQuestionSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the MatchQuestion
+   */
+  omit?: Prisma.MatchQuestionOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.MatchQuestionInclude<ExtArgs> | null
+  /**
+   * Filter, which MatchQuestion to fetch.
+   */
+  where?: Prisma.MatchQuestionWhereInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+   * 
+   * Determine the order of MatchQuestions to fetch.
+   */
+  orderBy?: Prisma.MatchQuestionOrderByWithRelationInput | Prisma.MatchQuestionOrderByWithRelationInput[]
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+   * 
+   * Sets the position for searching for MatchQuestions.
+   */
+  cursor?: Prisma.MatchQuestionWhereUniqueInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Take `±n` MatchQuestions from the position of the cursor.
+   */
+  take?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Skip the first `n` MatchQuestions.
+   */
+  skip?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+   * 
+   * Filter by unique combinations of MatchQuestions.
+   */
+  distinct?: Prisma.MatchQuestionScalarFieldEnum | Prisma.MatchQuestionScalarFieldEnum[]
+}
+
+/**
+ * MatchQuestion findMany
+ */
+export type MatchQuestionFindManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the MatchQuestion
+   */
+  select?: Prisma.MatchQuestionSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the MatchQuestion
+   */
+  omit?: Prisma.MatchQuestionOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.MatchQuestionInclude<ExtArgs> | null
+  /**
+   * Filter, which MatchQuestions to fetch.
+   */
+  where?: Prisma.MatchQuestionWhereInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+   * 
+   * Determine the order of MatchQuestions to fetch.
+   */
+  orderBy?: Prisma.MatchQuestionOrderByWithRelationInput | Prisma.MatchQuestionOrderByWithRelationInput[]
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+   * 
+   * Sets the position for listing MatchQuestions.
+   */
+  cursor?: Prisma.MatchQuestionWhereUniqueInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Take `±n` MatchQuestions from the position of the cursor.
+   */
+  take?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Skip the first `n` MatchQuestions.
+   */
+  skip?: number
+  distinct?: Prisma.MatchQuestionScalarFieldEnum | Prisma.MatchQuestionScalarFieldEnum[]
+}
+
+/**
+ * MatchQuestion create
+ */
+export type MatchQuestionCreateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the MatchQuestion
+   */
+  select?: Prisma.MatchQuestionSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the MatchQuestion
+   */
+  omit?: Prisma.MatchQuestionOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.MatchQuestionInclude<ExtArgs> | null
+  /**
+   * The data needed to create a MatchQuestion.
+   */
+  data: Prisma.XOR<Prisma.MatchQuestionCreateInput, Prisma.MatchQuestionUncheckedCreateInput>
+}
+
+/**
+ * MatchQuestion createMany
+ */
+export type MatchQuestionCreateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * The data used to create many MatchQuestions.
+   */
+  data: Prisma.MatchQuestionCreateManyInput | Prisma.MatchQuestionCreateManyInput[]
+  skipDuplicates?: boolean
+}
+
+/**
+ * MatchQuestion createManyAndReturn
+ */
+export type MatchQuestionCreateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the MatchQuestion
+   */
+  select?: Prisma.MatchQuestionSelectCreateManyAndReturn<ExtArgs> | null
+  /**
+   * Omit specific fields from the MatchQuestion
+   */
+  omit?: Prisma.MatchQuestionOmit<ExtArgs> | null
+  /**
+   * The data used to create many MatchQuestions.
+   */
+  data: Prisma.MatchQuestionCreateManyInput | Prisma.MatchQuestionCreateManyInput[]
+  skipDuplicates?: boolean
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.MatchQuestionIncludeCreateManyAndReturn<ExtArgs> | null
+}
+
+/**
+ * MatchQuestion update
+ */
+export type MatchQuestionUpdateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the MatchQuestion
+   */
+  select?: Prisma.MatchQuestionSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the MatchQuestion
+   */
+  omit?: Prisma.MatchQuestionOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.MatchQuestionInclude<ExtArgs> | null
+  /**
+   * The data needed to update a MatchQuestion.
+   */
+  data: Prisma.XOR<Prisma.MatchQuestionUpdateInput, Prisma.MatchQuestionUncheckedUpdateInput>
+  /**
+   * Choose, which MatchQuestion to update.
+   */
+  where: Prisma.MatchQuestionWhereUniqueInput
+}
+
+/**
+ * MatchQuestion updateMany
+ */
+export type MatchQuestionUpdateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * The data used to update MatchQuestions.
+   */
+  data: Prisma.XOR<Prisma.MatchQuestionUpdateManyMutationInput, Prisma.MatchQuestionUncheckedUpdateManyInput>
+  /**
+   * Filter which MatchQuestions to update
+   */
+  where?: Prisma.MatchQuestionWhereInput
+  /**
+   * Limit how many MatchQuestions to update.
+   */
+  limit?: number
+}
+
+/**
+ * MatchQuestion updateManyAndReturn
+ */
+export type MatchQuestionUpdateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the MatchQuestion
+   */
+  select?: Prisma.MatchQuestionSelectUpdateManyAndReturn<ExtArgs> | null
+  /**
+   * Omit specific fields from the MatchQuestion
+   */
+  omit?: Prisma.MatchQuestionOmit<ExtArgs> | null
+  /**
+   * The data used to update MatchQuestions.
+   */
+  data: Prisma.XOR<Prisma.MatchQuestionUpdateManyMutationInput, Prisma.MatchQuestionUncheckedUpdateManyInput>
+  /**
+   * Filter which MatchQuestions to update
+   */
+  where?: Prisma.MatchQuestionWhereInput
+  /**
+   * Limit how many MatchQuestions to update.
+   */
+  limit?: number
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.MatchQuestionIncludeUpdateManyAndReturn<ExtArgs> | null
+}
+
+/**
+ * MatchQuestion upsert
+ */
+export type MatchQuestionUpsertArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the MatchQuestion
+   */
+  select?: Prisma.MatchQuestionSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the MatchQuestion
+   */
+  omit?: Prisma.MatchQuestionOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.MatchQuestionInclude<ExtArgs> | null
+  /**
+   * The filter to search for the MatchQuestion to update in case it exists.
+   */
+  where: Prisma.MatchQuestionWhereUniqueInput
+  /**
+   * In case the MatchQuestion found by the `where` argument doesn't exist, create a new MatchQuestion with this data.
+   */
+  create: Prisma.XOR<Prisma.MatchQuestionCreateInput, Prisma.MatchQuestionUncheckedCreateInput>
+  /**
+   * In case the MatchQuestion was found with the provided `where` argument, update it with this data.
+   */
+  update: Prisma.XOR<Prisma.MatchQuestionUpdateInput, Prisma.MatchQuestionUncheckedUpdateInput>
+}
+
+/**
+ * MatchQuestion delete
+ */
+export type MatchQuestionDeleteArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the MatchQuestion
+   */
+  select?: Prisma.MatchQuestionSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the MatchQuestion
+   */
+  omit?: Prisma.MatchQuestionOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.MatchQuestionInclude<ExtArgs> | null
+  /**
+   * Filter which MatchQuestion to delete.
+   */
+  where: Prisma.MatchQuestionWhereUniqueInput
+}
+
+/**
+ * MatchQuestion deleteMany
+ */
+export type MatchQuestionDeleteManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Filter which MatchQuestions to delete
+   */
+  where?: Prisma.MatchQuestionWhereInput
+  /**
+   * Limit how many MatchQuestions to delete.
+   */
+  limit?: number
+}
+
+/**
+ * MatchQuestion without action
+ */
+export type MatchQuestionDefaultArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the MatchQuestion
+   */
+  select?: Prisma.MatchQuestionSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the MatchQuestion
+   */
+  omit?: Prisma.MatchQuestionOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.MatchQuestionInclude<ExtArgs> | null
+}
diff --git a/prisma/generated/prisma/models/Question.ts b/prisma/generated/prisma/models/Question.ts
new file mode 100644
index 0000000..7c6aa64
--- /dev/null
+++ b/prisma/generated/prisma/models/Question.ts
@@ -0,0 +1,1650 @@
+
+/* !!! This is code generated by Prisma. Do not edit directly. !!! */
+/* eslint-disable */
+// biome-ignore-all lint: generated file
+// @ts-nocheck 
+/*
+ * This file exports the `Question` model and its related types.
+ *
+ * 🟢 You can import this file directly.
+ */
+import type * as runtime from "@prisma/client/runtime/client"
+import type * as $Enums from "../enums"
+import type * as Prisma from "../internal/prismaNamespace"
+
+/**
+ * Model Question
+ * 
+ */
+export type QuestionModel = runtime.Types.Result.DefaultSelection<Prisma.$QuestionPayload>
+
+export type AggregateQuestion = {
+  _count: QuestionCountAggregateOutputType | null
+  _min: QuestionMinAggregateOutputType | null
+  _max: QuestionMaxAggregateOutputType | null
+}
+
+export type QuestionMinAggregateOutputType = {
+  id: string | null
+  title: string | null
+  description: string | null
+  difficulty: $Enums.Difficulty | null
+  mode: $Enums.GameMode | null
+  brokenCode: string | null
+  brokenLanguage: string | null
+  expectedOutput: string | null
+  createdAt: Date | null
+  updatedAt: Date | null
+}
+
+export type QuestionMaxAggregateOutputType = {
+  id: string | null
+  title: string | null
+  description: string | null
+  difficulty: $Enums.Difficulty | null
+  mode: $Enums.GameMode | null
+  brokenCode: string | null
+  brokenLanguage: string | null
+  expectedOutput: string | null
+  createdAt: Date | null
+  updatedAt: Date | null
+}
+
+export type QuestionCountAggregateOutputType = {
+  id: number
+  title: number
+  description: number
+  difficulty: number
+  mode: number
+  brokenCode: number
+  brokenLanguage: number
+  expectedOutput: number
+  testCases: number
+  createdAt: number
+  updatedAt: number
+  _all: number
+}
+
+
+export type QuestionMinAggregateInputType = {
+  id?: true
+  title?: true
+  description?: true
+  difficulty?: true
+  mode?: true
+  brokenCode?: true
+  brokenLanguage?: true
+  expectedOutput?: true
+  createdAt?: true
+  updatedAt?: true
+}
+
+export type QuestionMaxAggregateInputType = {
+  id?: true
+  title?: true
+  description?: true
+  difficulty?: true
+  mode?: true
+  brokenCode?: true
+  brokenLanguage?: true
+  expectedOutput?: true
+  createdAt?: true
+  updatedAt?: true
+}
+
+export type QuestionCountAggregateInputType = {
+  id?: true
+  title?: true
+  description?: true
+  difficulty?: true
+  mode?: true
+  brokenCode?: true
+  brokenLanguage?: true
+  expectedOutput?: true
+  testCases?: true
+  createdAt?: true
+  updatedAt?: true
+  _all?: true
+}
+
+export type QuestionAggregateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Filter which Question to aggregate.
+   */
+  where?: Prisma.QuestionWhereInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+   * 
+   * Determine the order of Questions to fetch.
+   */
+  orderBy?: Prisma.QuestionOrderByWithRelationInput | Prisma.QuestionOrderByWithRelationInput[]
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+   * 
+   * Sets the start position
+   */
+  cursor?: Prisma.QuestionWhereUniqueInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Take `±n` Questions from the position of the cursor.
+   */
+  take?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Skip the first `n` Questions.
+   */
+  skip?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Count returned Questions
+  **/
+  _count?: true | QuestionCountAggregateInputType
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Select which fields to find the minimum value
+  **/
+  _min?: QuestionMinAggregateInputType
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Select which fields to find the maximum value
+  **/
+  _max?: QuestionMaxAggregateInputType
+}
+
+export type GetQuestionAggregateType<T extends QuestionAggregateArgs> = {
+      [P in keyof T & keyof AggregateQuestion]: P extends '_count' | 'count'
+    ? T[P] extends true
+      ? number
+      : Prisma.GetScalarType<T[P], AggregateQuestion[P]>
+    : Prisma.GetScalarType<T[P], AggregateQuestion[P]>
+}
+
+
+
+
+export type QuestionGroupByArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  where?: Prisma.QuestionWhereInput
+  orderBy?: Prisma.QuestionOrderByWithAggregationInput | Prisma.QuestionOrderByWithAggregationInput[]
+  by: Prisma.QuestionScalarFieldEnum[] | Prisma.QuestionScalarFieldEnum
+  having?: Prisma.QuestionScalarWhereWithAggregatesInput
+  take?: number
+  skip?: number
+  _count?: QuestionCountAggregateInputType | true
+  _min?: QuestionMinAggregateInputType
+  _max?: QuestionMaxAggregateInputType
+}
+
+export type QuestionGroupByOutputType = {
+  id: string
+  title: string
+  description: string
+  difficulty: $Enums.Difficulty
+  mode: $Enums.GameMode
+  brokenCode: string | null
+  brokenLanguage: string | null
+  expectedOutput: string | null
+  testCases: runtime.JsonValue | null
+  createdAt: Date
+  updatedAt: Date
+  _count: QuestionCountAggregateOutputType | null
+  _min: QuestionMinAggregateOutputType | null
+  _max: QuestionMaxAggregateOutputType | null
+}
+
+type GetQuestionGroupByPayload<T extends QuestionGroupByArgs> = Prisma.PrismaPromise<
+  Array<
+    Prisma.PickEnumerable<QuestionGroupByOutputType, T['by']> &
+      {
+        [P in ((keyof T) & (keyof QuestionGroupByOutputType))]: P extends '_count'
+          ? T[P] extends boolean
+            ? number
+            : Prisma.GetScalarType<T[P], QuestionGroupByOutputType[P]>
+          : Prisma.GetScalarType<T[P], QuestionGroupByOutputType[P]>
+      }
+    >
+  >
+
+
+
+export type QuestionWhereInput = {
+  AND?: Prisma.QuestionWhereInput | Prisma.QuestionWhereInput[]
+  OR?: Prisma.QuestionWhereInput[]
+  NOT?: Prisma.QuestionWhereInput | Prisma.QuestionWhereInput[]
+  id?: Prisma.StringFilter<"Question"> | string
+  title?: Prisma.StringFilter<"Question"> | string
+  description?: Prisma.StringFilter<"Question"> | string
+  difficulty?: Prisma.EnumDifficultyFilter<"Question"> | $Enums.Difficulty
+  mode?: Prisma.EnumGameModeFilter<"Question"> | $Enums.GameMode
+  brokenCode?: Prisma.StringNullableFilter<"Question"> | string | null
+  brokenLanguage?: Prisma.StringNullableFilter<"Question"> | string | null
+  expectedOutput?: Prisma.StringNullableFilter<"Question"> | string | null
+  testCases?: Prisma.JsonNullableFilter<"Question">
+  createdAt?: Prisma.DateTimeFilter<"Question"> | Date | string
+  updatedAt?: Prisma.DateTimeFilter<"Question"> | Date | string
+  matchQuestions?: Prisma.MatchQuestionListRelationFilter
+  submissions?: Prisma.SubmissionListRelationFilter
+}
+
+export type QuestionOrderByWithRelationInput = {
+  id?: Prisma.SortOrder
+  title?: Prisma.SortOrder
+  description?: Prisma.SortOrder
+  difficulty?: Prisma.SortOrder
+  mode?: Prisma.SortOrder
+  brokenCode?: Prisma.SortOrderInput | Prisma.SortOrder
+  brokenLanguage?: Prisma.SortOrderInput | Prisma.SortOrder
+  expectedOutput?: Prisma.SortOrderInput | Prisma.SortOrder
+  testCases?: Prisma.SortOrderInput | Prisma.SortOrder
+  createdAt?: Prisma.SortOrder
+  updatedAt?: Prisma.SortOrder
+  matchQuestions?: Prisma.MatchQuestionOrderByRelationAggregateInput
+  submissions?: Prisma.SubmissionOrderByRelationAggregateInput
+}
+
+export type QuestionWhereUniqueInput = Prisma.AtLeast<{
+  id?: string
+  AND?: Prisma.QuestionWhereInput | Prisma.QuestionWhereInput[]
+  OR?: Prisma.QuestionWhereInput[]
+  NOT?: Prisma.QuestionWhereInput | Prisma.QuestionWhereInput[]
+  title?: Prisma.StringFilter<"Question"> | string
+  description?: Prisma.StringFilter<"Question"> | string
+  difficulty?: Prisma.EnumDifficultyFilter<"Question"> | $Enums.Difficulty
+  mode?: Prisma.EnumGameModeFilter<"Question"> | $Enums.GameMode
+  brokenCode?: Prisma.StringNullableFilter<"Question"> | string | null
+  brokenLanguage?: Prisma.StringNullableFilter<"Question"> | string | null
+  expectedOutput?: Prisma.StringNullableFilter<"Question"> | string | null
+  testCases?: Prisma.JsonNullableFilter<"Question">
+  createdAt?: Prisma.DateTimeFilter<"Question"> | Date | string
+  updatedAt?: Prisma.DateTimeFilter<"Question"> | Date | string
+  matchQuestions?: Prisma.MatchQuestionListRelationFilter
+  submissions?: Prisma.SubmissionListRelationFilter
+}, "id">
+
+export type QuestionOrderByWithAggregationInput = {
+  id?: Prisma.SortOrder
+  title?: Prisma.SortOrder
+  description?: Prisma.SortOrder
+  difficulty?: Prisma.SortOrder
+  mode?: Prisma.SortOrder
+  brokenCode?: Prisma.SortOrderInput | Prisma.SortOrder
+  brokenLanguage?: Prisma.SortOrderInput | Prisma.SortOrder
+  expectedOutput?: Prisma.SortOrderInput | Prisma.SortOrder
+  testCases?: Prisma.SortOrderInput | Prisma.SortOrder
+  createdAt?: Prisma.SortOrder
+  updatedAt?: Prisma.SortOrder
+  _count?: Prisma.QuestionCountOrderByAggregateInput
+  _max?: Prisma.QuestionMaxOrderByAggregateInput
+  _min?: Prisma.QuestionMinOrderByAggregateInput
+}
+
+export type QuestionScalarWhereWithAggregatesInput = {
+  AND?: Prisma.QuestionScalarWhereWithAggregatesInput | Prisma.QuestionScalarWhereWithAggregatesInput[]
+  OR?: Prisma.QuestionScalarWhereWithAggregatesInput[]
+  NOT?: Prisma.QuestionScalarWhereWithAggregatesInput | Prisma.QuestionScalarWhereWithAggregatesInput[]
+  id?: Prisma.StringWithAggregatesFilter<"Question"> | string
+  title?: Prisma.StringWithAggregatesFilter<"Question"> | string
+  description?: Prisma.StringWithAggregatesFilter<"Question"> | string
+  difficulty?: Prisma.EnumDifficultyWithAggregatesFilter<"Question"> | $Enums.Difficulty
+  mode?: Prisma.EnumGameModeWithAggregatesFilter<"Question"> | $Enums.GameMode
+  brokenCode?: Prisma.StringNullableWithAggregatesFilter<"Question"> | string | null
+  brokenLanguage?: Prisma.StringNullableWithAggregatesFilter<"Question"> | string | null
+  expectedOutput?: Prisma.StringNullableWithAggregatesFilter<"Question"> | string | null
+  testCases?: Prisma.JsonNullableWithAggregatesFilter<"Question">
+  createdAt?: Prisma.DateTimeWithAggregatesFilter<"Question"> | Date | string
+  updatedAt?: Prisma.DateTimeWithAggregatesFilter<"Question"> | Date | string
+}
+
+export type QuestionCreateInput = {
+  id?: string
+  title: string
+  description: string
+  difficulty?: $Enums.Difficulty
+  mode?: $Enums.GameMode
+  brokenCode?: string | null
+  brokenLanguage?: string | null
+  expectedOutput?: string | null
+  testCases?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
+  createdAt?: Date | string
+  updatedAt?: Date | string
+  matchQuestions?: Prisma.MatchQuestionCreateNestedManyWithoutQuestionInput
+  submissions?: Prisma.SubmissionCreateNestedManyWithoutQuestionInput
+}
+
+export type QuestionUncheckedCreateInput = {
+  id?: string
+  title: string
+  description: string
+  difficulty?: $Enums.Difficulty
+  mode?: $Enums.GameMode
+  brokenCode?: string | null
+  brokenLanguage?: string | null
+  expectedOutput?: string | null
+  testCases?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
+  createdAt?: Date | string
+  updatedAt?: Date | string
+  matchQuestions?: Prisma.MatchQuestionUncheckedCreateNestedManyWithoutQuestionInput
+  submissions?: Prisma.SubmissionUncheckedCreateNestedManyWithoutQuestionInput
+}
+
+export type QuestionUpdateInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  title?: Prisma.StringFieldUpdateOperationsInput | string
+  description?: Prisma.StringFieldUpdateOperationsInput | string
+  difficulty?: Prisma.EnumDifficultyFieldUpdateOperationsInput | $Enums.Difficulty
+  mode?: Prisma.EnumGameModeFieldUpdateOperationsInput | $Enums.GameMode
+  brokenCode?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  brokenLanguage?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  expectedOutput?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  testCases?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  matchQuestions?: Prisma.MatchQuestionUpdateManyWithoutQuestionNestedInput
+  submissions?: Prisma.SubmissionUpdateManyWithoutQuestionNestedInput
+}
+
+export type QuestionUncheckedUpdateInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  title?: Prisma.StringFieldUpdateOperationsInput | string
+  description?: Prisma.StringFieldUpdateOperationsInput | string
+  difficulty?: Prisma.EnumDifficultyFieldUpdateOperationsInput | $Enums.Difficulty
+  mode?: Prisma.EnumGameModeFieldUpdateOperationsInput | $Enums.GameMode
+  brokenCode?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  brokenLanguage?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  expectedOutput?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  testCases?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  matchQuestions?: Prisma.MatchQuestionUncheckedUpdateManyWithoutQuestionNestedInput
+  submissions?: Prisma.SubmissionUncheckedUpdateManyWithoutQuestionNestedInput
+}
+
+export type QuestionCreateManyInput = {
+  id?: string
+  title: string
+  description: string
+  difficulty?: $Enums.Difficulty
+  mode?: $Enums.GameMode
+  brokenCode?: string | null
+  brokenLanguage?: string | null
+  expectedOutput?: string | null
+  testCases?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
+  createdAt?: Date | string
+  updatedAt?: Date | string
+}
+
+export type QuestionUpdateManyMutationInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  title?: Prisma.StringFieldUpdateOperationsInput | string
+  description?: Prisma.StringFieldUpdateOperationsInput | string
+  difficulty?: Prisma.EnumDifficultyFieldUpdateOperationsInput | $Enums.Difficulty
+  mode?: Prisma.EnumGameModeFieldUpdateOperationsInput | $Enums.GameMode
+  brokenCode?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  brokenLanguage?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  expectedOutput?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  testCases?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+}
+
+export type QuestionUncheckedUpdateManyInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  title?: Prisma.StringFieldUpdateOperationsInput | string
+  description?: Prisma.StringFieldUpdateOperationsInput | string
+  difficulty?: Prisma.EnumDifficultyFieldUpdateOperationsInput | $Enums.Difficulty
+  mode?: Prisma.EnumGameModeFieldUpdateOperationsInput | $Enums.GameMode
+  brokenCode?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  brokenLanguage?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  expectedOutput?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  testCases?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+}
+
+export type QuestionCountOrderByAggregateInput = {
+  id?: Prisma.SortOrder
+  title?: Prisma.SortOrder
+  description?: Prisma.SortOrder
+  difficulty?: Prisma.SortOrder
+  mode?: Prisma.SortOrder
+  brokenCode?: Prisma.SortOrder
+  brokenLanguage?: Prisma.SortOrder
+  expectedOutput?: Prisma.SortOrder
+  testCases?: Prisma.SortOrder
+  createdAt?: Prisma.SortOrder
+  updatedAt?: Prisma.SortOrder
+}
+
+export type QuestionMaxOrderByAggregateInput = {
+  id?: Prisma.SortOrder
+  title?: Prisma.SortOrder
+  description?: Prisma.SortOrder
+  difficulty?: Prisma.SortOrder
+  mode?: Prisma.SortOrder
+  brokenCode?: Prisma.SortOrder
+  brokenLanguage?: Prisma.SortOrder
+  expectedOutput?: Prisma.SortOrder
+  createdAt?: Prisma.SortOrder
+  updatedAt?: Prisma.SortOrder
+}
+
+export type QuestionMinOrderByAggregateInput = {
+  id?: Prisma.SortOrder
+  title?: Prisma.SortOrder
+  description?: Prisma.SortOrder
+  difficulty?: Prisma.SortOrder
+  mode?: Prisma.SortOrder
+  brokenCode?: Prisma.SortOrder
+  brokenLanguage?: Prisma.SortOrder
+  expectedOutput?: Prisma.SortOrder
+  createdAt?: Prisma.SortOrder
+  updatedAt?: Prisma.SortOrder
+}
+
+export type QuestionScalarRelationFilter = {
+  is?: Prisma.QuestionWhereInput
+  isNot?: Prisma.QuestionWhereInput
+}
+
+export type EnumDifficultyFieldUpdateOperationsInput = {
+  set?: $Enums.Difficulty
+}
+
+export type QuestionCreateNestedOneWithoutMatchQuestionsInput = {
+  create?: Prisma.XOR<Prisma.QuestionCreateWithoutMatchQuestionsInput, Prisma.QuestionUncheckedCreateWithoutMatchQuestionsInput>
+  connectOrCreate?: Prisma.QuestionCreateOrConnectWithoutMatchQuestionsInput
+  connect?: Prisma.QuestionWhereUniqueInput
+}
+
+export type QuestionUpdateOneRequiredWithoutMatchQuestionsNestedInput = {
+  create?: Prisma.XOR<Prisma.QuestionCreateWithoutMatchQuestionsInput, Prisma.QuestionUncheckedCreateWithoutMatchQuestionsInput>
+  connectOrCreate?: Prisma.QuestionCreateOrConnectWithoutMatchQuestionsInput
+  upsert?: Prisma.QuestionUpsertWithoutMatchQuestionsInput
+  connect?: Prisma.QuestionWhereUniqueInput
+  update?: Prisma.XOR<Prisma.XOR<Prisma.QuestionUpdateToOneWithWhereWithoutMatchQuestionsInput, Prisma.QuestionUpdateWithoutMatchQuestionsInput>, Prisma.QuestionUncheckedUpdateWithoutMatchQuestionsInput>
+}
+
+export type QuestionCreateNestedOneWithoutSubmissionsInput = {
+  create?: Prisma.XOR<Prisma.QuestionCreateWithoutSubmissionsInput, Prisma.QuestionUncheckedCreateWithoutSubmissionsInput>
+  connectOrCreate?: Prisma.QuestionCreateOrConnectWithoutSubmissionsInput
+  connect?: Prisma.QuestionWhereUniqueInput
+}
+
+export type QuestionUpdateOneRequiredWithoutSubmissionsNestedInput = {
+  create?: Prisma.XOR<Prisma.QuestionCreateWithoutSubmissionsInput, Prisma.QuestionUncheckedCreateWithoutSubmissionsInput>
+  connectOrCreate?: Prisma.QuestionCreateOrConnectWithoutSubmissionsInput
+  upsert?: Prisma.QuestionUpsertWithoutSubmissionsInput
+  connect?: Prisma.QuestionWhereUniqueInput
+  update?: Prisma.XOR<Prisma.XOR<Prisma.QuestionUpdateToOneWithWhereWithoutSubmissionsInput, Prisma.QuestionUpdateWithoutSubmissionsInput>, Prisma.QuestionUncheckedUpdateWithoutSubmissionsInput>
+}
+
+export type QuestionCreateWithoutMatchQuestionsInput = {
+  id?: string
+  title: string
+  description: string
+  difficulty?: $Enums.Difficulty
+  mode?: $Enums.GameMode
+  brokenCode?: string | null
+  brokenLanguage?: string | null
+  expectedOutput?: string | null
+  testCases?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
+  createdAt?: Date | string
+  updatedAt?: Date | string
+  submissions?: Prisma.SubmissionCreateNestedManyWithoutQuestionInput
+}
+
+export type QuestionUncheckedCreateWithoutMatchQuestionsInput = {
+  id?: string
+  title: string
+  description: string
+  difficulty?: $Enums.Difficulty
+  mode?: $Enums.GameMode
+  brokenCode?: string | null
+  brokenLanguage?: string | null
+  expectedOutput?: string | null
+  testCases?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
+  createdAt?: Date | string
+  updatedAt?: Date | string
+  submissions?: Prisma.SubmissionUncheckedCreateNestedManyWithoutQuestionInput
+}
+
+export type QuestionCreateOrConnectWithoutMatchQuestionsInput = {
+  where: Prisma.QuestionWhereUniqueInput
+  create: Prisma.XOR<Prisma.QuestionCreateWithoutMatchQuestionsInput, Prisma.QuestionUncheckedCreateWithoutMatchQuestionsInput>
+}
+
+export type QuestionUpsertWithoutMatchQuestionsInput = {
+  update: Prisma.XOR<Prisma.QuestionUpdateWithoutMatchQuestionsInput, Prisma.QuestionUncheckedUpdateWithoutMatchQuestionsInput>
+  create: Prisma.XOR<Prisma.QuestionCreateWithoutMatchQuestionsInput, Prisma.QuestionUncheckedCreateWithoutMatchQuestionsInput>
+  where?: Prisma.QuestionWhereInput
+}
+
+export type QuestionUpdateToOneWithWhereWithoutMatchQuestionsInput = {
+  where?: Prisma.QuestionWhereInput
+  data: Prisma.XOR<Prisma.QuestionUpdateWithoutMatchQuestionsInput, Prisma.QuestionUncheckedUpdateWithoutMatchQuestionsInput>
+}
+
+export type QuestionUpdateWithoutMatchQuestionsInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  title?: Prisma.StringFieldUpdateOperationsInput | string
+  description?: Prisma.StringFieldUpdateOperationsInput | string
+  difficulty?: Prisma.EnumDifficultyFieldUpdateOperationsInput | $Enums.Difficulty
+  mode?: Prisma.EnumGameModeFieldUpdateOperationsInput | $Enums.GameMode
+  brokenCode?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  brokenLanguage?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  expectedOutput?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  testCases?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  submissions?: Prisma.SubmissionUpdateManyWithoutQuestionNestedInput
+}
+
+export type QuestionUncheckedUpdateWithoutMatchQuestionsInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  title?: Prisma.StringFieldUpdateOperationsInput | string
+  description?: Prisma.StringFieldUpdateOperationsInput | string
+  difficulty?: Prisma.EnumDifficultyFieldUpdateOperationsInput | $Enums.Difficulty
+  mode?: Prisma.EnumGameModeFieldUpdateOperationsInput | $Enums.GameMode
+  brokenCode?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  brokenLanguage?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  expectedOutput?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  testCases?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  submissions?: Prisma.SubmissionUncheckedUpdateManyWithoutQuestionNestedInput
+}
+
+export type QuestionCreateWithoutSubmissionsInput = {
+  id?: string
+  title: string
+  description: string
+  difficulty?: $Enums.Difficulty
+  mode?: $Enums.GameMode
+  brokenCode?: string | null
+  brokenLanguage?: string | null
+  expectedOutput?: string | null
+  testCases?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
+  createdAt?: Date | string
+  updatedAt?: Date | string
+  matchQuestions?: Prisma.MatchQuestionCreateNestedManyWithoutQuestionInput
+}
+
+export type QuestionUncheckedCreateWithoutSubmissionsInput = {
+  id?: string
+  title: string
+  description: string
+  difficulty?: $Enums.Difficulty
+  mode?: $Enums.GameMode
+  brokenCode?: string | null
+  brokenLanguage?: string | null
+  expectedOutput?: string | null
+  testCases?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
+  createdAt?: Date | string
+  updatedAt?: Date | string
+  matchQuestions?: Prisma.MatchQuestionUncheckedCreateNestedManyWithoutQuestionInput
+}
+
+export type QuestionCreateOrConnectWithoutSubmissionsInput = {
+  where: Prisma.QuestionWhereUniqueInput
+  create: Prisma.XOR<Prisma.QuestionCreateWithoutSubmissionsInput, Prisma.QuestionUncheckedCreateWithoutSubmissionsInput>
+}
+
+export type QuestionUpsertWithoutSubmissionsInput = {
+  update: Prisma.XOR<Prisma.QuestionUpdateWithoutSubmissionsInput, Prisma.QuestionUncheckedUpdateWithoutSubmissionsInput>
+  create: Prisma.XOR<Prisma.QuestionCreateWithoutSubmissionsInput, Prisma.QuestionUncheckedCreateWithoutSubmissionsInput>
+  where?: Prisma.QuestionWhereInput
+}
+
+export type QuestionUpdateToOneWithWhereWithoutSubmissionsInput = {
+  where?: Prisma.QuestionWhereInput
+  data: Prisma.XOR<Prisma.QuestionUpdateWithoutSubmissionsInput, Prisma.QuestionUncheckedUpdateWithoutSubmissionsInput>
+}
+
+export type QuestionUpdateWithoutSubmissionsInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  title?: Prisma.StringFieldUpdateOperationsInput | string
+  description?: Prisma.StringFieldUpdateOperationsInput | string
+  difficulty?: Prisma.EnumDifficultyFieldUpdateOperationsInput | $Enums.Difficulty
+  mode?: Prisma.EnumGameModeFieldUpdateOperationsInput | $Enums.GameMode
+  brokenCode?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  brokenLanguage?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  expectedOutput?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  testCases?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  matchQuestions?: Prisma.MatchQuestionUpdateManyWithoutQuestionNestedInput
+}
+
+export type QuestionUncheckedUpdateWithoutSubmissionsInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  title?: Prisma.StringFieldUpdateOperationsInput | string
+  description?: Prisma.StringFieldUpdateOperationsInput | string
+  difficulty?: Prisma.EnumDifficultyFieldUpdateOperationsInput | $Enums.Difficulty
+  mode?: Prisma.EnumGameModeFieldUpdateOperationsInput | $Enums.GameMode
+  brokenCode?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  brokenLanguage?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  expectedOutput?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  testCases?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  matchQuestions?: Prisma.MatchQuestionUncheckedUpdateManyWithoutQuestionNestedInput
+}
+
+
+/**
+ * Count Type QuestionCountOutputType
+ */
+
+export type QuestionCountOutputType = {
+  matchQuestions: number
+  submissions: number
+}
+
+export type QuestionCountOutputTypeSelect<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  matchQuestions?: boolean | QuestionCountOutputTypeCountMatchQuestionsArgs
+  submissions?: boolean | QuestionCountOutputTypeCountSubmissionsArgs
+}
+
+/**
+ * QuestionCountOutputType without action
+ */
+export type QuestionCountOutputTypeDefaultArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the QuestionCountOutputType
+   */
+  select?: Prisma.QuestionCountOutputTypeSelect<ExtArgs> | null
+}
+
+/**
+ * QuestionCountOutputType without action
+ */
+export type QuestionCountOutputTypeCountMatchQuestionsArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  where?: Prisma.MatchQuestionWhereInput
+}
+
+/**
+ * QuestionCountOutputType without action
+ */
+export type QuestionCountOutputTypeCountSubmissionsArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  where?: Prisma.SubmissionWhereInput
+}
+
+
+export type QuestionSelect<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
+  id?: boolean
+  title?: boolean
+  description?: boolean
+  difficulty?: boolean
+  mode?: boolean
+  brokenCode?: boolean
+  brokenLanguage?: boolean
+  expectedOutput?: boolean
+  testCases?: boolean
+  createdAt?: boolean
+  updatedAt?: boolean
+  matchQuestions?: boolean | Prisma.Question$matchQuestionsArgs<ExtArgs>
+  submissions?: boolean | Prisma.Question$submissionsArgs<ExtArgs>
+  _count?: boolean | Prisma.QuestionCountOutputTypeDefaultArgs<ExtArgs>
+}, ExtArgs["result"]["question"]>
+
+export type QuestionSelectCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
+  id?: boolean
+  title?: boolean
+  description?: boolean
+  difficulty?: boolean
+  mode?: boolean
+  brokenCode?: boolean
+  brokenLanguage?: boolean
+  expectedOutput?: boolean
+  testCases?: boolean
+  createdAt?: boolean
+  updatedAt?: boolean
+}, ExtArgs["result"]["question"]>
+
+export type QuestionSelectUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
+  id?: boolean
+  title?: boolean
+  description?: boolean
+  difficulty?: boolean
+  mode?: boolean
+  brokenCode?: boolean
+  brokenLanguage?: boolean
+  expectedOutput?: boolean
+  testCases?: boolean
+  createdAt?: boolean
+  updatedAt?: boolean
+}, ExtArgs["result"]["question"]>
+
+export type QuestionSelectScalar = {
+  id?: boolean
+  title?: boolean
+  description?: boolean
+  difficulty?: boolean
+  mode?: boolean
+  brokenCode?: boolean
+  brokenLanguage?: boolean
+  expectedOutput?: boolean
+  testCases?: boolean
+  createdAt?: boolean
+  updatedAt?: boolean
+}
+
+export type QuestionOmit<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetOmit<"id" | "title" | "description" | "difficulty" | "mode" | "brokenCode" | "brokenLanguage" | "expectedOutput" | "testCases" | "createdAt" | "updatedAt", ExtArgs["result"]["question"]>
+export type QuestionInclude<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  matchQuestions?: boolean | Prisma.Question$matchQuestionsArgs<ExtArgs>
+  submissions?: boolean | Prisma.Question$submissionsArgs<ExtArgs>
+  _count?: boolean | Prisma.QuestionCountOutputTypeDefaultArgs<ExtArgs>
+}
+export type QuestionIncludeCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {}
+export type QuestionIncludeUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {}
+
+export type $QuestionPayload<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  name: "Question"
+  objects: {
+    matchQuestions: Prisma.$MatchQuestionPayload<ExtArgs>[]
+    submissions: Prisma.$SubmissionPayload<ExtArgs>[]
+  }
+  scalars: runtime.Types.Extensions.GetPayloadResult<{
+    id: string
+    title: string
+    description: string
+    difficulty: $Enums.Difficulty
+    mode: $Enums.GameMode
+    brokenCode: string | null
+    brokenLanguage: string | null
+    expectedOutput: string | null
+    testCases: runtime.JsonValue | null
+    createdAt: Date
+    updatedAt: Date
+  }, ExtArgs["result"]["question"]>
+  composites: {}
+}
+
+export type QuestionGetPayload<S extends boolean | null | undefined | QuestionDefaultArgs> = runtime.Types.Result.GetResult<Prisma.$QuestionPayload, S>
+
+export type QuestionCountArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> =
+  Omit<QuestionFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
+    select?: QuestionCountAggregateInputType | true
+  }
+
+export interface QuestionDelegate<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> {
+  [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Question'], meta: { name: 'Question' } }
+  /**
+   * Find zero or one Question that matches the filter.
+   * @param {QuestionFindUniqueArgs} args - Arguments to find a Question
+   * @example
+   * // Get one Question
+   * const question = await prisma.question.findUnique({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   */
+  findUnique<T extends QuestionFindUniqueArgs>(args: Prisma.SelectSubset<T, QuestionFindUniqueArgs<ExtArgs>>): Prisma.Prisma__QuestionClient<runtime.Types.Result.GetResult<Prisma.$QuestionPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Find one Question that matches the filter or throw an error with `error.code='P2025'`
+   * if no matches were found.
+   * @param {QuestionFindUniqueOrThrowArgs} args - Arguments to find a Question
+   * @example
+   * // Get one Question
+   * const question = await prisma.question.findUniqueOrThrow({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   */
+  findUniqueOrThrow<T extends QuestionFindUniqueOrThrowArgs>(args: Prisma.SelectSubset<T, QuestionFindUniqueOrThrowArgs<ExtArgs>>): Prisma.Prisma__QuestionClient<runtime.Types.Result.GetResult<Prisma.$QuestionPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Find the first Question that matches the filter.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {QuestionFindFirstArgs} args - Arguments to find a Question
+   * @example
+   * // Get one Question
+   * const question = await prisma.question.findFirst({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   */
+  findFirst<T extends QuestionFindFirstArgs>(args?: Prisma.SelectSubset<T, QuestionFindFirstArgs<ExtArgs>>): Prisma.Prisma__QuestionClient<runtime.Types.Result.GetResult<Prisma.$QuestionPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Find the first Question that matches the filter or
+   * throw `PrismaKnownClientError` with `P2025` code if no matches were found.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {QuestionFindFirstOrThrowArgs} args - Arguments to find a Question
+   * @example
+   * // Get one Question
+   * const question = await prisma.question.findFirstOrThrow({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   */
+  findFirstOrThrow<T extends QuestionFindFirstOrThrowArgs>(args?: Prisma.SelectSubset<T, QuestionFindFirstOrThrowArgs<ExtArgs>>): Prisma.Prisma__QuestionClient<runtime.Types.Result.GetResult<Prisma.$QuestionPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Find zero or more Questions that matches the filter.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {QuestionFindManyArgs} args - Arguments to filter and select certain fields only.
+   * @example
+   * // Get all Questions
+   * const questions = await prisma.question.findMany()
+   * 
+   * // Get first 10 Questions
+   * const questions = await prisma.question.findMany({ take: 10 })
+   * 
+   * // Only select the `id`
+   * const questionWithIdOnly = await prisma.question.findMany({ select: { id: true } })
+   * 
+   */
+  findMany<T extends QuestionFindManyArgs>(args?: Prisma.SelectSubset<T, QuestionFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$QuestionPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>
+
+  /**
+   * Create a Question.
+   * @param {QuestionCreateArgs} args - Arguments to create a Question.
+   * @example
+   * // Create one Question
+   * const Question = await prisma.question.create({
+   *   data: {
+   *     // ... data to create a Question
+   *   }
+   * })
+   * 
+   */
+  create<T extends QuestionCreateArgs>(args: Prisma.SelectSubset<T, QuestionCreateArgs<ExtArgs>>): Prisma.Prisma__QuestionClient<runtime.Types.Result.GetResult<Prisma.$QuestionPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Create many Questions.
+   * @param {QuestionCreateManyArgs} args - Arguments to create many Questions.
+   * @example
+   * // Create many Questions
+   * const question = await prisma.question.createMany({
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   *     
+   */
+  createMany<T extends QuestionCreateManyArgs>(args?: Prisma.SelectSubset<T, QuestionCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>
+
+  /**
+   * Create many Questions and returns the data saved in the database.
+   * @param {QuestionCreateManyAndReturnArgs} args - Arguments to create many Questions.
+   * @example
+   * // Create many Questions
+   * const question = await prisma.question.createManyAndReturn({
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   * 
+   * // Create many Questions and only return the `id`
+   * const questionWithIdOnly = await prisma.question.createManyAndReturn({
+   *   select: { id: true },
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * 
+   */
+  createManyAndReturn<T extends QuestionCreateManyAndReturnArgs>(args?: Prisma.SelectSubset<T, QuestionCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$QuestionPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>
+
+  /**
+   * Delete a Question.
+   * @param {QuestionDeleteArgs} args - Arguments to delete one Question.
+   * @example
+   * // Delete one Question
+   * const Question = await prisma.question.delete({
+   *   where: {
+   *     // ... filter to delete one Question
+   *   }
+   * })
+   * 
+   */
+  delete<T extends QuestionDeleteArgs>(args: Prisma.SelectSubset<T, QuestionDeleteArgs<ExtArgs>>): Prisma.Prisma__QuestionClient<runtime.Types.Result.GetResult<Prisma.$QuestionPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Update one Question.
+   * @param {QuestionUpdateArgs} args - Arguments to update one Question.
+   * @example
+   * // Update one Question
+   * const question = await prisma.question.update({
+   *   where: {
+   *     // ... provide filter here
+   *   },
+   *   data: {
+   *     // ... provide data here
+   *   }
+   * })
+   * 
+   */
+  update<T extends QuestionUpdateArgs>(args: Prisma.SelectSubset<T, QuestionUpdateArgs<ExtArgs>>): Prisma.Prisma__QuestionClient<runtime.Types.Result.GetResult<Prisma.$QuestionPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Delete zero or more Questions.
+   * @param {QuestionDeleteManyArgs} args - Arguments to filter Questions to delete.
+   * @example
+   * // Delete a few Questions
+   * const { count } = await prisma.question.deleteMany({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   * 
+   */
+  deleteMany<T extends QuestionDeleteManyArgs>(args?: Prisma.SelectSubset<T, QuestionDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>
+
+  /**
+   * Update zero or more Questions.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {QuestionUpdateManyArgs} args - Arguments to update one or more rows.
+   * @example
+   * // Update many Questions
+   * const question = await prisma.question.updateMany({
+   *   where: {
+   *     // ... provide filter here
+   *   },
+   *   data: {
+   *     // ... provide data here
+   *   }
+   * })
+   * 
+   */
+  updateMany<T extends QuestionUpdateManyArgs>(args: Prisma.SelectSubset<T, QuestionUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>
+
+  /**
+   * Update zero or more Questions and returns the data updated in the database.
+   * @param {QuestionUpdateManyAndReturnArgs} args - Arguments to update many Questions.
+   * @example
+   * // Update many Questions
+   * const question = await prisma.question.updateManyAndReturn({
+   *   where: {
+   *     // ... provide filter here
+   *   },
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   * 
+   * // Update zero or more Questions and only return the `id`
+   * const questionWithIdOnly = await prisma.question.updateManyAndReturn({
+   *   select: { id: true },
+   *   where: {
+   *     // ... provide filter here
+   *   },
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * 
+   */
+  updateManyAndReturn<T extends QuestionUpdateManyAndReturnArgs>(args: Prisma.SelectSubset<T, QuestionUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$QuestionPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>
+
+  /**
+   * Create or update one Question.
+   * @param {QuestionUpsertArgs} args - Arguments to update or create a Question.
+   * @example
+   * // Update or create a Question
+   * const question = await prisma.question.upsert({
+   *   create: {
+   *     // ... data to create a Question
+   *   },
+   *   update: {
+   *     // ... in case it already exists, update
+   *   },
+   *   where: {
+   *     // ... the filter for the Question we want to update
+   *   }
+   * })
+   */
+  upsert<T extends QuestionUpsertArgs>(args: Prisma.SelectSubset<T, QuestionUpsertArgs<ExtArgs>>): Prisma.Prisma__QuestionClient<runtime.Types.Result.GetResult<Prisma.$QuestionPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+
+  /**
+   * Count the number of Questions.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {QuestionCountArgs} args - Arguments to filter Questions to count.
+   * @example
+   * // Count the number of Questions
+   * const count = await prisma.question.count({
+   *   where: {
+   *     // ... the filter for the Questions we want to count
+   *   }
+   * })
+  **/
+  count<T extends QuestionCountArgs>(
+    args?: Prisma.Subset<T, QuestionCountArgs>,
+  ): Prisma.PrismaPromise<
+    T extends runtime.Types.Utils.Record<'select', any>
+      ? T['select'] extends true
+        ? number
+        : Prisma.GetScalarType<T['select'], QuestionCountAggregateOutputType>
+      : number
+  >
+
+  /**
+   * Allows you to perform aggregations operations on a Question.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {QuestionAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
+   * @example
+   * // Ordered by age ascending
+   * // Where email contains prisma.io
+   * // Limited to the 10 users
+   * const aggregations = await prisma.user.aggregate({
+   *   _avg: {
+   *     age: true,
+   *   },
+   *   where: {
+   *     email: {
+   *       contains: "prisma.io",
+   *     },
+   *   },
+   *   orderBy: {
+   *     age: "asc",
+   *   },
+   *   take: 10,
+   * })
+  **/
+  aggregate<T extends QuestionAggregateArgs>(args: Prisma.Subset<T, QuestionAggregateArgs>): Prisma.PrismaPromise<GetQuestionAggregateType<T>>
+
+  /**
+   * Group by Question.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {QuestionGroupByArgs} args - Group by arguments.
+   * @example
+   * // Group by city, order by createdAt, get count
+   * const result = await prisma.user.groupBy({
+   *   by: ['city', 'createdAt'],
+   *   orderBy: {
+   *     createdAt: true
+   *   },
+   *   _count: {
+   *     _all: true
+   *   },
+   * })
+   * 
+  **/
+  groupBy<
+    T extends QuestionGroupByArgs,
+    HasSelectOrTake extends Prisma.Or<
+      Prisma.Extends<'skip', Prisma.Keys<T>>,
+      Prisma.Extends<'take', Prisma.Keys<T>>
+    >,
+    OrderByArg extends Prisma.True extends HasSelectOrTake
+      ? { orderBy: QuestionGroupByArgs['orderBy'] }
+      : { orderBy?: QuestionGroupByArgs['orderBy'] },
+    OrderFields extends Prisma.ExcludeUnderscoreKeys<Prisma.Keys<Prisma.MaybeTupleToUnion<T['orderBy']>>>,
+    ByFields extends Prisma.MaybeTupleToUnion<T['by']>,
+    ByValid extends Prisma.Has<ByFields, OrderFields>,
+    HavingFields extends Prisma.GetHavingFields<T['having']>,
+    HavingValid extends Prisma.Has<ByFields, HavingFields>,
+    ByEmpty extends T['by'] extends never[] ? Prisma.True : Prisma.False,
+    InputErrors extends ByEmpty extends Prisma.True
+    ? `Error: "by" must not be empty.`
+    : HavingValid extends Prisma.False
+    ? {
+        [P in HavingFields]: P extends ByFields
+          ? never
+          : P extends string
+          ? `Error: Field "${P}" used in "having" needs to be provided in "by".`
+          : [
+              Error,
+              'Field ',
+              P,
+              ` in "having" needs to be provided in "by"`,
+            ]
+      }[HavingFields]
+    : 'take' extends Prisma.Keys<T>
+    ? 'orderBy' extends Prisma.Keys<T>
+      ? ByValid extends Prisma.True
+        ? {}
+        : {
+            [P in OrderFields]: P extends ByFields
+              ? never
+              : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
+          }[OrderFields]
+      : 'Error: If you provide "take", you also need to provide "orderBy"'
+    : 'skip' extends Prisma.Keys<T>
+    ? 'orderBy' extends Prisma.Keys<T>
+      ? ByValid extends Prisma.True
+        ? {}
+        : {
+            [P in OrderFields]: P extends ByFields
+              ? never
+              : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
+          }[OrderFields]
+      : 'Error: If you provide "skip", you also need to provide "orderBy"'
+    : ByValid extends Prisma.True
+    ? {}
+    : {
+        [P in OrderFields]: P extends ByFields
+          ? never
+          : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
+      }[OrderFields]
+  >(args: Prisma.SubsetIntersection<T, QuestionGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetQuestionGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
+/**
+ * Fields of the Question model
+ */
+readonly fields: QuestionFieldRefs;
+}
+
+/**
+ * The delegate class that acts as a "Promise-like" for Question.
+ * Why is this prefixed with `Prisma__`?
+ * Because we want to prevent naming conflicts as mentioned in
+ * https://github.com/prisma/prisma-client-js/issues/707
+ */
+export interface Prisma__QuestionClient<T, Null = never, ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
+  readonly [Symbol.toStringTag]: "PrismaPromise"
+  matchQuestions<T extends Prisma.Question$matchQuestionsArgs<ExtArgs> = {}>(args?: Prisma.Subset<T, Prisma.Question$matchQuestionsArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$MatchQuestionPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
+  submissions<T extends Prisma.Question$submissionsArgs<ExtArgs> = {}>(args?: Prisma.Subset<T, Prisma.Question$submissionsArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$SubmissionPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
+  /**
+   * Attaches callbacks for the resolution and/or rejection of the Promise.
+   * @param onfulfilled The callback to execute when the Promise is resolved.
+   * @param onrejected The callback to execute when the Promise is rejected.
+   * @returns A Promise for the completion of which ever callback is executed.
+   */
+  then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): runtime.Types.Utils.JsPromise<TResult1 | TResult2>
+  /**
+   * Attaches a callback for only the rejection of the Promise.
+   * @param onrejected The callback to execute when the Promise is rejected.
+   * @returns A Promise for the completion of the callback.
+   */
+  catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): runtime.Types.Utils.JsPromise<T | TResult>
+  /**
+   * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
+   * resolved value cannot be modified from the callback.
+   * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
+   * @returns A Promise for the completion of the callback.
+   */
+  finally(onfinally?: (() => void) | undefined | null): runtime.Types.Utils.JsPromise<T>
+}
+
+
+
+
+/**
+ * Fields of the Question model
+ */
+export interface QuestionFieldRefs {
+  readonly id: Prisma.FieldRef<"Question", 'String'>
+  readonly title: Prisma.FieldRef<"Question", 'String'>
+  readonly description: Prisma.FieldRef<"Question", 'String'>
+  readonly difficulty: Prisma.FieldRef<"Question", 'Difficulty'>
+  readonly mode: Prisma.FieldRef<"Question", 'GameMode'>
+  readonly brokenCode: Prisma.FieldRef<"Question", 'String'>
+  readonly brokenLanguage: Prisma.FieldRef<"Question", 'String'>
+  readonly expectedOutput: Prisma.FieldRef<"Question", 'String'>
+  readonly testCases: Prisma.FieldRef<"Question", 'Json'>
+  readonly createdAt: Prisma.FieldRef<"Question", 'DateTime'>
+  readonly updatedAt: Prisma.FieldRef<"Question", 'DateTime'>
+}
+    
+
+// Custom InputTypes
+/**
+ * Question findUnique
+ */
+export type QuestionFindUniqueArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Question
+   */
+  select?: Prisma.QuestionSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Question
+   */
+  omit?: Prisma.QuestionOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.QuestionInclude<ExtArgs> | null
+  /**
+   * Filter, which Question to fetch.
+   */
+  where: Prisma.QuestionWhereUniqueInput
+}
+
+/**
+ * Question findUniqueOrThrow
+ */
+export type QuestionFindUniqueOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Question
+   */
+  select?: Prisma.QuestionSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Question
+   */
+  omit?: Prisma.QuestionOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.QuestionInclude<ExtArgs> | null
+  /**
+   * Filter, which Question to fetch.
+   */
+  where: Prisma.QuestionWhereUniqueInput
+}
+
+/**
+ * Question findFirst
+ */
+export type QuestionFindFirstArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Question
+   */
+  select?: Prisma.QuestionSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Question
+   */
+  omit?: Prisma.QuestionOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.QuestionInclude<ExtArgs> | null
+  /**
+   * Filter, which Question to fetch.
+   */
+  where?: Prisma.QuestionWhereInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+   * 
+   * Determine the order of Questions to fetch.
+   */
+  orderBy?: Prisma.QuestionOrderByWithRelationInput | Prisma.QuestionOrderByWithRelationInput[]
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+   * 
+   * Sets the position for searching for Questions.
+   */
+  cursor?: Prisma.QuestionWhereUniqueInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Take `±n` Questions from the position of the cursor.
+   */
+  take?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Skip the first `n` Questions.
+   */
+  skip?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+   * 
+   * Filter by unique combinations of Questions.
+   */
+  distinct?: Prisma.QuestionScalarFieldEnum | Prisma.QuestionScalarFieldEnum[]
+}
+
+/**
+ * Question findFirstOrThrow
+ */
+export type QuestionFindFirstOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Question
+   */
+  select?: Prisma.QuestionSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Question
+   */
+  omit?: Prisma.QuestionOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.QuestionInclude<ExtArgs> | null
+  /**
+   * Filter, which Question to fetch.
+   */
+  where?: Prisma.QuestionWhereInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+   * 
+   * Determine the order of Questions to fetch.
+   */
+  orderBy?: Prisma.QuestionOrderByWithRelationInput | Prisma.QuestionOrderByWithRelationInput[]
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+   * 
+   * Sets the position for searching for Questions.
+   */
+  cursor?: Prisma.QuestionWhereUniqueInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Take `±n` Questions from the position of the cursor.
+   */
+  take?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Skip the first `n` Questions.
+   */
+  skip?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+   * 
+   * Filter by unique combinations of Questions.
+   */
+  distinct?: Prisma.QuestionScalarFieldEnum | Prisma.QuestionScalarFieldEnum[]
+}
+
+/**
+ * Question findMany
+ */
+export type QuestionFindManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Question
+   */
+  select?: Prisma.QuestionSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Question
+   */
+  omit?: Prisma.QuestionOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.QuestionInclude<ExtArgs> | null
+  /**
+   * Filter, which Questions to fetch.
+   */
+  where?: Prisma.QuestionWhereInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+   * 
+   * Determine the order of Questions to fetch.
+   */
+  orderBy?: Prisma.QuestionOrderByWithRelationInput | Prisma.QuestionOrderByWithRelationInput[]
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+   * 
+   * Sets the position for listing Questions.
+   */
+  cursor?: Prisma.QuestionWhereUniqueInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Take `±n` Questions from the position of the cursor.
+   */
+  take?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Skip the first `n` Questions.
+   */
+  skip?: number
+  distinct?: Prisma.QuestionScalarFieldEnum | Prisma.QuestionScalarFieldEnum[]
+}
+
+/**
+ * Question create
+ */
+export type QuestionCreateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Question
+   */
+  select?: Prisma.QuestionSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Question
+   */
+  omit?: Prisma.QuestionOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.QuestionInclude<ExtArgs> | null
+  /**
+   * The data needed to create a Question.
+   */
+  data: Prisma.XOR<Prisma.QuestionCreateInput, Prisma.QuestionUncheckedCreateInput>
+}
+
+/**
+ * Question createMany
+ */
+export type QuestionCreateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * The data used to create many Questions.
+   */
+  data: Prisma.QuestionCreateManyInput | Prisma.QuestionCreateManyInput[]
+  skipDuplicates?: boolean
+}
+
+/**
+ * Question createManyAndReturn
+ */
+export type QuestionCreateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Question
+   */
+  select?: Prisma.QuestionSelectCreateManyAndReturn<ExtArgs> | null
+  /**
+   * Omit specific fields from the Question
+   */
+  omit?: Prisma.QuestionOmit<ExtArgs> | null
+  /**
+   * The data used to create many Questions.
+   */
+  data: Prisma.QuestionCreateManyInput | Prisma.QuestionCreateManyInput[]
+  skipDuplicates?: boolean
+}
+
+/**
+ * Question update
+ */
+export type QuestionUpdateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Question
+   */
+  select?: Prisma.QuestionSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Question
+   */
+  omit?: Prisma.QuestionOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.QuestionInclude<ExtArgs> | null
+  /**
+   * The data needed to update a Question.
+   */
+  data: Prisma.XOR<Prisma.QuestionUpdateInput, Prisma.QuestionUncheckedUpdateInput>
+  /**
+   * Choose, which Question to update.
+   */
+  where: Prisma.QuestionWhereUniqueInput
+}
+
+/**
+ * Question updateMany
+ */
+export type QuestionUpdateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * The data used to update Questions.
+   */
+  data: Prisma.XOR<Prisma.QuestionUpdateManyMutationInput, Prisma.QuestionUncheckedUpdateManyInput>
+  /**
+   * Filter which Questions to update
+   */
+  where?: Prisma.QuestionWhereInput
+  /**
+   * Limit how many Questions to update.
+   */
+  limit?: number
+}
+
+/**
+ * Question updateManyAndReturn
+ */
+export type QuestionUpdateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Question
+   */
+  select?: Prisma.QuestionSelectUpdateManyAndReturn<ExtArgs> | null
+  /**
+   * Omit specific fields from the Question
+   */
+  omit?: Prisma.QuestionOmit<ExtArgs> | null
+  /**
+   * The data used to update Questions.
+   */
+  data: Prisma.XOR<Prisma.QuestionUpdateManyMutationInput, Prisma.QuestionUncheckedUpdateManyInput>
+  /**
+   * Filter which Questions to update
+   */
+  where?: Prisma.QuestionWhereInput
+  /**
+   * Limit how many Questions to update.
+   */
+  limit?: number
+}
+
+/**
+ * Question upsert
+ */
+export type QuestionUpsertArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Question
+   */
+  select?: Prisma.QuestionSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Question
+   */
+  omit?: Prisma.QuestionOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.QuestionInclude<ExtArgs> | null
+  /**
+   * The filter to search for the Question to update in case it exists.
+   */
+  where: Prisma.QuestionWhereUniqueInput
+  /**
+   * In case the Question found by the `where` argument doesn't exist, create a new Question with this data.
+   */
+  create: Prisma.XOR<Prisma.QuestionCreateInput, Prisma.QuestionUncheckedCreateInput>
+  /**
+   * In case the Question was found with the provided `where` argument, update it with this data.
+   */
+  update: Prisma.XOR<Prisma.QuestionUpdateInput, Prisma.QuestionUncheckedUpdateInput>
+}
+
+/**
+ * Question delete
+ */
+export type QuestionDeleteArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Question
+   */
+  select?: Prisma.QuestionSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Question
+   */
+  omit?: Prisma.QuestionOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.QuestionInclude<ExtArgs> | null
+  /**
+   * Filter which Question to delete.
+   */
+  where: Prisma.QuestionWhereUniqueInput
+}
+
+/**
+ * Question deleteMany
+ */
+export type QuestionDeleteManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Filter which Questions to delete
+   */
+  where?: Prisma.QuestionWhereInput
+  /**
+   * Limit how many Questions to delete.
+   */
+  limit?: number
+}
+
+/**
+ * Question.matchQuestions
+ */
+export type Question$matchQuestionsArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the MatchQuestion
+   */
+  select?: Prisma.MatchQuestionSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the MatchQuestion
+   */
+  omit?: Prisma.MatchQuestionOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.MatchQuestionInclude<ExtArgs> | null
+  where?: Prisma.MatchQuestionWhereInput
+  orderBy?: Prisma.MatchQuestionOrderByWithRelationInput | Prisma.MatchQuestionOrderByWithRelationInput[]
+  cursor?: Prisma.MatchQuestionWhereUniqueInput
+  take?: number
+  skip?: number
+  distinct?: Prisma.MatchQuestionScalarFieldEnum | Prisma.MatchQuestionScalarFieldEnum[]
+}
+
+/**
+ * Question.submissions
+ */
+export type Question$submissionsArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Submission
+   */
+  select?: Prisma.SubmissionSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Submission
+   */
+  omit?: Prisma.SubmissionOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.SubmissionInclude<ExtArgs> | null
+  where?: Prisma.SubmissionWhereInput
+  orderBy?: Prisma.SubmissionOrderByWithRelationInput | Prisma.SubmissionOrderByWithRelationInput[]
+  cursor?: Prisma.SubmissionWhereUniqueInput
+  take?: number
+  skip?: number
+  distinct?: Prisma.SubmissionScalarFieldEnum | Prisma.SubmissionScalarFieldEnum[]
+}
+
+/**
+ * Question without action
+ */
+export type QuestionDefaultArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Question
+   */
+  select?: Prisma.QuestionSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Question
+   */
+  omit?: Prisma.QuestionOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.QuestionInclude<ExtArgs> | null
+}
diff --git a/prisma/generated/prisma/models/QueueEntry.ts b/prisma/generated/prisma/models/QueueEntry.ts
new file mode 100644
index 0000000..0764ad2
--- /dev/null
+++ b/prisma/generated/prisma/models/QueueEntry.ts
@@ -0,0 +1,1315 @@
+
+/* !!! This is code generated by Prisma. Do not edit directly. !!! */
+/* eslint-disable */
+// biome-ignore-all lint: generated file
+// @ts-nocheck 
+/*
+ * This file exports the `QueueEntry` model and its related types.
+ *
+ * 🟢 You can import this file directly.
+ */
+import type * as runtime from "@prisma/client/runtime/client"
+import type * as $Enums from "../enums"
+import type * as Prisma from "../internal/prismaNamespace"
+
+/**
+ * Model QueueEntry
+ * 
+ */
+export type QueueEntryModel = runtime.Types.Result.DefaultSelection<Prisma.$QueueEntryPayload>
+
+export type AggregateQueueEntry = {
+  _count: QueueEntryCountAggregateOutputType | null
+  _min: QueueEntryMinAggregateOutputType | null
+  _max: QueueEntryMaxAggregateOutputType | null
+}
+
+export type QueueEntryMinAggregateOutputType = {
+  id: string | null
+  userId: string | null
+  joinedAt: Date | null
+  active: boolean | null
+}
+
+export type QueueEntryMaxAggregateOutputType = {
+  id: string | null
+  userId: string | null
+  joinedAt: Date | null
+  active: boolean | null
+}
+
+export type QueueEntryCountAggregateOutputType = {
+  id: number
+  userId: number
+  joinedAt: number
+  active: number
+  _all: number
+}
+
+
+export type QueueEntryMinAggregateInputType = {
+  id?: true
+  userId?: true
+  joinedAt?: true
+  active?: true
+}
+
+export type QueueEntryMaxAggregateInputType = {
+  id?: true
+  userId?: true
+  joinedAt?: true
+  active?: true
+}
+
+export type QueueEntryCountAggregateInputType = {
+  id?: true
+  userId?: true
+  joinedAt?: true
+  active?: true
+  _all?: true
+}
+
+export type QueueEntryAggregateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Filter which QueueEntry to aggregate.
+   */
+  where?: Prisma.QueueEntryWhereInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+   * 
+   * Determine the order of QueueEntries to fetch.
+   */
+  orderBy?: Prisma.QueueEntryOrderByWithRelationInput | Prisma.QueueEntryOrderByWithRelationInput[]
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+   * 
+   * Sets the start position
+   */
+  cursor?: Prisma.QueueEntryWhereUniqueInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Take `±n` QueueEntries from the position of the cursor.
+   */
+  take?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Skip the first `n` QueueEntries.
+   */
+  skip?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Count returned QueueEntries
+  **/
+  _count?: true | QueueEntryCountAggregateInputType
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Select which fields to find the minimum value
+  **/
+  _min?: QueueEntryMinAggregateInputType
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Select which fields to find the maximum value
+  **/
+  _max?: QueueEntryMaxAggregateInputType
+}
+
+export type GetQueueEntryAggregateType<T extends QueueEntryAggregateArgs> = {
+      [P in keyof T & keyof AggregateQueueEntry]: P extends '_count' | 'count'
+    ? T[P] extends true
+      ? number
+      : Prisma.GetScalarType<T[P], AggregateQueueEntry[P]>
+    : Prisma.GetScalarType<T[P], AggregateQueueEntry[P]>
+}
+
+
+
+
+export type QueueEntryGroupByArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  where?: Prisma.QueueEntryWhereInput
+  orderBy?: Prisma.QueueEntryOrderByWithAggregationInput | Prisma.QueueEntryOrderByWithAggregationInput[]
+  by: Prisma.QueueEntryScalarFieldEnum[] | Prisma.QueueEntryScalarFieldEnum
+  having?: Prisma.QueueEntryScalarWhereWithAggregatesInput
+  take?: number
+  skip?: number
+  _count?: QueueEntryCountAggregateInputType | true
+  _min?: QueueEntryMinAggregateInputType
+  _max?: QueueEntryMaxAggregateInputType
+}
+
+export type QueueEntryGroupByOutputType = {
+  id: string
+  userId: string
+  joinedAt: Date
+  active: boolean
+  _count: QueueEntryCountAggregateOutputType | null
+  _min: QueueEntryMinAggregateOutputType | null
+  _max: QueueEntryMaxAggregateOutputType | null
+}
+
+type GetQueueEntryGroupByPayload<T extends QueueEntryGroupByArgs> = Prisma.PrismaPromise<
+  Array<
+    Prisma.PickEnumerable<QueueEntryGroupByOutputType, T['by']> &
+      {
+        [P in ((keyof T) & (keyof QueueEntryGroupByOutputType))]: P extends '_count'
+          ? T[P] extends boolean
+            ? number
+            : Prisma.GetScalarType<T[P], QueueEntryGroupByOutputType[P]>
+          : Prisma.GetScalarType<T[P], QueueEntryGroupByOutputType[P]>
+      }
+    >
+  >
+
+
+
+export type QueueEntryWhereInput = {
+  AND?: Prisma.QueueEntryWhereInput | Prisma.QueueEntryWhereInput[]
+  OR?: Prisma.QueueEntryWhereInput[]
+  NOT?: Prisma.QueueEntryWhereInput | Prisma.QueueEntryWhereInput[]
+  id?: Prisma.StringFilter<"QueueEntry"> | string
+  userId?: Prisma.StringFilter<"QueueEntry"> | string
+  joinedAt?: Prisma.DateTimeFilter<"QueueEntry"> | Date | string
+  active?: Prisma.BoolFilter<"QueueEntry"> | boolean
+  user?: Prisma.XOR<Prisma.UserScalarRelationFilter, Prisma.UserWhereInput>
+}
+
+export type QueueEntryOrderByWithRelationInput = {
+  id?: Prisma.SortOrder
+  userId?: Prisma.SortOrder
+  joinedAt?: Prisma.SortOrder
+  active?: Prisma.SortOrder
+  user?: Prisma.UserOrderByWithRelationInput
+}
+
+export type QueueEntryWhereUniqueInput = Prisma.AtLeast<{
+  id?: string
+  userId_active?: Prisma.QueueEntryUserIdActiveCompoundUniqueInput
+  AND?: Prisma.QueueEntryWhereInput | Prisma.QueueEntryWhereInput[]
+  OR?: Prisma.QueueEntryWhereInput[]
+  NOT?: Prisma.QueueEntryWhereInput | Prisma.QueueEntryWhereInput[]
+  userId?: Prisma.StringFilter<"QueueEntry"> | string
+  joinedAt?: Prisma.DateTimeFilter<"QueueEntry"> | Date | string
+  active?: Prisma.BoolFilter<"QueueEntry"> | boolean
+  user?: Prisma.XOR<Prisma.UserScalarRelationFilter, Prisma.UserWhereInput>
+}, "id" | "userId_active">
+
+export type QueueEntryOrderByWithAggregationInput = {
+  id?: Prisma.SortOrder
+  userId?: Prisma.SortOrder
+  joinedAt?: Prisma.SortOrder
+  active?: Prisma.SortOrder
+  _count?: Prisma.QueueEntryCountOrderByAggregateInput
+  _max?: Prisma.QueueEntryMaxOrderByAggregateInput
+  _min?: Prisma.QueueEntryMinOrderByAggregateInput
+}
+
+export type QueueEntryScalarWhereWithAggregatesInput = {
+  AND?: Prisma.QueueEntryScalarWhereWithAggregatesInput | Prisma.QueueEntryScalarWhereWithAggregatesInput[]
+  OR?: Prisma.QueueEntryScalarWhereWithAggregatesInput[]
+  NOT?: Prisma.QueueEntryScalarWhereWithAggregatesInput | Prisma.QueueEntryScalarWhereWithAggregatesInput[]
+  id?: Prisma.StringWithAggregatesFilter<"QueueEntry"> | string
+  userId?: Prisma.StringWithAggregatesFilter<"QueueEntry"> | string
+  joinedAt?: Prisma.DateTimeWithAggregatesFilter<"QueueEntry"> | Date | string
+  active?: Prisma.BoolWithAggregatesFilter<"QueueEntry"> | boolean
+}
+
+export type QueueEntryCreateInput = {
+  id?: string
+  joinedAt?: Date | string
+  active?: boolean
+  user: Prisma.UserCreateNestedOneWithoutQueueEntriesInput
+}
+
+export type QueueEntryUncheckedCreateInput = {
+  id?: string
+  userId: string
+  joinedAt?: Date | string
+  active?: boolean
+}
+
+export type QueueEntryUpdateInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  joinedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  active?: Prisma.BoolFieldUpdateOperationsInput | boolean
+  user?: Prisma.UserUpdateOneRequiredWithoutQueueEntriesNestedInput
+}
+
+export type QueueEntryUncheckedUpdateInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  userId?: Prisma.StringFieldUpdateOperationsInput | string
+  joinedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  active?: Prisma.BoolFieldUpdateOperationsInput | boolean
+}
+
+export type QueueEntryCreateManyInput = {
+  id?: string
+  userId: string
+  joinedAt?: Date | string
+  active?: boolean
+}
+
+export type QueueEntryUpdateManyMutationInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  joinedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  active?: Prisma.BoolFieldUpdateOperationsInput | boolean
+}
+
+export type QueueEntryUncheckedUpdateManyInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  userId?: Prisma.StringFieldUpdateOperationsInput | string
+  joinedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  active?: Prisma.BoolFieldUpdateOperationsInput | boolean
+}
+
+export type QueueEntryListRelationFilter = {
+  every?: Prisma.QueueEntryWhereInput
+  some?: Prisma.QueueEntryWhereInput
+  none?: Prisma.QueueEntryWhereInput
+}
+
+export type QueueEntryOrderByRelationAggregateInput = {
+  _count?: Prisma.SortOrder
+}
+
+export type QueueEntryUserIdActiveCompoundUniqueInput = {
+  userId: string
+  active: boolean
+}
+
+export type QueueEntryCountOrderByAggregateInput = {
+  id?: Prisma.SortOrder
+  userId?: Prisma.SortOrder
+  joinedAt?: Prisma.SortOrder
+  active?: Prisma.SortOrder
+}
+
+export type QueueEntryMaxOrderByAggregateInput = {
+  id?: Prisma.SortOrder
+  userId?: Prisma.SortOrder
+  joinedAt?: Prisma.SortOrder
+  active?: Prisma.SortOrder
+}
+
+export type QueueEntryMinOrderByAggregateInput = {
+  id?: Prisma.SortOrder
+  userId?: Prisma.SortOrder
+  joinedAt?: Prisma.SortOrder
+  active?: Prisma.SortOrder
+}
+
+export type QueueEntryCreateNestedManyWithoutUserInput = {
+  create?: Prisma.XOR<Prisma.QueueEntryCreateWithoutUserInput, Prisma.QueueEntryUncheckedCreateWithoutUserInput> | Prisma.QueueEntryCreateWithoutUserInput[] | Prisma.QueueEntryUncheckedCreateWithoutUserInput[]
+  connectOrCreate?: Prisma.QueueEntryCreateOrConnectWithoutUserInput | Prisma.QueueEntryCreateOrConnectWithoutUserInput[]
+  createMany?: Prisma.QueueEntryCreateManyUserInputEnvelope
+  connect?: Prisma.QueueEntryWhereUniqueInput | Prisma.QueueEntryWhereUniqueInput[]
+}
+
+export type QueueEntryUncheckedCreateNestedManyWithoutUserInput = {
+  create?: Prisma.XOR<Prisma.QueueEntryCreateWithoutUserInput, Prisma.QueueEntryUncheckedCreateWithoutUserInput> | Prisma.QueueEntryCreateWithoutUserInput[] | Prisma.QueueEntryUncheckedCreateWithoutUserInput[]
+  connectOrCreate?: Prisma.QueueEntryCreateOrConnectWithoutUserInput | Prisma.QueueEntryCreateOrConnectWithoutUserInput[]
+  createMany?: Prisma.QueueEntryCreateManyUserInputEnvelope
+  connect?: Prisma.QueueEntryWhereUniqueInput | Prisma.QueueEntryWhereUniqueInput[]
+}
+
+export type QueueEntryUpdateManyWithoutUserNestedInput = {
+  create?: Prisma.XOR<Prisma.QueueEntryCreateWithoutUserInput, Prisma.QueueEntryUncheckedCreateWithoutUserInput> | Prisma.QueueEntryCreateWithoutUserInput[] | Prisma.QueueEntryUncheckedCreateWithoutUserInput[]
+  connectOrCreate?: Prisma.QueueEntryCreateOrConnectWithoutUserInput | Prisma.QueueEntryCreateOrConnectWithoutUserInput[]
+  upsert?: Prisma.QueueEntryUpsertWithWhereUniqueWithoutUserInput | Prisma.QueueEntryUpsertWithWhereUniqueWithoutUserInput[]
+  createMany?: Prisma.QueueEntryCreateManyUserInputEnvelope
+  set?: Prisma.QueueEntryWhereUniqueInput | Prisma.QueueEntryWhereUniqueInput[]
+  disconnect?: Prisma.QueueEntryWhereUniqueInput | Prisma.QueueEntryWhereUniqueInput[]
+  delete?: Prisma.QueueEntryWhereUniqueInput | Prisma.QueueEntryWhereUniqueInput[]
+  connect?: Prisma.QueueEntryWhereUniqueInput | Prisma.QueueEntryWhereUniqueInput[]
+  update?: Prisma.QueueEntryUpdateWithWhereUniqueWithoutUserInput | Prisma.QueueEntryUpdateWithWhereUniqueWithoutUserInput[]
+  updateMany?: Prisma.QueueEntryUpdateManyWithWhereWithoutUserInput | Prisma.QueueEntryUpdateManyWithWhereWithoutUserInput[]
+  deleteMany?: Prisma.QueueEntryScalarWhereInput | Prisma.QueueEntryScalarWhereInput[]
+}
+
+export type QueueEntryUncheckedUpdateManyWithoutUserNestedInput = {
+  create?: Prisma.XOR<Prisma.QueueEntryCreateWithoutUserInput, Prisma.QueueEntryUncheckedCreateWithoutUserInput> | Prisma.QueueEntryCreateWithoutUserInput[] | Prisma.QueueEntryUncheckedCreateWithoutUserInput[]
+  connectOrCreate?: Prisma.QueueEntryCreateOrConnectWithoutUserInput | Prisma.QueueEntryCreateOrConnectWithoutUserInput[]
+  upsert?: Prisma.QueueEntryUpsertWithWhereUniqueWithoutUserInput | Prisma.QueueEntryUpsertWithWhereUniqueWithoutUserInput[]
+  createMany?: Prisma.QueueEntryCreateManyUserInputEnvelope
+  set?: Prisma.QueueEntryWhereUniqueInput | Prisma.QueueEntryWhereUniqueInput[]
+  disconnect?: Prisma.QueueEntryWhereUniqueInput | Prisma.QueueEntryWhereUniqueInput[]
+  delete?: Prisma.QueueEntryWhereUniqueInput | Prisma.QueueEntryWhereUniqueInput[]
+  connect?: Prisma.QueueEntryWhereUniqueInput | Prisma.QueueEntryWhereUniqueInput[]
+  update?: Prisma.QueueEntryUpdateWithWhereUniqueWithoutUserInput | Prisma.QueueEntryUpdateWithWhereUniqueWithoutUserInput[]
+  updateMany?: Prisma.QueueEntryUpdateManyWithWhereWithoutUserInput | Prisma.QueueEntryUpdateManyWithWhereWithoutUserInput[]
+  deleteMany?: Prisma.QueueEntryScalarWhereInput | Prisma.QueueEntryScalarWhereInput[]
+}
+
+export type BoolFieldUpdateOperationsInput = {
+  set?: boolean
+}
+
+export type QueueEntryCreateWithoutUserInput = {
+  id?: string
+  joinedAt?: Date | string
+  active?: boolean
+}
+
+export type QueueEntryUncheckedCreateWithoutUserInput = {
+  id?: string
+  joinedAt?: Date | string
+  active?: boolean
+}
+
+export type QueueEntryCreateOrConnectWithoutUserInput = {
+  where: Prisma.QueueEntryWhereUniqueInput
+  create: Prisma.XOR<Prisma.QueueEntryCreateWithoutUserInput, Prisma.QueueEntryUncheckedCreateWithoutUserInput>
+}
+
+export type QueueEntryCreateManyUserInputEnvelope = {
+  data: Prisma.QueueEntryCreateManyUserInput | Prisma.QueueEntryCreateManyUserInput[]
+  skipDuplicates?: boolean
+}
+
+export type QueueEntryUpsertWithWhereUniqueWithoutUserInput = {
+  where: Prisma.QueueEntryWhereUniqueInput
+  update: Prisma.XOR<Prisma.QueueEntryUpdateWithoutUserInput, Prisma.QueueEntryUncheckedUpdateWithoutUserInput>
+  create: Prisma.XOR<Prisma.QueueEntryCreateWithoutUserInput, Prisma.QueueEntryUncheckedCreateWithoutUserInput>
+}
+
+export type QueueEntryUpdateWithWhereUniqueWithoutUserInput = {
+  where: Prisma.QueueEntryWhereUniqueInput
+  data: Prisma.XOR<Prisma.QueueEntryUpdateWithoutUserInput, Prisma.QueueEntryUncheckedUpdateWithoutUserInput>
+}
+
+export type QueueEntryUpdateManyWithWhereWithoutUserInput = {
+  where: Prisma.QueueEntryScalarWhereInput
+  data: Prisma.XOR<Prisma.QueueEntryUpdateManyMutationInput, Prisma.QueueEntryUncheckedUpdateManyWithoutUserInput>
+}
+
+export type QueueEntryScalarWhereInput = {
+  AND?: Prisma.QueueEntryScalarWhereInput | Prisma.QueueEntryScalarWhereInput[]
+  OR?: Prisma.QueueEntryScalarWhereInput[]
+  NOT?: Prisma.QueueEntryScalarWhereInput | Prisma.QueueEntryScalarWhereInput[]
+  id?: Prisma.StringFilter<"QueueEntry"> | string
+  userId?: Prisma.StringFilter<"QueueEntry"> | string
+  joinedAt?: Prisma.DateTimeFilter<"QueueEntry"> | Date | string
+  active?: Prisma.BoolFilter<"QueueEntry"> | boolean
+}
+
+export type QueueEntryCreateManyUserInput = {
+  id?: string
+  joinedAt?: Date | string
+  active?: boolean
+}
+
+export type QueueEntryUpdateWithoutUserInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  joinedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  active?: Prisma.BoolFieldUpdateOperationsInput | boolean
+}
+
+export type QueueEntryUncheckedUpdateWithoutUserInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  joinedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  active?: Prisma.BoolFieldUpdateOperationsInput | boolean
+}
+
+export type QueueEntryUncheckedUpdateManyWithoutUserInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  joinedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  active?: Prisma.BoolFieldUpdateOperationsInput | boolean
+}
+
+
+
+export type QueueEntrySelect<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
+  id?: boolean
+  userId?: boolean
+  joinedAt?: boolean
+  active?: boolean
+  user?: boolean | Prisma.UserDefaultArgs<ExtArgs>
+}, ExtArgs["result"]["queueEntry"]>
+
+export type QueueEntrySelectCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
+  id?: boolean
+  userId?: boolean
+  joinedAt?: boolean
+  active?: boolean
+  user?: boolean | Prisma.UserDefaultArgs<ExtArgs>
+}, ExtArgs["result"]["queueEntry"]>
+
+export type QueueEntrySelectUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
+  id?: boolean
+  userId?: boolean
+  joinedAt?: boolean
+  active?: boolean
+  user?: boolean | Prisma.UserDefaultArgs<ExtArgs>
+}, ExtArgs["result"]["queueEntry"]>
+
+export type QueueEntrySelectScalar = {
+  id?: boolean
+  userId?: boolean
+  joinedAt?: boolean
+  active?: boolean
+}
+
+export type QueueEntryOmit<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetOmit<"id" | "userId" | "joinedAt" | "active", ExtArgs["result"]["queueEntry"]>
+export type QueueEntryInclude<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  user?: boolean | Prisma.UserDefaultArgs<ExtArgs>
+}
+export type QueueEntryIncludeCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  user?: boolean | Prisma.UserDefaultArgs<ExtArgs>
+}
+export type QueueEntryIncludeUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  user?: boolean | Prisma.UserDefaultArgs<ExtArgs>
+}
+
+export type $QueueEntryPayload<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  name: "QueueEntry"
+  objects: {
+    user: Prisma.$UserPayload<ExtArgs>
+  }
+  scalars: runtime.Types.Extensions.GetPayloadResult<{
+    id: string
+    userId: string
+    joinedAt: Date
+    active: boolean
+  }, ExtArgs["result"]["queueEntry"]>
+  composites: {}
+}
+
+export type QueueEntryGetPayload<S extends boolean | null | undefined | QueueEntryDefaultArgs> = runtime.Types.Result.GetResult<Prisma.$QueueEntryPayload, S>
+
+export type QueueEntryCountArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> =
+  Omit<QueueEntryFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
+    select?: QueueEntryCountAggregateInputType | true
+  }
+
+export interface QueueEntryDelegate<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> {
+  [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['QueueEntry'], meta: { name: 'QueueEntry' } }
+  /**
+   * Find zero or one QueueEntry that matches the filter.
+   * @param {QueueEntryFindUniqueArgs} args - Arguments to find a QueueEntry
+   * @example
+   * // Get one QueueEntry
+   * const queueEntry = await prisma.queueEntry.findUnique({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   */
+  findUnique<T extends QueueEntryFindUniqueArgs>(args: Prisma.SelectSubset<T, QueueEntryFindUniqueArgs<ExtArgs>>): Prisma.Prisma__QueueEntryClient<runtime.Types.Result.GetResult<Prisma.$QueueEntryPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Find one QueueEntry that matches the filter or throw an error with `error.code='P2025'`
+   * if no matches were found.
+   * @param {QueueEntryFindUniqueOrThrowArgs} args - Arguments to find a QueueEntry
+   * @example
+   * // Get one QueueEntry
+   * const queueEntry = await prisma.queueEntry.findUniqueOrThrow({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   */
+  findUniqueOrThrow<T extends QueueEntryFindUniqueOrThrowArgs>(args: Prisma.SelectSubset<T, QueueEntryFindUniqueOrThrowArgs<ExtArgs>>): Prisma.Prisma__QueueEntryClient<runtime.Types.Result.GetResult<Prisma.$QueueEntryPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Find the first QueueEntry that matches the filter.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {QueueEntryFindFirstArgs} args - Arguments to find a QueueEntry
+   * @example
+   * // Get one QueueEntry
+   * const queueEntry = await prisma.queueEntry.findFirst({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   */
+  findFirst<T extends QueueEntryFindFirstArgs>(args?: Prisma.SelectSubset<T, QueueEntryFindFirstArgs<ExtArgs>>): Prisma.Prisma__QueueEntryClient<runtime.Types.Result.GetResult<Prisma.$QueueEntryPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Find the first QueueEntry that matches the filter or
+   * throw `PrismaKnownClientError` with `P2025` code if no matches were found.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {QueueEntryFindFirstOrThrowArgs} args - Arguments to find a QueueEntry
+   * @example
+   * // Get one QueueEntry
+   * const queueEntry = await prisma.queueEntry.findFirstOrThrow({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   */
+  findFirstOrThrow<T extends QueueEntryFindFirstOrThrowArgs>(args?: Prisma.SelectSubset<T, QueueEntryFindFirstOrThrowArgs<ExtArgs>>): Prisma.Prisma__QueueEntryClient<runtime.Types.Result.GetResult<Prisma.$QueueEntryPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Find zero or more QueueEntries that matches the filter.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {QueueEntryFindManyArgs} args - Arguments to filter and select certain fields only.
+   * @example
+   * // Get all QueueEntries
+   * const queueEntries = await prisma.queueEntry.findMany()
+   * 
+   * // Get first 10 QueueEntries
+   * const queueEntries = await prisma.queueEntry.findMany({ take: 10 })
+   * 
+   * // Only select the `id`
+   * const queueEntryWithIdOnly = await prisma.queueEntry.findMany({ select: { id: true } })
+   * 
+   */
+  findMany<T extends QueueEntryFindManyArgs>(args?: Prisma.SelectSubset<T, QueueEntryFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$QueueEntryPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>
+
+  /**
+   * Create a QueueEntry.
+   * @param {QueueEntryCreateArgs} args - Arguments to create a QueueEntry.
+   * @example
+   * // Create one QueueEntry
+   * const QueueEntry = await prisma.queueEntry.create({
+   *   data: {
+   *     // ... data to create a QueueEntry
+   *   }
+   * })
+   * 
+   */
+  create<T extends QueueEntryCreateArgs>(args: Prisma.SelectSubset<T, QueueEntryCreateArgs<ExtArgs>>): Prisma.Prisma__QueueEntryClient<runtime.Types.Result.GetResult<Prisma.$QueueEntryPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Create many QueueEntries.
+   * @param {QueueEntryCreateManyArgs} args - Arguments to create many QueueEntries.
+   * @example
+   * // Create many QueueEntries
+   * const queueEntry = await prisma.queueEntry.createMany({
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   *     
+   */
+  createMany<T extends QueueEntryCreateManyArgs>(args?: Prisma.SelectSubset<T, QueueEntryCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>
+
+  /**
+   * Create many QueueEntries and returns the data saved in the database.
+   * @param {QueueEntryCreateManyAndReturnArgs} args - Arguments to create many QueueEntries.
+   * @example
+   * // Create many QueueEntries
+   * const queueEntry = await prisma.queueEntry.createManyAndReturn({
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   * 
+   * // Create many QueueEntries and only return the `id`
+   * const queueEntryWithIdOnly = await prisma.queueEntry.createManyAndReturn({
+   *   select: { id: true },
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * 
+   */
+  createManyAndReturn<T extends QueueEntryCreateManyAndReturnArgs>(args?: Prisma.SelectSubset<T, QueueEntryCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$QueueEntryPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>
+
+  /**
+   * Delete a QueueEntry.
+   * @param {QueueEntryDeleteArgs} args - Arguments to delete one QueueEntry.
+   * @example
+   * // Delete one QueueEntry
+   * const QueueEntry = await prisma.queueEntry.delete({
+   *   where: {
+   *     // ... filter to delete one QueueEntry
+   *   }
+   * })
+   * 
+   */
+  delete<T extends QueueEntryDeleteArgs>(args: Prisma.SelectSubset<T, QueueEntryDeleteArgs<ExtArgs>>): Prisma.Prisma__QueueEntryClient<runtime.Types.Result.GetResult<Prisma.$QueueEntryPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Update one QueueEntry.
+   * @param {QueueEntryUpdateArgs} args - Arguments to update one QueueEntry.
+   * @example
+   * // Update one QueueEntry
+   * const queueEntry = await prisma.queueEntry.update({
+   *   where: {
+   *     // ... provide filter here
+   *   },
+   *   data: {
+   *     // ... provide data here
+   *   }
+   * })
+   * 
+   */
+  update<T extends QueueEntryUpdateArgs>(args: Prisma.SelectSubset<T, QueueEntryUpdateArgs<ExtArgs>>): Prisma.Prisma__QueueEntryClient<runtime.Types.Result.GetResult<Prisma.$QueueEntryPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Delete zero or more QueueEntries.
+   * @param {QueueEntryDeleteManyArgs} args - Arguments to filter QueueEntries to delete.
+   * @example
+   * // Delete a few QueueEntries
+   * const { count } = await prisma.queueEntry.deleteMany({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   * 
+   */
+  deleteMany<T extends QueueEntryDeleteManyArgs>(args?: Prisma.SelectSubset<T, QueueEntryDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>
+
+  /**
+   * Update zero or more QueueEntries.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {QueueEntryUpdateManyArgs} args - Arguments to update one or more rows.
+   * @example
+   * // Update many QueueEntries
+   * const queueEntry = await prisma.queueEntry.updateMany({
+   *   where: {
+   *     // ... provide filter here
+   *   },
+   *   data: {
+   *     // ... provide data here
+   *   }
+   * })
+   * 
+   */
+  updateMany<T extends QueueEntryUpdateManyArgs>(args: Prisma.SelectSubset<T, QueueEntryUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>
+
+  /**
+   * Update zero or more QueueEntries and returns the data updated in the database.
+   * @param {QueueEntryUpdateManyAndReturnArgs} args - Arguments to update many QueueEntries.
+   * @example
+   * // Update many QueueEntries
+   * const queueEntry = await prisma.queueEntry.updateManyAndReturn({
+   *   where: {
+   *     // ... provide filter here
+   *   },
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   * 
+   * // Update zero or more QueueEntries and only return the `id`
+   * const queueEntryWithIdOnly = await prisma.queueEntry.updateManyAndReturn({
+   *   select: { id: true },
+   *   where: {
+   *     // ... provide filter here
+   *   },
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * 
+   */
+  updateManyAndReturn<T extends QueueEntryUpdateManyAndReturnArgs>(args: Prisma.SelectSubset<T, QueueEntryUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$QueueEntryPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>
+
+  /**
+   * Create or update one QueueEntry.
+   * @param {QueueEntryUpsertArgs} args - Arguments to update or create a QueueEntry.
+   * @example
+   * // Update or create a QueueEntry
+   * const queueEntry = await prisma.queueEntry.upsert({
+   *   create: {
+   *     // ... data to create a QueueEntry
+   *   },
+   *   update: {
+   *     // ... in case it already exists, update
+   *   },
+   *   where: {
+   *     // ... the filter for the QueueEntry we want to update
+   *   }
+   * })
+   */
+  upsert<T extends QueueEntryUpsertArgs>(args: Prisma.SelectSubset<T, QueueEntryUpsertArgs<ExtArgs>>): Prisma.Prisma__QueueEntryClient<runtime.Types.Result.GetResult<Prisma.$QueueEntryPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+
+  /**
+   * Count the number of QueueEntries.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {QueueEntryCountArgs} args - Arguments to filter QueueEntries to count.
+   * @example
+   * // Count the number of QueueEntries
+   * const count = await prisma.queueEntry.count({
+   *   where: {
+   *     // ... the filter for the QueueEntries we want to count
+   *   }
+   * })
+  **/
+  count<T extends QueueEntryCountArgs>(
+    args?: Prisma.Subset<T, QueueEntryCountArgs>,
+  ): Prisma.PrismaPromise<
+    T extends runtime.Types.Utils.Record<'select', any>
+      ? T['select'] extends true
+        ? number
+        : Prisma.GetScalarType<T['select'], QueueEntryCountAggregateOutputType>
+      : number
+  >
+
+  /**
+   * Allows you to perform aggregations operations on a QueueEntry.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {QueueEntryAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
+   * @example
+   * // Ordered by age ascending
+   * // Where email contains prisma.io
+   * // Limited to the 10 users
+   * const aggregations = await prisma.user.aggregate({
+   *   _avg: {
+   *     age: true,
+   *   },
+   *   where: {
+   *     email: {
+   *       contains: "prisma.io",
+   *     },
+   *   },
+   *   orderBy: {
+   *     age: "asc",
+   *   },
+   *   take: 10,
+   * })
+  **/
+  aggregate<T extends QueueEntryAggregateArgs>(args: Prisma.Subset<T, QueueEntryAggregateArgs>): Prisma.PrismaPromise<GetQueueEntryAggregateType<T>>
+
+  /**
+   * Group by QueueEntry.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {QueueEntryGroupByArgs} args - Group by arguments.
+   * @example
+   * // Group by city, order by createdAt, get count
+   * const result = await prisma.user.groupBy({
+   *   by: ['city', 'createdAt'],
+   *   orderBy: {
+   *     createdAt: true
+   *   },
+   *   _count: {
+   *     _all: true
+   *   },
+   * })
+   * 
+  **/
+  groupBy<
+    T extends QueueEntryGroupByArgs,
+    HasSelectOrTake extends Prisma.Or<
+      Prisma.Extends<'skip', Prisma.Keys<T>>,
+      Prisma.Extends<'take', Prisma.Keys<T>>
+    >,
+    OrderByArg extends Prisma.True extends HasSelectOrTake
+      ? { orderBy: QueueEntryGroupByArgs['orderBy'] }
+      : { orderBy?: QueueEntryGroupByArgs['orderBy'] },
+    OrderFields extends Prisma.ExcludeUnderscoreKeys<Prisma.Keys<Prisma.MaybeTupleToUnion<T['orderBy']>>>,
+    ByFields extends Prisma.MaybeTupleToUnion<T['by']>,
+    ByValid extends Prisma.Has<ByFields, OrderFields>,
+    HavingFields extends Prisma.GetHavingFields<T['having']>,
+    HavingValid extends Prisma.Has<ByFields, HavingFields>,
+    ByEmpty extends T['by'] extends never[] ? Prisma.True : Prisma.False,
+    InputErrors extends ByEmpty extends Prisma.True
+    ? `Error: "by" must not be empty.`
+    : HavingValid extends Prisma.False
+    ? {
+        [P in HavingFields]: P extends ByFields
+          ? never
+          : P extends string
+          ? `Error: Field "${P}" used in "having" needs to be provided in "by".`
+          : [
+              Error,
+              'Field ',
+              P,
+              ` in "having" needs to be provided in "by"`,
+            ]
+      }[HavingFields]
+    : 'take' extends Prisma.Keys<T>
+    ? 'orderBy' extends Prisma.Keys<T>
+      ? ByValid extends Prisma.True
+        ? {}
+        : {
+            [P in OrderFields]: P extends ByFields
+              ? never
+              : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
+          }[OrderFields]
+      : 'Error: If you provide "take", you also need to provide "orderBy"'
+    : 'skip' extends Prisma.Keys<T>
+    ? 'orderBy' extends Prisma.Keys<T>
+      ? ByValid extends Prisma.True
+        ? {}
+        : {
+            [P in OrderFields]: P extends ByFields
+              ? never
+              : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
+          }[OrderFields]
+      : 'Error: If you provide "skip", you also need to provide "orderBy"'
+    : ByValid extends Prisma.True
+    ? {}
+    : {
+        [P in OrderFields]: P extends ByFields
+          ? never
+          : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
+      }[OrderFields]
+  >(args: Prisma.SubsetIntersection<T, QueueEntryGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetQueueEntryGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
+/**
+ * Fields of the QueueEntry model
+ */
+readonly fields: QueueEntryFieldRefs;
+}
+
+/**
+ * The delegate class that acts as a "Promise-like" for QueueEntry.
+ * Why is this prefixed with `Prisma__`?
+ * Because we want to prevent naming conflicts as mentioned in
+ * https://github.com/prisma/prisma-client-js/issues/707
+ */
+export interface Prisma__QueueEntryClient<T, Null = never, ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
+  readonly [Symbol.toStringTag]: "PrismaPromise"
+  user<T extends Prisma.UserDefaultArgs<ExtArgs> = {}>(args?: Prisma.Subset<T, Prisma.UserDefaultArgs<ExtArgs>>): Prisma.Prisma__UserClient<runtime.Types.Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
+  /**
+   * Attaches callbacks for the resolution and/or rejection of the Promise.
+   * @param onfulfilled The callback to execute when the Promise is resolved.
+   * @param onrejected The callback to execute when the Promise is rejected.
+   * @returns A Promise for the completion of which ever callback is executed.
+   */
+  then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): runtime.Types.Utils.JsPromise<TResult1 | TResult2>
+  /**
+   * Attaches a callback for only the rejection of the Promise.
+   * @param onrejected The callback to execute when the Promise is rejected.
+   * @returns A Promise for the completion of the callback.
+   */
+  catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): runtime.Types.Utils.JsPromise<T | TResult>
+  /**
+   * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
+   * resolved value cannot be modified from the callback.
+   * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
+   * @returns A Promise for the completion of the callback.
+   */
+  finally(onfinally?: (() => void) | undefined | null): runtime.Types.Utils.JsPromise<T>
+}
+
+
+
+
+/**
+ * Fields of the QueueEntry model
+ */
+export interface QueueEntryFieldRefs {
+  readonly id: Prisma.FieldRef<"QueueEntry", 'String'>
+  readonly userId: Prisma.FieldRef<"QueueEntry", 'String'>
+  readonly joinedAt: Prisma.FieldRef<"QueueEntry", 'DateTime'>
+  readonly active: Prisma.FieldRef<"QueueEntry", 'Boolean'>
+}
+    
+
+// Custom InputTypes
+/**
+ * QueueEntry findUnique
+ */
+export type QueueEntryFindUniqueArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the QueueEntry
+   */
+  select?: Prisma.QueueEntrySelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the QueueEntry
+   */
+  omit?: Prisma.QueueEntryOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.QueueEntryInclude<ExtArgs> | null
+  /**
+   * Filter, which QueueEntry to fetch.
+   */
+  where: Prisma.QueueEntryWhereUniqueInput
+}
+
+/**
+ * QueueEntry findUniqueOrThrow
+ */
+export type QueueEntryFindUniqueOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the QueueEntry
+   */
+  select?: Prisma.QueueEntrySelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the QueueEntry
+   */
+  omit?: Prisma.QueueEntryOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.QueueEntryInclude<ExtArgs> | null
+  /**
+   * Filter, which QueueEntry to fetch.
+   */
+  where: Prisma.QueueEntryWhereUniqueInput
+}
+
+/**
+ * QueueEntry findFirst
+ */
+export type QueueEntryFindFirstArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the QueueEntry
+   */
+  select?: Prisma.QueueEntrySelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the QueueEntry
+   */
+  omit?: Prisma.QueueEntryOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.QueueEntryInclude<ExtArgs> | null
+  /**
+   * Filter, which QueueEntry to fetch.
+   */
+  where?: Prisma.QueueEntryWhereInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+   * 
+   * Determine the order of QueueEntries to fetch.
+   */
+  orderBy?: Prisma.QueueEntryOrderByWithRelationInput | Prisma.QueueEntryOrderByWithRelationInput[]
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+   * 
+   * Sets the position for searching for QueueEntries.
+   */
+  cursor?: Prisma.QueueEntryWhereUniqueInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Take `±n` QueueEntries from the position of the cursor.
+   */
+  take?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Skip the first `n` QueueEntries.
+   */
+  skip?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+   * 
+   * Filter by unique combinations of QueueEntries.
+   */
+  distinct?: Prisma.QueueEntryScalarFieldEnum | Prisma.QueueEntryScalarFieldEnum[]
+}
+
+/**
+ * QueueEntry findFirstOrThrow
+ */
+export type QueueEntryFindFirstOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the QueueEntry
+   */
+  select?: Prisma.QueueEntrySelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the QueueEntry
+   */
+  omit?: Prisma.QueueEntryOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.QueueEntryInclude<ExtArgs> | null
+  /**
+   * Filter, which QueueEntry to fetch.
+   */
+  where?: Prisma.QueueEntryWhereInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+   * 
+   * Determine the order of QueueEntries to fetch.
+   */
+  orderBy?: Prisma.QueueEntryOrderByWithRelationInput | Prisma.QueueEntryOrderByWithRelationInput[]
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+   * 
+   * Sets the position for searching for QueueEntries.
+   */
+  cursor?: Prisma.QueueEntryWhereUniqueInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Take `±n` QueueEntries from the position of the cursor.
+   */
+  take?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Skip the first `n` QueueEntries.
+   */
+  skip?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+   * 
+   * Filter by unique combinations of QueueEntries.
+   */
+  distinct?: Prisma.QueueEntryScalarFieldEnum | Prisma.QueueEntryScalarFieldEnum[]
+}
+
+/**
+ * QueueEntry findMany
+ */
+export type QueueEntryFindManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the QueueEntry
+   */
+  select?: Prisma.QueueEntrySelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the QueueEntry
+   */
+  omit?: Prisma.QueueEntryOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.QueueEntryInclude<ExtArgs> | null
+  /**
+   * Filter, which QueueEntries to fetch.
+   */
+  where?: Prisma.QueueEntryWhereInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+   * 
+   * Determine the order of QueueEntries to fetch.
+   */
+  orderBy?: Prisma.QueueEntryOrderByWithRelationInput | Prisma.QueueEntryOrderByWithRelationInput[]
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+   * 
+   * Sets the position for listing QueueEntries.
+   */
+  cursor?: Prisma.QueueEntryWhereUniqueInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Take `±n` QueueEntries from the position of the cursor.
+   */
+  take?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Skip the first `n` QueueEntries.
+   */
+  skip?: number
+  distinct?: Prisma.QueueEntryScalarFieldEnum | Prisma.QueueEntryScalarFieldEnum[]
+}
+
+/**
+ * QueueEntry create
+ */
+export type QueueEntryCreateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the QueueEntry
+   */
+  select?: Prisma.QueueEntrySelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the QueueEntry
+   */
+  omit?: Prisma.QueueEntryOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.QueueEntryInclude<ExtArgs> | null
+  /**
+   * The data needed to create a QueueEntry.
+   */
+  data: Prisma.XOR<Prisma.QueueEntryCreateInput, Prisma.QueueEntryUncheckedCreateInput>
+}
+
+/**
+ * QueueEntry createMany
+ */
+export type QueueEntryCreateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * The data used to create many QueueEntries.
+   */
+  data: Prisma.QueueEntryCreateManyInput | Prisma.QueueEntryCreateManyInput[]
+  skipDuplicates?: boolean
+}
+
+/**
+ * QueueEntry createManyAndReturn
+ */
+export type QueueEntryCreateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the QueueEntry
+   */
+  select?: Prisma.QueueEntrySelectCreateManyAndReturn<ExtArgs> | null
+  /**
+   * Omit specific fields from the QueueEntry
+   */
+  omit?: Prisma.QueueEntryOmit<ExtArgs> | null
+  /**
+   * The data used to create many QueueEntries.
+   */
+  data: Prisma.QueueEntryCreateManyInput | Prisma.QueueEntryCreateManyInput[]
+  skipDuplicates?: boolean
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.QueueEntryIncludeCreateManyAndReturn<ExtArgs> | null
+}
+
+/**
+ * QueueEntry update
+ */
+export type QueueEntryUpdateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the QueueEntry
+   */
+  select?: Prisma.QueueEntrySelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the QueueEntry
+   */
+  omit?: Prisma.QueueEntryOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.QueueEntryInclude<ExtArgs> | null
+  /**
+   * The data needed to update a QueueEntry.
+   */
+  data: Prisma.XOR<Prisma.QueueEntryUpdateInput, Prisma.QueueEntryUncheckedUpdateInput>
+  /**
+   * Choose, which QueueEntry to update.
+   */
+  where: Prisma.QueueEntryWhereUniqueInput
+}
+
+/**
+ * QueueEntry updateMany
+ */
+export type QueueEntryUpdateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * The data used to update QueueEntries.
+   */
+  data: Prisma.XOR<Prisma.QueueEntryUpdateManyMutationInput, Prisma.QueueEntryUncheckedUpdateManyInput>
+  /**
+   * Filter which QueueEntries to update
+   */
+  where?: Prisma.QueueEntryWhereInput
+  /**
+   * Limit how many QueueEntries to update.
+   */
+  limit?: number
+}
+
+/**
+ * QueueEntry updateManyAndReturn
+ */
+export type QueueEntryUpdateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the QueueEntry
+   */
+  select?: Prisma.QueueEntrySelectUpdateManyAndReturn<ExtArgs> | null
+  /**
+   * Omit specific fields from the QueueEntry
+   */
+  omit?: Prisma.QueueEntryOmit<ExtArgs> | null
+  /**
+   * The data used to update QueueEntries.
+   */
+  data: Prisma.XOR<Prisma.QueueEntryUpdateManyMutationInput, Prisma.QueueEntryUncheckedUpdateManyInput>
+  /**
+   * Filter which QueueEntries to update
+   */
+  where?: Prisma.QueueEntryWhereInput
+  /**
+   * Limit how many QueueEntries to update.
+   */
+  limit?: number
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.QueueEntryIncludeUpdateManyAndReturn<ExtArgs> | null
+}
+
+/**
+ * QueueEntry upsert
+ */
+export type QueueEntryUpsertArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the QueueEntry
+   */
+  select?: Prisma.QueueEntrySelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the QueueEntry
+   */
+  omit?: Prisma.QueueEntryOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.QueueEntryInclude<ExtArgs> | null
+  /**
+   * The filter to search for the QueueEntry to update in case it exists.
+   */
+  where: Prisma.QueueEntryWhereUniqueInput
+  /**
+   * In case the QueueEntry found by the `where` argument doesn't exist, create a new QueueEntry with this data.
+   */
+  create: Prisma.XOR<Prisma.QueueEntryCreateInput, Prisma.QueueEntryUncheckedCreateInput>
+  /**
+   * In case the QueueEntry was found with the provided `where` argument, update it with this data.
+   */
+  update: Prisma.XOR<Prisma.QueueEntryUpdateInput, Prisma.QueueEntryUncheckedUpdateInput>
+}
+
+/**
+ * QueueEntry delete
+ */
+export type QueueEntryDeleteArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the QueueEntry
+   */
+  select?: Prisma.QueueEntrySelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the QueueEntry
+   */
+  omit?: Prisma.QueueEntryOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.QueueEntryInclude<ExtArgs> | null
+  /**
+   * Filter which QueueEntry to delete.
+   */
+  where: Prisma.QueueEntryWhereUniqueInput
+}
+
+/**
+ * QueueEntry deleteMany
+ */
+export type QueueEntryDeleteManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Filter which QueueEntries to delete
+   */
+  where?: Prisma.QueueEntryWhereInput
+  /**
+   * Limit how many QueueEntries to delete.
+   */
+  limit?: number
+}
+
+/**
+ * QueueEntry without action
+ */
+export type QueueEntryDefaultArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the QueueEntry
+   */
+  select?: Prisma.QueueEntrySelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the QueueEntry
+   */
+  omit?: Prisma.QueueEntryOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.QueueEntryInclude<ExtArgs> | null
+}
diff --git a/prisma/generated/prisma/models/Submission.ts b/prisma/generated/prisma/models/Submission.ts
new file mode 100644
index 0000000..2bfefde
--- /dev/null
+++ b/prisma/generated/prisma/models/Submission.ts
@@ -0,0 +1,2377 @@
+
+/* !!! This is code generated by Prisma. Do not edit directly. !!! */
+/* eslint-disable */
+// biome-ignore-all lint: generated file
+// @ts-nocheck 
+/*
+ * This file exports the `Submission` model and its related types.
+ *
+ * 🟢 You can import this file directly.
+ */
+import type * as runtime from "@prisma/client/runtime/client"
+import type * as $Enums from "../enums"
+import type * as Prisma from "../internal/prismaNamespace"
+
+/**
+ * Model Submission
+ * 
+ */
+export type SubmissionModel = runtime.Types.Result.DefaultSelection<Prisma.$SubmissionPayload>
+
+export type AggregateSubmission = {
+  _count: SubmissionCountAggregateOutputType | null
+  _avg: SubmissionAvgAggregateOutputType | null
+  _sum: SubmissionSumAggregateOutputType | null
+  _min: SubmissionMinAggregateOutputType | null
+  _max: SubmissionMaxAggregateOutputType | null
+}
+
+export type SubmissionAvgAggregateOutputType = {
+  charCount: number | null
+  exitCode: number | null
+  execTimeMs: number | null
+  testsPassed: number | null
+  testsTotal: number | null
+  timeScore: number | null
+  spaceScore: number | null
+  originalityScore: number | null
+  relevanceScore: number | null
+}
+
+export type SubmissionSumAggregateOutputType = {
+  charCount: number | null
+  exitCode: number | null
+  execTimeMs: number | null
+  testsPassed: number | null
+  testsTotal: number | null
+  timeScore: number | null
+  spaceScore: number | null
+  originalityScore: number | null
+  relevanceScore: number | null
+}
+
+export type SubmissionMinAggregateOutputType = {
+  id: string | null
+  matchId: string | null
+  userId: string | null
+  questionId: string | null
+  code: string | null
+  language: string | null
+  charCount: number | null
+  stdout: string | null
+  stderr: string | null
+  exitCode: number | null
+  execTimeMs: number | null
+  testsPassed: number | null
+  testsTotal: number | null
+  timeComplexity: string | null
+  timeScore: number | null
+  spaceComplexity: string | null
+  spaceScore: number | null
+  originalityScore: number | null
+  relevanceScore: number | null
+  submittedAt: Date | null
+}
+
+export type SubmissionMaxAggregateOutputType = {
+  id: string | null
+  matchId: string | null
+  userId: string | null
+  questionId: string | null
+  code: string | null
+  language: string | null
+  charCount: number | null
+  stdout: string | null
+  stderr: string | null
+  exitCode: number | null
+  execTimeMs: number | null
+  testsPassed: number | null
+  testsTotal: number | null
+  timeComplexity: string | null
+  timeScore: number | null
+  spaceComplexity: string | null
+  spaceScore: number | null
+  originalityScore: number | null
+  relevanceScore: number | null
+  submittedAt: Date | null
+}
+
+export type SubmissionCountAggregateOutputType = {
+  id: number
+  matchId: number
+  userId: number
+  questionId: number
+  code: number
+  language: number
+  charCount: number
+  stdout: number
+  stderr: number
+  exitCode: number
+  execTimeMs: number
+  testsPassed: number
+  testsTotal: number
+  timeComplexity: number
+  timeScore: number
+  spaceComplexity: number
+  spaceScore: number
+  originalityScore: number
+  relevanceScore: number
+  submittedAt: number
+  _all: number
+}
+
+
+export type SubmissionAvgAggregateInputType = {
+  charCount?: true
+  exitCode?: true
+  execTimeMs?: true
+  testsPassed?: true
+  testsTotal?: true
+  timeScore?: true
+  spaceScore?: true
+  originalityScore?: true
+  relevanceScore?: true
+}
+
+export type SubmissionSumAggregateInputType = {
+  charCount?: true
+  exitCode?: true
+  execTimeMs?: true
+  testsPassed?: true
+  testsTotal?: true
+  timeScore?: true
+  spaceScore?: true
+  originalityScore?: true
+  relevanceScore?: true
+}
+
+export type SubmissionMinAggregateInputType = {
+  id?: true
+  matchId?: true
+  userId?: true
+  questionId?: true
+  code?: true
+  language?: true
+  charCount?: true
+  stdout?: true
+  stderr?: true
+  exitCode?: true
+  execTimeMs?: true
+  testsPassed?: true
+  testsTotal?: true
+  timeComplexity?: true
+  timeScore?: true
+  spaceComplexity?: true
+  spaceScore?: true
+  originalityScore?: true
+  relevanceScore?: true
+  submittedAt?: true
+}
+
+export type SubmissionMaxAggregateInputType = {
+  id?: true
+  matchId?: true
+  userId?: true
+  questionId?: true
+  code?: true
+  language?: true
+  charCount?: true
+  stdout?: true
+  stderr?: true
+  exitCode?: true
+  execTimeMs?: true
+  testsPassed?: true
+  testsTotal?: true
+  timeComplexity?: true
+  timeScore?: true
+  spaceComplexity?: true
+  spaceScore?: true
+  originalityScore?: true
+  relevanceScore?: true
+  submittedAt?: true
+}
+
+export type SubmissionCountAggregateInputType = {
+  id?: true
+  matchId?: true
+  userId?: true
+  questionId?: true
+  code?: true
+  language?: true
+  charCount?: true
+  stdout?: true
+  stderr?: true
+  exitCode?: true
+  execTimeMs?: true
+  testsPassed?: true
+  testsTotal?: true
+  timeComplexity?: true
+  timeScore?: true
+  spaceComplexity?: true
+  spaceScore?: true
+  originalityScore?: true
+  relevanceScore?: true
+  submittedAt?: true
+  _all?: true
+}
+
+export type SubmissionAggregateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Filter which Submission to aggregate.
+   */
+  where?: Prisma.SubmissionWhereInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+   * 
+   * Determine the order of Submissions to fetch.
+   */
+  orderBy?: Prisma.SubmissionOrderByWithRelationInput | Prisma.SubmissionOrderByWithRelationInput[]
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+   * 
+   * Sets the start position
+   */
+  cursor?: Prisma.SubmissionWhereUniqueInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Take `±n` Submissions from the position of the cursor.
+   */
+  take?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Skip the first `n` Submissions.
+   */
+  skip?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Count returned Submissions
+  **/
+  _count?: true | SubmissionCountAggregateInputType
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Select which fields to average
+  **/
+  _avg?: SubmissionAvgAggregateInputType
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Select which fields to sum
+  **/
+  _sum?: SubmissionSumAggregateInputType
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Select which fields to find the minimum value
+  **/
+  _min?: SubmissionMinAggregateInputType
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Select which fields to find the maximum value
+  **/
+  _max?: SubmissionMaxAggregateInputType
+}
+
+export type GetSubmissionAggregateType<T extends SubmissionAggregateArgs> = {
+      [P in keyof T & keyof AggregateSubmission]: P extends '_count' | 'count'
+    ? T[P] extends true
+      ? number
+      : Prisma.GetScalarType<T[P], AggregateSubmission[P]>
+    : Prisma.GetScalarType<T[P], AggregateSubmission[P]>
+}
+
+
+
+
+export type SubmissionGroupByArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  where?: Prisma.SubmissionWhereInput
+  orderBy?: Prisma.SubmissionOrderByWithAggregationInput | Prisma.SubmissionOrderByWithAggregationInput[]
+  by: Prisma.SubmissionScalarFieldEnum[] | Prisma.SubmissionScalarFieldEnum
+  having?: Prisma.SubmissionScalarWhereWithAggregatesInput
+  take?: number
+  skip?: number
+  _count?: SubmissionCountAggregateInputType | true
+  _avg?: SubmissionAvgAggregateInputType
+  _sum?: SubmissionSumAggregateInputType
+  _min?: SubmissionMinAggregateInputType
+  _max?: SubmissionMaxAggregateInputType
+}
+
+export type SubmissionGroupByOutputType = {
+  id: string
+  matchId: string
+  userId: string
+  questionId: string
+  code: string
+  language: string
+  charCount: number | null
+  stdout: string | null
+  stderr: string | null
+  exitCode: number | null
+  execTimeMs: number | null
+  testsPassed: number
+  testsTotal: number
+  timeComplexity: string | null
+  timeScore: number | null
+  spaceComplexity: string | null
+  spaceScore: number | null
+  originalityScore: number | null
+  relevanceScore: number | null
+  submittedAt: Date
+  _count: SubmissionCountAggregateOutputType | null
+  _avg: SubmissionAvgAggregateOutputType | null
+  _sum: SubmissionSumAggregateOutputType | null
+  _min: SubmissionMinAggregateOutputType | null
+  _max: SubmissionMaxAggregateOutputType | null
+}
+
+type GetSubmissionGroupByPayload<T extends SubmissionGroupByArgs> = Prisma.PrismaPromise<
+  Array<
+    Prisma.PickEnumerable<SubmissionGroupByOutputType, T['by']> &
+      {
+        [P in ((keyof T) & (keyof SubmissionGroupByOutputType))]: P extends '_count'
+          ? T[P] extends boolean
+            ? number
+            : Prisma.GetScalarType<T[P], SubmissionGroupByOutputType[P]>
+          : Prisma.GetScalarType<T[P], SubmissionGroupByOutputType[P]>
+      }
+    >
+  >
+
+
+
+export type SubmissionWhereInput = {
+  AND?: Prisma.SubmissionWhereInput | Prisma.SubmissionWhereInput[]
+  OR?: Prisma.SubmissionWhereInput[]
+  NOT?: Prisma.SubmissionWhereInput | Prisma.SubmissionWhereInput[]
+  id?: Prisma.StringFilter<"Submission"> | string
+  matchId?: Prisma.StringFilter<"Submission"> | string
+  userId?: Prisma.StringFilter<"Submission"> | string
+  questionId?: Prisma.StringFilter<"Submission"> | string
+  code?: Prisma.StringFilter<"Submission"> | string
+  language?: Prisma.StringFilter<"Submission"> | string
+  charCount?: Prisma.IntNullableFilter<"Submission"> | number | null
+  stdout?: Prisma.StringNullableFilter<"Submission"> | string | null
+  stderr?: Prisma.StringNullableFilter<"Submission"> | string | null
+  exitCode?: Prisma.IntNullableFilter<"Submission"> | number | null
+  execTimeMs?: Prisma.IntNullableFilter<"Submission"> | number | null
+  testsPassed?: Prisma.IntFilter<"Submission"> | number
+  testsTotal?: Prisma.IntFilter<"Submission"> | number
+  timeComplexity?: Prisma.StringNullableFilter<"Submission"> | string | null
+  timeScore?: Prisma.FloatNullableFilter<"Submission"> | number | null
+  spaceComplexity?: Prisma.StringNullableFilter<"Submission"> | string | null
+  spaceScore?: Prisma.FloatNullableFilter<"Submission"> | number | null
+  originalityScore?: Prisma.FloatNullableFilter<"Submission"> | number | null
+  relevanceScore?: Prisma.FloatNullableFilter<"Submission"> | number | null
+  submittedAt?: Prisma.DateTimeFilter<"Submission"> | Date | string
+  match?: Prisma.XOR<Prisma.MatchScalarRelationFilter, Prisma.MatchWhereInput>
+  user?: Prisma.XOR<Prisma.UserScalarRelationFilter, Prisma.UserWhereInput>
+  question?: Prisma.XOR<Prisma.QuestionScalarRelationFilter, Prisma.QuestionWhereInput>
+}
+
+export type SubmissionOrderByWithRelationInput = {
+  id?: Prisma.SortOrder
+  matchId?: Prisma.SortOrder
+  userId?: Prisma.SortOrder
+  questionId?: Prisma.SortOrder
+  code?: Prisma.SortOrder
+  language?: Prisma.SortOrder
+  charCount?: Prisma.SortOrderInput | Prisma.SortOrder
+  stdout?: Prisma.SortOrderInput | Prisma.SortOrder
+  stderr?: Prisma.SortOrderInput | Prisma.SortOrder
+  exitCode?: Prisma.SortOrderInput | Prisma.SortOrder
+  execTimeMs?: Prisma.SortOrderInput | Prisma.SortOrder
+  testsPassed?: Prisma.SortOrder
+  testsTotal?: Prisma.SortOrder
+  timeComplexity?: Prisma.SortOrderInput | Prisma.SortOrder
+  timeScore?: Prisma.SortOrderInput | Prisma.SortOrder
+  spaceComplexity?: Prisma.SortOrderInput | Prisma.SortOrder
+  spaceScore?: Prisma.SortOrderInput | Prisma.SortOrder
+  originalityScore?: Prisma.SortOrderInput | Prisma.SortOrder
+  relevanceScore?: Prisma.SortOrderInput | Prisma.SortOrder
+  submittedAt?: Prisma.SortOrder
+  match?: Prisma.MatchOrderByWithRelationInput
+  user?: Prisma.UserOrderByWithRelationInput
+  question?: Prisma.QuestionOrderByWithRelationInput
+}
+
+export type SubmissionWhereUniqueInput = Prisma.AtLeast<{
+  id?: string
+  AND?: Prisma.SubmissionWhereInput | Prisma.SubmissionWhereInput[]
+  OR?: Prisma.SubmissionWhereInput[]
+  NOT?: Prisma.SubmissionWhereInput | Prisma.SubmissionWhereInput[]
+  matchId?: Prisma.StringFilter<"Submission"> | string
+  userId?: Prisma.StringFilter<"Submission"> | string
+  questionId?: Prisma.StringFilter<"Submission"> | string
+  code?: Prisma.StringFilter<"Submission"> | string
+  language?: Prisma.StringFilter<"Submission"> | string
+  charCount?: Prisma.IntNullableFilter<"Submission"> | number | null
+  stdout?: Prisma.StringNullableFilter<"Submission"> | string | null
+  stderr?: Prisma.StringNullableFilter<"Submission"> | string | null
+  exitCode?: Prisma.IntNullableFilter<"Submission"> | number | null
+  execTimeMs?: Prisma.IntNullableFilter<"Submission"> | number | null
+  testsPassed?: Prisma.IntFilter<"Submission"> | number
+  testsTotal?: Prisma.IntFilter<"Submission"> | number
+  timeComplexity?: Prisma.StringNullableFilter<"Submission"> | string | null
+  timeScore?: Prisma.FloatNullableFilter<"Submission"> | number | null
+  spaceComplexity?: Prisma.StringNullableFilter<"Submission"> | string | null
+  spaceScore?: Prisma.FloatNullableFilter<"Submission"> | number | null
+  originalityScore?: Prisma.FloatNullableFilter<"Submission"> | number | null
+  relevanceScore?: Prisma.FloatNullableFilter<"Submission"> | number | null
+  submittedAt?: Prisma.DateTimeFilter<"Submission"> | Date | string
+  match?: Prisma.XOR<Prisma.MatchScalarRelationFilter, Prisma.MatchWhereInput>
+  user?: Prisma.XOR<Prisma.UserScalarRelationFilter, Prisma.UserWhereInput>
+  question?: Prisma.XOR<Prisma.QuestionScalarRelationFilter, Prisma.QuestionWhereInput>
+}, "id">
+
+export type SubmissionOrderByWithAggregationInput = {
+  id?: Prisma.SortOrder
+  matchId?: Prisma.SortOrder
+  userId?: Prisma.SortOrder
+  questionId?: Prisma.SortOrder
+  code?: Prisma.SortOrder
+  language?: Prisma.SortOrder
+  charCount?: Prisma.SortOrderInput | Prisma.SortOrder
+  stdout?: Prisma.SortOrderInput | Prisma.SortOrder
+  stderr?: Prisma.SortOrderInput | Prisma.SortOrder
+  exitCode?: Prisma.SortOrderInput | Prisma.SortOrder
+  execTimeMs?: Prisma.SortOrderInput | Prisma.SortOrder
+  testsPassed?: Prisma.SortOrder
+  testsTotal?: Prisma.SortOrder
+  timeComplexity?: Prisma.SortOrderInput | Prisma.SortOrder
+  timeScore?: Prisma.SortOrderInput | Prisma.SortOrder
+  spaceComplexity?: Prisma.SortOrderInput | Prisma.SortOrder
+  spaceScore?: Prisma.SortOrderInput | Prisma.SortOrder
+  originalityScore?: Prisma.SortOrderInput | Prisma.SortOrder
+  relevanceScore?: Prisma.SortOrderInput | Prisma.SortOrder
+  submittedAt?: Prisma.SortOrder
+  _count?: Prisma.SubmissionCountOrderByAggregateInput
+  _avg?: Prisma.SubmissionAvgOrderByAggregateInput
+  _max?: Prisma.SubmissionMaxOrderByAggregateInput
+  _min?: Prisma.SubmissionMinOrderByAggregateInput
+  _sum?: Prisma.SubmissionSumOrderByAggregateInput
+}
+
+export type SubmissionScalarWhereWithAggregatesInput = {
+  AND?: Prisma.SubmissionScalarWhereWithAggregatesInput | Prisma.SubmissionScalarWhereWithAggregatesInput[]
+  OR?: Prisma.SubmissionScalarWhereWithAggregatesInput[]
+  NOT?: Prisma.SubmissionScalarWhereWithAggregatesInput | Prisma.SubmissionScalarWhereWithAggregatesInput[]
+  id?: Prisma.StringWithAggregatesFilter<"Submission"> | string
+  matchId?: Prisma.StringWithAggregatesFilter<"Submission"> | string
+  userId?: Prisma.StringWithAggregatesFilter<"Submission"> | string
+  questionId?: Prisma.StringWithAggregatesFilter<"Submission"> | string
+  code?: Prisma.StringWithAggregatesFilter<"Submission"> | string
+  language?: Prisma.StringWithAggregatesFilter<"Submission"> | string
+  charCount?: Prisma.IntNullableWithAggregatesFilter<"Submission"> | number | null
+  stdout?: Prisma.StringNullableWithAggregatesFilter<"Submission"> | string | null
+  stderr?: Prisma.StringNullableWithAggregatesFilter<"Submission"> | string | null
+  exitCode?: Prisma.IntNullableWithAggregatesFilter<"Submission"> | number | null
+  execTimeMs?: Prisma.IntNullableWithAggregatesFilter<"Submission"> | number | null
+  testsPassed?: Prisma.IntWithAggregatesFilter<"Submission"> | number
+  testsTotal?: Prisma.IntWithAggregatesFilter<"Submission"> | number
+  timeComplexity?: Prisma.StringNullableWithAggregatesFilter<"Submission"> | string | null
+  timeScore?: Prisma.FloatNullableWithAggregatesFilter<"Submission"> | number | null
+  spaceComplexity?: Prisma.StringNullableWithAggregatesFilter<"Submission"> | string | null
+  spaceScore?: Prisma.FloatNullableWithAggregatesFilter<"Submission"> | number | null
+  originalityScore?: Prisma.FloatNullableWithAggregatesFilter<"Submission"> | number | null
+  relevanceScore?: Prisma.FloatNullableWithAggregatesFilter<"Submission"> | number | null
+  submittedAt?: Prisma.DateTimeWithAggregatesFilter<"Submission"> | Date | string
+}
+
+export type SubmissionCreateInput = {
+  id?: string
+  code: string
+  language: string
+  charCount?: number | null
+  stdout?: string | null
+  stderr?: string | null
+  exitCode?: number | null
+  execTimeMs?: number | null
+  testsPassed?: number
+  testsTotal?: number
+  timeComplexity?: string | null
+  timeScore?: number | null
+  spaceComplexity?: string | null
+  spaceScore?: number | null
+  originalityScore?: number | null
+  relevanceScore?: number | null
+  submittedAt?: Date | string
+  match: Prisma.MatchCreateNestedOneWithoutSubmissionsInput
+  user: Prisma.UserCreateNestedOneWithoutSubmissionsInput
+  question: Prisma.QuestionCreateNestedOneWithoutSubmissionsInput
+}
+
+export type SubmissionUncheckedCreateInput = {
+  id?: string
+  matchId: string
+  userId: string
+  questionId: string
+  code: string
+  language: string
+  charCount?: number | null
+  stdout?: string | null
+  stderr?: string | null
+  exitCode?: number | null
+  execTimeMs?: number | null
+  testsPassed?: number
+  testsTotal?: number
+  timeComplexity?: string | null
+  timeScore?: number | null
+  spaceComplexity?: string | null
+  spaceScore?: number | null
+  originalityScore?: number | null
+  relevanceScore?: number | null
+  submittedAt?: Date | string
+}
+
+export type SubmissionUpdateInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  code?: Prisma.StringFieldUpdateOperationsInput | string
+  language?: Prisma.StringFieldUpdateOperationsInput | string
+  charCount?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
+  stdout?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  stderr?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  exitCode?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
+  execTimeMs?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
+  testsPassed?: Prisma.IntFieldUpdateOperationsInput | number
+  testsTotal?: Prisma.IntFieldUpdateOperationsInput | number
+  timeComplexity?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  timeScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  spaceComplexity?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  spaceScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  originalityScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  relevanceScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  submittedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  match?: Prisma.MatchUpdateOneRequiredWithoutSubmissionsNestedInput
+  user?: Prisma.UserUpdateOneRequiredWithoutSubmissionsNestedInput
+  question?: Prisma.QuestionUpdateOneRequiredWithoutSubmissionsNestedInput
+}
+
+export type SubmissionUncheckedUpdateInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  matchId?: Prisma.StringFieldUpdateOperationsInput | string
+  userId?: Prisma.StringFieldUpdateOperationsInput | string
+  questionId?: Prisma.StringFieldUpdateOperationsInput | string
+  code?: Prisma.StringFieldUpdateOperationsInput | string
+  language?: Prisma.StringFieldUpdateOperationsInput | string
+  charCount?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
+  stdout?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  stderr?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  exitCode?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
+  execTimeMs?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
+  testsPassed?: Prisma.IntFieldUpdateOperationsInput | number
+  testsTotal?: Prisma.IntFieldUpdateOperationsInput | number
+  timeComplexity?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  timeScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  spaceComplexity?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  spaceScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  originalityScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  relevanceScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  submittedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+}
+
+export type SubmissionCreateManyInput = {
+  id?: string
+  matchId: string
+  userId: string
+  questionId: string
+  code: string
+  language: string
+  charCount?: number | null
+  stdout?: string | null
+  stderr?: string | null
+  exitCode?: number | null
+  execTimeMs?: number | null
+  testsPassed?: number
+  testsTotal?: number
+  timeComplexity?: string | null
+  timeScore?: number | null
+  spaceComplexity?: string | null
+  spaceScore?: number | null
+  originalityScore?: number | null
+  relevanceScore?: number | null
+  submittedAt?: Date | string
+}
+
+export type SubmissionUpdateManyMutationInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  code?: Prisma.StringFieldUpdateOperationsInput | string
+  language?: Prisma.StringFieldUpdateOperationsInput | string
+  charCount?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
+  stdout?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  stderr?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  exitCode?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
+  execTimeMs?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
+  testsPassed?: Prisma.IntFieldUpdateOperationsInput | number
+  testsTotal?: Prisma.IntFieldUpdateOperationsInput | number
+  timeComplexity?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  timeScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  spaceComplexity?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  spaceScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  originalityScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  relevanceScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  submittedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+}
+
+export type SubmissionUncheckedUpdateManyInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  matchId?: Prisma.StringFieldUpdateOperationsInput | string
+  userId?: Prisma.StringFieldUpdateOperationsInput | string
+  questionId?: Prisma.StringFieldUpdateOperationsInput | string
+  code?: Prisma.StringFieldUpdateOperationsInput | string
+  language?: Prisma.StringFieldUpdateOperationsInput | string
+  charCount?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
+  stdout?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  stderr?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  exitCode?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
+  execTimeMs?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
+  testsPassed?: Prisma.IntFieldUpdateOperationsInput | number
+  testsTotal?: Prisma.IntFieldUpdateOperationsInput | number
+  timeComplexity?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  timeScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  spaceComplexity?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  spaceScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  originalityScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  relevanceScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  submittedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+}
+
+export type SubmissionListRelationFilter = {
+  every?: Prisma.SubmissionWhereInput
+  some?: Prisma.SubmissionWhereInput
+  none?: Prisma.SubmissionWhereInput
+}
+
+export type SubmissionOrderByRelationAggregateInput = {
+  _count?: Prisma.SortOrder
+}
+
+export type SubmissionCountOrderByAggregateInput = {
+  id?: Prisma.SortOrder
+  matchId?: Prisma.SortOrder
+  userId?: Prisma.SortOrder
+  questionId?: Prisma.SortOrder
+  code?: Prisma.SortOrder
+  language?: Prisma.SortOrder
+  charCount?: Prisma.SortOrder
+  stdout?: Prisma.SortOrder
+  stderr?: Prisma.SortOrder
+  exitCode?: Prisma.SortOrder
+  execTimeMs?: Prisma.SortOrder
+  testsPassed?: Prisma.SortOrder
+  testsTotal?: Prisma.SortOrder
+  timeComplexity?: Prisma.SortOrder
+  timeScore?: Prisma.SortOrder
+  spaceComplexity?: Prisma.SortOrder
+  spaceScore?: Prisma.SortOrder
+  originalityScore?: Prisma.SortOrder
+  relevanceScore?: Prisma.SortOrder
+  submittedAt?: Prisma.SortOrder
+}
+
+export type SubmissionAvgOrderByAggregateInput = {
+  charCount?: Prisma.SortOrder
+  exitCode?: Prisma.SortOrder
+  execTimeMs?: Prisma.SortOrder
+  testsPassed?: Prisma.SortOrder
+  testsTotal?: Prisma.SortOrder
+  timeScore?: Prisma.SortOrder
+  spaceScore?: Prisma.SortOrder
+  originalityScore?: Prisma.SortOrder
+  relevanceScore?: Prisma.SortOrder
+}
+
+export type SubmissionMaxOrderByAggregateInput = {
+  id?: Prisma.SortOrder
+  matchId?: Prisma.SortOrder
+  userId?: Prisma.SortOrder
+  questionId?: Prisma.SortOrder
+  code?: Prisma.SortOrder
+  language?: Prisma.SortOrder
+  charCount?: Prisma.SortOrder
+  stdout?: Prisma.SortOrder
+  stderr?: Prisma.SortOrder
+  exitCode?: Prisma.SortOrder
+  execTimeMs?: Prisma.SortOrder
+  testsPassed?: Prisma.SortOrder
+  testsTotal?: Prisma.SortOrder
+  timeComplexity?: Prisma.SortOrder
+  timeScore?: Prisma.SortOrder
+  spaceComplexity?: Prisma.SortOrder
+  spaceScore?: Prisma.SortOrder
+  originalityScore?: Prisma.SortOrder
+  relevanceScore?: Prisma.SortOrder
+  submittedAt?: Prisma.SortOrder
+}
+
+export type SubmissionMinOrderByAggregateInput = {
+  id?: Prisma.SortOrder
+  matchId?: Prisma.SortOrder
+  userId?: Prisma.SortOrder
+  questionId?: Prisma.SortOrder
+  code?: Prisma.SortOrder
+  language?: Prisma.SortOrder
+  charCount?: Prisma.SortOrder
+  stdout?: Prisma.SortOrder
+  stderr?: Prisma.SortOrder
+  exitCode?: Prisma.SortOrder
+  execTimeMs?: Prisma.SortOrder
+  testsPassed?: Prisma.SortOrder
+  testsTotal?: Prisma.SortOrder
+  timeComplexity?: Prisma.SortOrder
+  timeScore?: Prisma.SortOrder
+  spaceComplexity?: Prisma.SortOrder
+  spaceScore?: Prisma.SortOrder
+  originalityScore?: Prisma.SortOrder
+  relevanceScore?: Prisma.SortOrder
+  submittedAt?: Prisma.SortOrder
+}
+
+export type SubmissionSumOrderByAggregateInput = {
+  charCount?: Prisma.SortOrder
+  exitCode?: Prisma.SortOrder
+  execTimeMs?: Prisma.SortOrder
+  testsPassed?: Prisma.SortOrder
+  testsTotal?: Prisma.SortOrder
+  timeScore?: Prisma.SortOrder
+  spaceScore?: Prisma.SortOrder
+  originalityScore?: Prisma.SortOrder
+  relevanceScore?: Prisma.SortOrder
+}
+
+export type SubmissionCreateNestedManyWithoutUserInput = {
+  create?: Prisma.XOR<Prisma.SubmissionCreateWithoutUserInput, Prisma.SubmissionUncheckedCreateWithoutUserInput> | Prisma.SubmissionCreateWithoutUserInput[] | Prisma.SubmissionUncheckedCreateWithoutUserInput[]
+  connectOrCreate?: Prisma.SubmissionCreateOrConnectWithoutUserInput | Prisma.SubmissionCreateOrConnectWithoutUserInput[]
+  createMany?: Prisma.SubmissionCreateManyUserInputEnvelope
+  connect?: Prisma.SubmissionWhereUniqueInput | Prisma.SubmissionWhereUniqueInput[]
+}
+
+export type SubmissionUncheckedCreateNestedManyWithoutUserInput = {
+  create?: Prisma.XOR<Prisma.SubmissionCreateWithoutUserInput, Prisma.SubmissionUncheckedCreateWithoutUserInput> | Prisma.SubmissionCreateWithoutUserInput[] | Prisma.SubmissionUncheckedCreateWithoutUserInput[]
+  connectOrCreate?: Prisma.SubmissionCreateOrConnectWithoutUserInput | Prisma.SubmissionCreateOrConnectWithoutUserInput[]
+  createMany?: Prisma.SubmissionCreateManyUserInputEnvelope
+  connect?: Prisma.SubmissionWhereUniqueInput | Prisma.SubmissionWhereUniqueInput[]
+}
+
+export type SubmissionUpdateManyWithoutUserNestedInput = {
+  create?: Prisma.XOR<Prisma.SubmissionCreateWithoutUserInput, Prisma.SubmissionUncheckedCreateWithoutUserInput> | Prisma.SubmissionCreateWithoutUserInput[] | Prisma.SubmissionUncheckedCreateWithoutUserInput[]
+  connectOrCreate?: Prisma.SubmissionCreateOrConnectWithoutUserInput | Prisma.SubmissionCreateOrConnectWithoutUserInput[]
+  upsert?: Prisma.SubmissionUpsertWithWhereUniqueWithoutUserInput | Prisma.SubmissionUpsertWithWhereUniqueWithoutUserInput[]
+  createMany?: Prisma.SubmissionCreateManyUserInputEnvelope
+  set?: Prisma.SubmissionWhereUniqueInput | Prisma.SubmissionWhereUniqueInput[]
+  disconnect?: Prisma.SubmissionWhereUniqueInput | Prisma.SubmissionWhereUniqueInput[]
+  delete?: Prisma.SubmissionWhereUniqueInput | Prisma.SubmissionWhereUniqueInput[]
+  connect?: Prisma.SubmissionWhereUniqueInput | Prisma.SubmissionWhereUniqueInput[]
+  update?: Prisma.SubmissionUpdateWithWhereUniqueWithoutUserInput | Prisma.SubmissionUpdateWithWhereUniqueWithoutUserInput[]
+  updateMany?: Prisma.SubmissionUpdateManyWithWhereWithoutUserInput | Prisma.SubmissionUpdateManyWithWhereWithoutUserInput[]
+  deleteMany?: Prisma.SubmissionScalarWhereInput | Prisma.SubmissionScalarWhereInput[]
+}
+
+export type SubmissionUncheckedUpdateManyWithoutUserNestedInput = {
+  create?: Prisma.XOR<Prisma.SubmissionCreateWithoutUserInput, Prisma.SubmissionUncheckedCreateWithoutUserInput> | Prisma.SubmissionCreateWithoutUserInput[] | Prisma.SubmissionUncheckedCreateWithoutUserInput[]
+  connectOrCreate?: Prisma.SubmissionCreateOrConnectWithoutUserInput | Prisma.SubmissionCreateOrConnectWithoutUserInput[]
+  upsert?: Prisma.SubmissionUpsertWithWhereUniqueWithoutUserInput | Prisma.SubmissionUpsertWithWhereUniqueWithoutUserInput[]
+  createMany?: Prisma.SubmissionCreateManyUserInputEnvelope
+  set?: Prisma.SubmissionWhereUniqueInput | Prisma.SubmissionWhereUniqueInput[]
+  disconnect?: Prisma.SubmissionWhereUniqueInput | Prisma.SubmissionWhereUniqueInput[]
+  delete?: Prisma.SubmissionWhereUniqueInput | Prisma.SubmissionWhereUniqueInput[]
+  connect?: Prisma.SubmissionWhereUniqueInput | Prisma.SubmissionWhereUniqueInput[]
+  update?: Prisma.SubmissionUpdateWithWhereUniqueWithoutUserInput | Prisma.SubmissionUpdateWithWhereUniqueWithoutUserInput[]
+  updateMany?: Prisma.SubmissionUpdateManyWithWhereWithoutUserInput | Prisma.SubmissionUpdateManyWithWhereWithoutUserInput[]
+  deleteMany?: Prisma.SubmissionScalarWhereInput | Prisma.SubmissionScalarWhereInput[]
+}
+
+export type SubmissionCreateNestedManyWithoutMatchInput = {
+  create?: Prisma.XOR<Prisma.SubmissionCreateWithoutMatchInput, Prisma.SubmissionUncheckedCreateWithoutMatchInput> | Prisma.SubmissionCreateWithoutMatchInput[] | Prisma.SubmissionUncheckedCreateWithoutMatchInput[]
+  connectOrCreate?: Prisma.SubmissionCreateOrConnectWithoutMatchInput | Prisma.SubmissionCreateOrConnectWithoutMatchInput[]
+  createMany?: Prisma.SubmissionCreateManyMatchInputEnvelope
+  connect?: Prisma.SubmissionWhereUniqueInput | Prisma.SubmissionWhereUniqueInput[]
+}
+
+export type SubmissionUncheckedCreateNestedManyWithoutMatchInput = {
+  create?: Prisma.XOR<Prisma.SubmissionCreateWithoutMatchInput, Prisma.SubmissionUncheckedCreateWithoutMatchInput> | Prisma.SubmissionCreateWithoutMatchInput[] | Prisma.SubmissionUncheckedCreateWithoutMatchInput[]
+  connectOrCreate?: Prisma.SubmissionCreateOrConnectWithoutMatchInput | Prisma.SubmissionCreateOrConnectWithoutMatchInput[]
+  createMany?: Prisma.SubmissionCreateManyMatchInputEnvelope
+  connect?: Prisma.SubmissionWhereUniqueInput | Prisma.SubmissionWhereUniqueInput[]
+}
+
+export type SubmissionUpdateManyWithoutMatchNestedInput = {
+  create?: Prisma.XOR<Prisma.SubmissionCreateWithoutMatchInput, Prisma.SubmissionUncheckedCreateWithoutMatchInput> | Prisma.SubmissionCreateWithoutMatchInput[] | Prisma.SubmissionUncheckedCreateWithoutMatchInput[]
+  connectOrCreate?: Prisma.SubmissionCreateOrConnectWithoutMatchInput | Prisma.SubmissionCreateOrConnectWithoutMatchInput[]
+  upsert?: Prisma.SubmissionUpsertWithWhereUniqueWithoutMatchInput | Prisma.SubmissionUpsertWithWhereUniqueWithoutMatchInput[]
+  createMany?: Prisma.SubmissionCreateManyMatchInputEnvelope
+  set?: Prisma.SubmissionWhereUniqueInput | Prisma.SubmissionWhereUniqueInput[]
+  disconnect?: Prisma.SubmissionWhereUniqueInput | Prisma.SubmissionWhereUniqueInput[]
+  delete?: Prisma.SubmissionWhereUniqueInput | Prisma.SubmissionWhereUniqueInput[]
+  connect?: Prisma.SubmissionWhereUniqueInput | Prisma.SubmissionWhereUniqueInput[]
+  update?: Prisma.SubmissionUpdateWithWhereUniqueWithoutMatchInput | Prisma.SubmissionUpdateWithWhereUniqueWithoutMatchInput[]
+  updateMany?: Prisma.SubmissionUpdateManyWithWhereWithoutMatchInput | Prisma.SubmissionUpdateManyWithWhereWithoutMatchInput[]
+  deleteMany?: Prisma.SubmissionScalarWhereInput | Prisma.SubmissionScalarWhereInput[]
+}
+
+export type SubmissionUncheckedUpdateManyWithoutMatchNestedInput = {
+  create?: Prisma.XOR<Prisma.SubmissionCreateWithoutMatchInput, Prisma.SubmissionUncheckedCreateWithoutMatchInput> | Prisma.SubmissionCreateWithoutMatchInput[] | Prisma.SubmissionUncheckedCreateWithoutMatchInput[]
+  connectOrCreate?: Prisma.SubmissionCreateOrConnectWithoutMatchInput | Prisma.SubmissionCreateOrConnectWithoutMatchInput[]
+  upsert?: Prisma.SubmissionUpsertWithWhereUniqueWithoutMatchInput | Prisma.SubmissionUpsertWithWhereUniqueWithoutMatchInput[]
+  createMany?: Prisma.SubmissionCreateManyMatchInputEnvelope
+  set?: Prisma.SubmissionWhereUniqueInput | Prisma.SubmissionWhereUniqueInput[]
+  disconnect?: Prisma.SubmissionWhereUniqueInput | Prisma.SubmissionWhereUniqueInput[]
+  delete?: Prisma.SubmissionWhereUniqueInput | Prisma.SubmissionWhereUniqueInput[]
+  connect?: Prisma.SubmissionWhereUniqueInput | Prisma.SubmissionWhereUniqueInput[]
+  update?: Prisma.SubmissionUpdateWithWhereUniqueWithoutMatchInput | Prisma.SubmissionUpdateWithWhereUniqueWithoutMatchInput[]
+  updateMany?: Prisma.SubmissionUpdateManyWithWhereWithoutMatchInput | Prisma.SubmissionUpdateManyWithWhereWithoutMatchInput[]
+  deleteMany?: Prisma.SubmissionScalarWhereInput | Prisma.SubmissionScalarWhereInput[]
+}
+
+export type SubmissionCreateNestedManyWithoutQuestionInput = {
+  create?: Prisma.XOR<Prisma.SubmissionCreateWithoutQuestionInput, Prisma.SubmissionUncheckedCreateWithoutQuestionInput> | Prisma.SubmissionCreateWithoutQuestionInput[] | Prisma.SubmissionUncheckedCreateWithoutQuestionInput[]
+  connectOrCreate?: Prisma.SubmissionCreateOrConnectWithoutQuestionInput | Prisma.SubmissionCreateOrConnectWithoutQuestionInput[]
+  createMany?: Prisma.SubmissionCreateManyQuestionInputEnvelope
+  connect?: Prisma.SubmissionWhereUniqueInput | Prisma.SubmissionWhereUniqueInput[]
+}
+
+export type SubmissionUncheckedCreateNestedManyWithoutQuestionInput = {
+  create?: Prisma.XOR<Prisma.SubmissionCreateWithoutQuestionInput, Prisma.SubmissionUncheckedCreateWithoutQuestionInput> | Prisma.SubmissionCreateWithoutQuestionInput[] | Prisma.SubmissionUncheckedCreateWithoutQuestionInput[]
+  connectOrCreate?: Prisma.SubmissionCreateOrConnectWithoutQuestionInput | Prisma.SubmissionCreateOrConnectWithoutQuestionInput[]
+  createMany?: Prisma.SubmissionCreateManyQuestionInputEnvelope
+  connect?: Prisma.SubmissionWhereUniqueInput | Prisma.SubmissionWhereUniqueInput[]
+}
+
+export type SubmissionUpdateManyWithoutQuestionNestedInput = {
+  create?: Prisma.XOR<Prisma.SubmissionCreateWithoutQuestionInput, Prisma.SubmissionUncheckedCreateWithoutQuestionInput> | Prisma.SubmissionCreateWithoutQuestionInput[] | Prisma.SubmissionUncheckedCreateWithoutQuestionInput[]
+  connectOrCreate?: Prisma.SubmissionCreateOrConnectWithoutQuestionInput | Prisma.SubmissionCreateOrConnectWithoutQuestionInput[]
+  upsert?: Prisma.SubmissionUpsertWithWhereUniqueWithoutQuestionInput | Prisma.SubmissionUpsertWithWhereUniqueWithoutQuestionInput[]
+  createMany?: Prisma.SubmissionCreateManyQuestionInputEnvelope
+  set?: Prisma.SubmissionWhereUniqueInput | Prisma.SubmissionWhereUniqueInput[]
+  disconnect?: Prisma.SubmissionWhereUniqueInput | Prisma.SubmissionWhereUniqueInput[]
+  delete?: Prisma.SubmissionWhereUniqueInput | Prisma.SubmissionWhereUniqueInput[]
+  connect?: Prisma.SubmissionWhereUniqueInput | Prisma.SubmissionWhereUniqueInput[]
+  update?: Prisma.SubmissionUpdateWithWhereUniqueWithoutQuestionInput | Prisma.SubmissionUpdateWithWhereUniqueWithoutQuestionInput[]
+  updateMany?: Prisma.SubmissionUpdateManyWithWhereWithoutQuestionInput | Prisma.SubmissionUpdateManyWithWhereWithoutQuestionInput[]
+  deleteMany?: Prisma.SubmissionScalarWhereInput | Prisma.SubmissionScalarWhereInput[]
+}
+
+export type SubmissionUncheckedUpdateManyWithoutQuestionNestedInput = {
+  create?: Prisma.XOR<Prisma.SubmissionCreateWithoutQuestionInput, Prisma.SubmissionUncheckedCreateWithoutQuestionInput> | Prisma.SubmissionCreateWithoutQuestionInput[] | Prisma.SubmissionUncheckedCreateWithoutQuestionInput[]
+  connectOrCreate?: Prisma.SubmissionCreateOrConnectWithoutQuestionInput | Prisma.SubmissionCreateOrConnectWithoutQuestionInput[]
+  upsert?: Prisma.SubmissionUpsertWithWhereUniqueWithoutQuestionInput | Prisma.SubmissionUpsertWithWhereUniqueWithoutQuestionInput[]
+  createMany?: Prisma.SubmissionCreateManyQuestionInputEnvelope
+  set?: Prisma.SubmissionWhereUniqueInput | Prisma.SubmissionWhereUniqueInput[]
+  disconnect?: Prisma.SubmissionWhereUniqueInput | Prisma.SubmissionWhereUniqueInput[]
+  delete?: Prisma.SubmissionWhereUniqueInput | Prisma.SubmissionWhereUniqueInput[]
+  connect?: Prisma.SubmissionWhereUniqueInput | Prisma.SubmissionWhereUniqueInput[]
+  update?: Prisma.SubmissionUpdateWithWhereUniqueWithoutQuestionInput | Prisma.SubmissionUpdateWithWhereUniqueWithoutQuestionInput[]
+  updateMany?: Prisma.SubmissionUpdateManyWithWhereWithoutQuestionInput | Prisma.SubmissionUpdateManyWithWhereWithoutQuestionInput[]
+  deleteMany?: Prisma.SubmissionScalarWhereInput | Prisma.SubmissionScalarWhereInput[]
+}
+
+export type SubmissionCreateWithoutUserInput = {
+  id?: string
+  code: string
+  language: string
+  charCount?: number | null
+  stdout?: string | null
+  stderr?: string | null
+  exitCode?: number | null
+  execTimeMs?: number | null
+  testsPassed?: number
+  testsTotal?: number
+  timeComplexity?: string | null
+  timeScore?: number | null
+  spaceComplexity?: string | null
+  spaceScore?: number | null
+  originalityScore?: number | null
+  relevanceScore?: number | null
+  submittedAt?: Date | string
+  match: Prisma.MatchCreateNestedOneWithoutSubmissionsInput
+  question: Prisma.QuestionCreateNestedOneWithoutSubmissionsInput
+}
+
+export type SubmissionUncheckedCreateWithoutUserInput = {
+  id?: string
+  matchId: string
+  questionId: string
+  code: string
+  language: string
+  charCount?: number | null
+  stdout?: string | null
+  stderr?: string | null
+  exitCode?: number | null
+  execTimeMs?: number | null
+  testsPassed?: number
+  testsTotal?: number
+  timeComplexity?: string | null
+  timeScore?: number | null
+  spaceComplexity?: string | null
+  spaceScore?: number | null
+  originalityScore?: number | null
+  relevanceScore?: number | null
+  submittedAt?: Date | string
+}
+
+export type SubmissionCreateOrConnectWithoutUserInput = {
+  where: Prisma.SubmissionWhereUniqueInput
+  create: Prisma.XOR<Prisma.SubmissionCreateWithoutUserInput, Prisma.SubmissionUncheckedCreateWithoutUserInput>
+}
+
+export type SubmissionCreateManyUserInputEnvelope = {
+  data: Prisma.SubmissionCreateManyUserInput | Prisma.SubmissionCreateManyUserInput[]
+  skipDuplicates?: boolean
+}
+
+export type SubmissionUpsertWithWhereUniqueWithoutUserInput = {
+  where: Prisma.SubmissionWhereUniqueInput
+  update: Prisma.XOR<Prisma.SubmissionUpdateWithoutUserInput, Prisma.SubmissionUncheckedUpdateWithoutUserInput>
+  create: Prisma.XOR<Prisma.SubmissionCreateWithoutUserInput, Prisma.SubmissionUncheckedCreateWithoutUserInput>
+}
+
+export type SubmissionUpdateWithWhereUniqueWithoutUserInput = {
+  where: Prisma.SubmissionWhereUniqueInput
+  data: Prisma.XOR<Prisma.SubmissionUpdateWithoutUserInput, Prisma.SubmissionUncheckedUpdateWithoutUserInput>
+}
+
+export type SubmissionUpdateManyWithWhereWithoutUserInput = {
+  where: Prisma.SubmissionScalarWhereInput
+  data: Prisma.XOR<Prisma.SubmissionUpdateManyMutationInput, Prisma.SubmissionUncheckedUpdateManyWithoutUserInput>
+}
+
+export type SubmissionScalarWhereInput = {
+  AND?: Prisma.SubmissionScalarWhereInput | Prisma.SubmissionScalarWhereInput[]
+  OR?: Prisma.SubmissionScalarWhereInput[]
+  NOT?: Prisma.SubmissionScalarWhereInput | Prisma.SubmissionScalarWhereInput[]
+  id?: Prisma.StringFilter<"Submission"> | string
+  matchId?: Prisma.StringFilter<"Submission"> | string
+  userId?: Prisma.StringFilter<"Submission"> | string
+  questionId?: Prisma.StringFilter<"Submission"> | string
+  code?: Prisma.StringFilter<"Submission"> | string
+  language?: Prisma.StringFilter<"Submission"> | string
+  charCount?: Prisma.IntNullableFilter<"Submission"> | number | null
+  stdout?: Prisma.StringNullableFilter<"Submission"> | string | null
+  stderr?: Prisma.StringNullableFilter<"Submission"> | string | null
+  exitCode?: Prisma.IntNullableFilter<"Submission"> | number | null
+  execTimeMs?: Prisma.IntNullableFilter<"Submission"> | number | null
+  testsPassed?: Prisma.IntFilter<"Submission"> | number
+  testsTotal?: Prisma.IntFilter<"Submission"> | number
+  timeComplexity?: Prisma.StringNullableFilter<"Submission"> | string | null
+  timeScore?: Prisma.FloatNullableFilter<"Submission"> | number | null
+  spaceComplexity?: Prisma.StringNullableFilter<"Submission"> | string | null
+  spaceScore?: Prisma.FloatNullableFilter<"Submission"> | number | null
+  originalityScore?: Prisma.FloatNullableFilter<"Submission"> | number | null
+  relevanceScore?: Prisma.FloatNullableFilter<"Submission"> | number | null
+  submittedAt?: Prisma.DateTimeFilter<"Submission"> | Date | string
+}
+
+export type SubmissionCreateWithoutMatchInput = {
+  id?: string
+  code: string
+  language: string
+  charCount?: number | null
+  stdout?: string | null
+  stderr?: string | null
+  exitCode?: number | null
+  execTimeMs?: number | null
+  testsPassed?: number
+  testsTotal?: number
+  timeComplexity?: string | null
+  timeScore?: number | null
+  spaceComplexity?: string | null
+  spaceScore?: number | null
+  originalityScore?: number | null
+  relevanceScore?: number | null
+  submittedAt?: Date | string
+  user: Prisma.UserCreateNestedOneWithoutSubmissionsInput
+  question: Prisma.QuestionCreateNestedOneWithoutSubmissionsInput
+}
+
+export type SubmissionUncheckedCreateWithoutMatchInput = {
+  id?: string
+  userId: string
+  questionId: string
+  code: string
+  language: string
+  charCount?: number | null
+  stdout?: string | null
+  stderr?: string | null
+  exitCode?: number | null
+  execTimeMs?: number | null
+  testsPassed?: number
+  testsTotal?: number
+  timeComplexity?: string | null
+  timeScore?: number | null
+  spaceComplexity?: string | null
+  spaceScore?: number | null
+  originalityScore?: number | null
+  relevanceScore?: number | null
+  submittedAt?: Date | string
+}
+
+export type SubmissionCreateOrConnectWithoutMatchInput = {
+  where: Prisma.SubmissionWhereUniqueInput
+  create: Prisma.XOR<Prisma.SubmissionCreateWithoutMatchInput, Prisma.SubmissionUncheckedCreateWithoutMatchInput>
+}
+
+export type SubmissionCreateManyMatchInputEnvelope = {
+  data: Prisma.SubmissionCreateManyMatchInput | Prisma.SubmissionCreateManyMatchInput[]
+  skipDuplicates?: boolean
+}
+
+export type SubmissionUpsertWithWhereUniqueWithoutMatchInput = {
+  where: Prisma.SubmissionWhereUniqueInput
+  update: Prisma.XOR<Prisma.SubmissionUpdateWithoutMatchInput, Prisma.SubmissionUncheckedUpdateWithoutMatchInput>
+  create: Prisma.XOR<Prisma.SubmissionCreateWithoutMatchInput, Prisma.SubmissionUncheckedCreateWithoutMatchInput>
+}
+
+export type SubmissionUpdateWithWhereUniqueWithoutMatchInput = {
+  where: Prisma.SubmissionWhereUniqueInput
+  data: Prisma.XOR<Prisma.SubmissionUpdateWithoutMatchInput, Prisma.SubmissionUncheckedUpdateWithoutMatchInput>
+}
+
+export type SubmissionUpdateManyWithWhereWithoutMatchInput = {
+  where: Prisma.SubmissionScalarWhereInput
+  data: Prisma.XOR<Prisma.SubmissionUpdateManyMutationInput, Prisma.SubmissionUncheckedUpdateManyWithoutMatchInput>
+}
+
+export type SubmissionCreateWithoutQuestionInput = {
+  id?: string
+  code: string
+  language: string
+  charCount?: number | null
+  stdout?: string | null
+  stderr?: string | null
+  exitCode?: number | null
+  execTimeMs?: number | null
+  testsPassed?: number
+  testsTotal?: number
+  timeComplexity?: string | null
+  timeScore?: number | null
+  spaceComplexity?: string | null
+  spaceScore?: number | null
+  originalityScore?: number | null
+  relevanceScore?: number | null
+  submittedAt?: Date | string
+  match: Prisma.MatchCreateNestedOneWithoutSubmissionsInput
+  user: Prisma.UserCreateNestedOneWithoutSubmissionsInput
+}
+
+export type SubmissionUncheckedCreateWithoutQuestionInput = {
+  id?: string
+  matchId: string
+  userId: string
+  code: string
+  language: string
+  charCount?: number | null
+  stdout?: string | null
+  stderr?: string | null
+  exitCode?: number | null
+  execTimeMs?: number | null
+  testsPassed?: number
+  testsTotal?: number
+  timeComplexity?: string | null
+  timeScore?: number | null
+  spaceComplexity?: string | null
+  spaceScore?: number | null
+  originalityScore?: number | null
+  relevanceScore?: number | null
+  submittedAt?: Date | string
+}
+
+export type SubmissionCreateOrConnectWithoutQuestionInput = {
+  where: Prisma.SubmissionWhereUniqueInput
+  create: Prisma.XOR<Prisma.SubmissionCreateWithoutQuestionInput, Prisma.SubmissionUncheckedCreateWithoutQuestionInput>
+}
+
+export type SubmissionCreateManyQuestionInputEnvelope = {
+  data: Prisma.SubmissionCreateManyQuestionInput | Prisma.SubmissionCreateManyQuestionInput[]
+  skipDuplicates?: boolean
+}
+
+export type SubmissionUpsertWithWhereUniqueWithoutQuestionInput = {
+  where: Prisma.SubmissionWhereUniqueInput
+  update: Prisma.XOR<Prisma.SubmissionUpdateWithoutQuestionInput, Prisma.SubmissionUncheckedUpdateWithoutQuestionInput>
+  create: Prisma.XOR<Prisma.SubmissionCreateWithoutQuestionInput, Prisma.SubmissionUncheckedCreateWithoutQuestionInput>
+}
+
+export type SubmissionUpdateWithWhereUniqueWithoutQuestionInput = {
+  where: Prisma.SubmissionWhereUniqueInput
+  data: Prisma.XOR<Prisma.SubmissionUpdateWithoutQuestionInput, Prisma.SubmissionUncheckedUpdateWithoutQuestionInput>
+}
+
+export type SubmissionUpdateManyWithWhereWithoutQuestionInput = {
+  where: Prisma.SubmissionScalarWhereInput
+  data: Prisma.XOR<Prisma.SubmissionUpdateManyMutationInput, Prisma.SubmissionUncheckedUpdateManyWithoutQuestionInput>
+}
+
+export type SubmissionCreateManyUserInput = {
+  id?: string
+  matchId: string
+  questionId: string
+  code: string
+  language: string
+  charCount?: number | null
+  stdout?: string | null
+  stderr?: string | null
+  exitCode?: number | null
+  execTimeMs?: number | null
+  testsPassed?: number
+  testsTotal?: number
+  timeComplexity?: string | null
+  timeScore?: number | null
+  spaceComplexity?: string | null
+  spaceScore?: number | null
+  originalityScore?: number | null
+  relevanceScore?: number | null
+  submittedAt?: Date | string
+}
+
+export type SubmissionUpdateWithoutUserInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  code?: Prisma.StringFieldUpdateOperationsInput | string
+  language?: Prisma.StringFieldUpdateOperationsInput | string
+  charCount?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
+  stdout?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  stderr?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  exitCode?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
+  execTimeMs?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
+  testsPassed?: Prisma.IntFieldUpdateOperationsInput | number
+  testsTotal?: Prisma.IntFieldUpdateOperationsInput | number
+  timeComplexity?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  timeScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  spaceComplexity?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  spaceScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  originalityScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  relevanceScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  submittedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  match?: Prisma.MatchUpdateOneRequiredWithoutSubmissionsNestedInput
+  question?: Prisma.QuestionUpdateOneRequiredWithoutSubmissionsNestedInput
+}
+
+export type SubmissionUncheckedUpdateWithoutUserInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  matchId?: Prisma.StringFieldUpdateOperationsInput | string
+  questionId?: Prisma.StringFieldUpdateOperationsInput | string
+  code?: Prisma.StringFieldUpdateOperationsInput | string
+  language?: Prisma.StringFieldUpdateOperationsInput | string
+  charCount?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
+  stdout?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  stderr?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  exitCode?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
+  execTimeMs?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
+  testsPassed?: Prisma.IntFieldUpdateOperationsInput | number
+  testsTotal?: Prisma.IntFieldUpdateOperationsInput | number
+  timeComplexity?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  timeScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  spaceComplexity?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  spaceScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  originalityScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  relevanceScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  submittedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+}
+
+export type SubmissionUncheckedUpdateManyWithoutUserInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  matchId?: Prisma.StringFieldUpdateOperationsInput | string
+  questionId?: Prisma.StringFieldUpdateOperationsInput | string
+  code?: Prisma.StringFieldUpdateOperationsInput | string
+  language?: Prisma.StringFieldUpdateOperationsInput | string
+  charCount?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
+  stdout?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  stderr?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  exitCode?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
+  execTimeMs?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
+  testsPassed?: Prisma.IntFieldUpdateOperationsInput | number
+  testsTotal?: Prisma.IntFieldUpdateOperationsInput | number
+  timeComplexity?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  timeScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  spaceComplexity?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  spaceScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  originalityScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  relevanceScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  submittedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+}
+
+export type SubmissionCreateManyMatchInput = {
+  id?: string
+  userId: string
+  questionId: string
+  code: string
+  language: string
+  charCount?: number | null
+  stdout?: string | null
+  stderr?: string | null
+  exitCode?: number | null
+  execTimeMs?: number | null
+  testsPassed?: number
+  testsTotal?: number
+  timeComplexity?: string | null
+  timeScore?: number | null
+  spaceComplexity?: string | null
+  spaceScore?: number | null
+  originalityScore?: number | null
+  relevanceScore?: number | null
+  submittedAt?: Date | string
+}
+
+export type SubmissionUpdateWithoutMatchInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  code?: Prisma.StringFieldUpdateOperationsInput | string
+  language?: Prisma.StringFieldUpdateOperationsInput | string
+  charCount?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
+  stdout?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  stderr?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  exitCode?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
+  execTimeMs?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
+  testsPassed?: Prisma.IntFieldUpdateOperationsInput | number
+  testsTotal?: Prisma.IntFieldUpdateOperationsInput | number
+  timeComplexity?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  timeScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  spaceComplexity?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  spaceScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  originalityScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  relevanceScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  submittedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  user?: Prisma.UserUpdateOneRequiredWithoutSubmissionsNestedInput
+  question?: Prisma.QuestionUpdateOneRequiredWithoutSubmissionsNestedInput
+}
+
+export type SubmissionUncheckedUpdateWithoutMatchInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  userId?: Prisma.StringFieldUpdateOperationsInput | string
+  questionId?: Prisma.StringFieldUpdateOperationsInput | string
+  code?: Prisma.StringFieldUpdateOperationsInput | string
+  language?: Prisma.StringFieldUpdateOperationsInput | string
+  charCount?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
+  stdout?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  stderr?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  exitCode?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
+  execTimeMs?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
+  testsPassed?: Prisma.IntFieldUpdateOperationsInput | number
+  testsTotal?: Prisma.IntFieldUpdateOperationsInput | number
+  timeComplexity?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  timeScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  spaceComplexity?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  spaceScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  originalityScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  relevanceScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  submittedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+}
+
+export type SubmissionUncheckedUpdateManyWithoutMatchInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  userId?: Prisma.StringFieldUpdateOperationsInput | string
+  questionId?: Prisma.StringFieldUpdateOperationsInput | string
+  code?: Prisma.StringFieldUpdateOperationsInput | string
+  language?: Prisma.StringFieldUpdateOperationsInput | string
+  charCount?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
+  stdout?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  stderr?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  exitCode?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
+  execTimeMs?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
+  testsPassed?: Prisma.IntFieldUpdateOperationsInput | number
+  testsTotal?: Prisma.IntFieldUpdateOperationsInput | number
+  timeComplexity?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  timeScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  spaceComplexity?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  spaceScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  originalityScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  relevanceScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  submittedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+}
+
+export type SubmissionCreateManyQuestionInput = {
+  id?: string
+  matchId: string
+  userId: string
+  code: string
+  language: string
+  charCount?: number | null
+  stdout?: string | null
+  stderr?: string | null
+  exitCode?: number | null
+  execTimeMs?: number | null
+  testsPassed?: number
+  testsTotal?: number
+  timeComplexity?: string | null
+  timeScore?: number | null
+  spaceComplexity?: string | null
+  spaceScore?: number | null
+  originalityScore?: number | null
+  relevanceScore?: number | null
+  submittedAt?: Date | string
+}
+
+export type SubmissionUpdateWithoutQuestionInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  code?: Prisma.StringFieldUpdateOperationsInput | string
+  language?: Prisma.StringFieldUpdateOperationsInput | string
+  charCount?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
+  stdout?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  stderr?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  exitCode?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
+  execTimeMs?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
+  testsPassed?: Prisma.IntFieldUpdateOperationsInput | number
+  testsTotal?: Prisma.IntFieldUpdateOperationsInput | number
+  timeComplexity?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  timeScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  spaceComplexity?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  spaceScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  originalityScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  relevanceScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  submittedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  match?: Prisma.MatchUpdateOneRequiredWithoutSubmissionsNestedInput
+  user?: Prisma.UserUpdateOneRequiredWithoutSubmissionsNestedInput
+}
+
+export type SubmissionUncheckedUpdateWithoutQuestionInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  matchId?: Prisma.StringFieldUpdateOperationsInput | string
+  userId?: Prisma.StringFieldUpdateOperationsInput | string
+  code?: Prisma.StringFieldUpdateOperationsInput | string
+  language?: Prisma.StringFieldUpdateOperationsInput | string
+  charCount?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
+  stdout?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  stderr?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  exitCode?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
+  execTimeMs?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
+  testsPassed?: Prisma.IntFieldUpdateOperationsInput | number
+  testsTotal?: Prisma.IntFieldUpdateOperationsInput | number
+  timeComplexity?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  timeScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  spaceComplexity?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  spaceScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  originalityScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  relevanceScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  submittedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+}
+
+export type SubmissionUncheckedUpdateManyWithoutQuestionInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  matchId?: Prisma.StringFieldUpdateOperationsInput | string
+  userId?: Prisma.StringFieldUpdateOperationsInput | string
+  code?: Prisma.StringFieldUpdateOperationsInput | string
+  language?: Prisma.StringFieldUpdateOperationsInput | string
+  charCount?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
+  stdout?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  stderr?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  exitCode?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
+  execTimeMs?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
+  testsPassed?: Prisma.IntFieldUpdateOperationsInput | number
+  testsTotal?: Prisma.IntFieldUpdateOperationsInput | number
+  timeComplexity?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  timeScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  spaceComplexity?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  spaceScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  originalityScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  relevanceScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  submittedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+}
+
+
+
+export type SubmissionSelect<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
+  id?: boolean
+  matchId?: boolean
+  userId?: boolean
+  questionId?: boolean
+  code?: boolean
+  language?: boolean
+  charCount?: boolean
+  stdout?: boolean
+  stderr?: boolean
+  exitCode?: boolean
+  execTimeMs?: boolean
+  testsPassed?: boolean
+  testsTotal?: boolean
+  timeComplexity?: boolean
+  timeScore?: boolean
+  spaceComplexity?: boolean
+  spaceScore?: boolean
+  originalityScore?: boolean
+  relevanceScore?: boolean
+  submittedAt?: boolean
+  match?: boolean | Prisma.MatchDefaultArgs<ExtArgs>
+  user?: boolean | Prisma.UserDefaultArgs<ExtArgs>
+  question?: boolean | Prisma.QuestionDefaultArgs<ExtArgs>
+}, ExtArgs["result"]["submission"]>
+
+export type SubmissionSelectCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
+  id?: boolean
+  matchId?: boolean
+  userId?: boolean
+  questionId?: boolean
+  code?: boolean
+  language?: boolean
+  charCount?: boolean
+  stdout?: boolean
+  stderr?: boolean
+  exitCode?: boolean
+  execTimeMs?: boolean
+  testsPassed?: boolean
+  testsTotal?: boolean
+  timeComplexity?: boolean
+  timeScore?: boolean
+  spaceComplexity?: boolean
+  spaceScore?: boolean
+  originalityScore?: boolean
+  relevanceScore?: boolean
+  submittedAt?: boolean
+  match?: boolean | Prisma.MatchDefaultArgs<ExtArgs>
+  user?: boolean | Prisma.UserDefaultArgs<ExtArgs>
+  question?: boolean | Prisma.QuestionDefaultArgs<ExtArgs>
+}, ExtArgs["result"]["submission"]>
+
+export type SubmissionSelectUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
+  id?: boolean
+  matchId?: boolean
+  userId?: boolean
+  questionId?: boolean
+  code?: boolean
+  language?: boolean
+  charCount?: boolean
+  stdout?: boolean
+  stderr?: boolean
+  exitCode?: boolean
+  execTimeMs?: boolean
+  testsPassed?: boolean
+  testsTotal?: boolean
+  timeComplexity?: boolean
+  timeScore?: boolean
+  spaceComplexity?: boolean
+  spaceScore?: boolean
+  originalityScore?: boolean
+  relevanceScore?: boolean
+  submittedAt?: boolean
+  match?: boolean | Prisma.MatchDefaultArgs<ExtArgs>
+  user?: boolean | Prisma.UserDefaultArgs<ExtArgs>
+  question?: boolean | Prisma.QuestionDefaultArgs<ExtArgs>
+}, ExtArgs["result"]["submission"]>
+
+export type SubmissionSelectScalar = {
+  id?: boolean
+  matchId?: boolean
+  userId?: boolean
+  questionId?: boolean
+  code?: boolean
+  language?: boolean
+  charCount?: boolean
+  stdout?: boolean
+  stderr?: boolean
+  exitCode?: boolean
+  execTimeMs?: boolean
+  testsPassed?: boolean
+  testsTotal?: boolean
+  timeComplexity?: boolean
+  timeScore?: boolean
+  spaceComplexity?: boolean
+  spaceScore?: boolean
+  originalityScore?: boolean
+  relevanceScore?: boolean
+  submittedAt?: boolean
+}
+
+export type SubmissionOmit<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetOmit<"id" | "matchId" | "userId" | "questionId" | "code" | "language" | "charCount" | "stdout" | "stderr" | "exitCode" | "execTimeMs" | "testsPassed" | "testsTotal" | "timeComplexity" | "timeScore" | "spaceComplexity" | "spaceScore" | "originalityScore" | "relevanceScore" | "submittedAt", ExtArgs["result"]["submission"]>
+export type SubmissionInclude<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  match?: boolean | Prisma.MatchDefaultArgs<ExtArgs>
+  user?: boolean | Prisma.UserDefaultArgs<ExtArgs>
+  question?: boolean | Prisma.QuestionDefaultArgs<ExtArgs>
+}
+export type SubmissionIncludeCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  match?: boolean | Prisma.MatchDefaultArgs<ExtArgs>
+  user?: boolean | Prisma.UserDefaultArgs<ExtArgs>
+  question?: boolean | Prisma.QuestionDefaultArgs<ExtArgs>
+}
+export type SubmissionIncludeUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  match?: boolean | Prisma.MatchDefaultArgs<ExtArgs>
+  user?: boolean | Prisma.UserDefaultArgs<ExtArgs>
+  question?: boolean | Prisma.QuestionDefaultArgs<ExtArgs>
+}
+
+export type $SubmissionPayload<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  name: "Submission"
+  objects: {
+    match: Prisma.$MatchPayload<ExtArgs>
+    user: Prisma.$UserPayload<ExtArgs>
+    question: Prisma.$QuestionPayload<ExtArgs>
+  }
+  scalars: runtime.Types.Extensions.GetPayloadResult<{
+    id: string
+    matchId: string
+    userId: string
+    questionId: string
+    code: string
+    language: string
+    charCount: number | null
+    stdout: string | null
+    stderr: string | null
+    exitCode: number | null
+    execTimeMs: number | null
+    testsPassed: number
+    testsTotal: number
+    timeComplexity: string | null
+    timeScore: number | null
+    spaceComplexity: string | null
+    spaceScore: number | null
+    originalityScore: number | null
+    relevanceScore: number | null
+    submittedAt: Date
+  }, ExtArgs["result"]["submission"]>
+  composites: {}
+}
+
+export type SubmissionGetPayload<S extends boolean | null | undefined | SubmissionDefaultArgs> = runtime.Types.Result.GetResult<Prisma.$SubmissionPayload, S>
+
+export type SubmissionCountArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> =
+  Omit<SubmissionFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
+    select?: SubmissionCountAggregateInputType | true
+  }
+
+export interface SubmissionDelegate<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> {
+  [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Submission'], meta: { name: 'Submission' } }
+  /**
+   * Find zero or one Submission that matches the filter.
+   * @param {SubmissionFindUniqueArgs} args - Arguments to find a Submission
+   * @example
+   * // Get one Submission
+   * const submission = await prisma.submission.findUnique({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   */
+  findUnique<T extends SubmissionFindUniqueArgs>(args: Prisma.SelectSubset<T, SubmissionFindUniqueArgs<ExtArgs>>): Prisma.Prisma__SubmissionClient<runtime.Types.Result.GetResult<Prisma.$SubmissionPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Find one Submission that matches the filter or throw an error with `error.code='P2025'`
+   * if no matches were found.
+   * @param {SubmissionFindUniqueOrThrowArgs} args - Arguments to find a Submission
+   * @example
+   * // Get one Submission
+   * const submission = await prisma.submission.findUniqueOrThrow({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   */
+  findUniqueOrThrow<T extends SubmissionFindUniqueOrThrowArgs>(args: Prisma.SelectSubset<T, SubmissionFindUniqueOrThrowArgs<ExtArgs>>): Prisma.Prisma__SubmissionClient<runtime.Types.Result.GetResult<Prisma.$SubmissionPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Find the first Submission that matches the filter.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {SubmissionFindFirstArgs} args - Arguments to find a Submission
+   * @example
+   * // Get one Submission
+   * const submission = await prisma.submission.findFirst({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   */
+  findFirst<T extends SubmissionFindFirstArgs>(args?: Prisma.SelectSubset<T, SubmissionFindFirstArgs<ExtArgs>>): Prisma.Prisma__SubmissionClient<runtime.Types.Result.GetResult<Prisma.$SubmissionPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Find the first Submission that matches the filter or
+   * throw `PrismaKnownClientError` with `P2025` code if no matches were found.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {SubmissionFindFirstOrThrowArgs} args - Arguments to find a Submission
+   * @example
+   * // Get one Submission
+   * const submission = await prisma.submission.findFirstOrThrow({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   */
+  findFirstOrThrow<T extends SubmissionFindFirstOrThrowArgs>(args?: Prisma.SelectSubset<T, SubmissionFindFirstOrThrowArgs<ExtArgs>>): Prisma.Prisma__SubmissionClient<runtime.Types.Result.GetResult<Prisma.$SubmissionPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Find zero or more Submissions that matches the filter.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {SubmissionFindManyArgs} args - Arguments to filter and select certain fields only.
+   * @example
+   * // Get all Submissions
+   * const submissions = await prisma.submission.findMany()
+   * 
+   * // Get first 10 Submissions
+   * const submissions = await prisma.submission.findMany({ take: 10 })
+   * 
+   * // Only select the `id`
+   * const submissionWithIdOnly = await prisma.submission.findMany({ select: { id: true } })
+   * 
+   */
+  findMany<T extends SubmissionFindManyArgs>(args?: Prisma.SelectSubset<T, SubmissionFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$SubmissionPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>
+
+  /**
+   * Create a Submission.
+   * @param {SubmissionCreateArgs} args - Arguments to create a Submission.
+   * @example
+   * // Create one Submission
+   * const Submission = await prisma.submission.create({
+   *   data: {
+   *     // ... data to create a Submission
+   *   }
+   * })
+   * 
+   */
+  create<T extends SubmissionCreateArgs>(args: Prisma.SelectSubset<T, SubmissionCreateArgs<ExtArgs>>): Prisma.Prisma__SubmissionClient<runtime.Types.Result.GetResult<Prisma.$SubmissionPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Create many Submissions.
+   * @param {SubmissionCreateManyArgs} args - Arguments to create many Submissions.
+   * @example
+   * // Create many Submissions
+   * const submission = await prisma.submission.createMany({
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   *     
+   */
+  createMany<T extends SubmissionCreateManyArgs>(args?: Prisma.SelectSubset<T, SubmissionCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>
+
+  /**
+   * Create many Submissions and returns the data saved in the database.
+   * @param {SubmissionCreateManyAndReturnArgs} args - Arguments to create many Submissions.
+   * @example
+   * // Create many Submissions
+   * const submission = await prisma.submission.createManyAndReturn({
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   * 
+   * // Create many Submissions and only return the `id`
+   * const submissionWithIdOnly = await prisma.submission.createManyAndReturn({
+   *   select: { id: true },
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * 
+   */
+  createManyAndReturn<T extends SubmissionCreateManyAndReturnArgs>(args?: Prisma.SelectSubset<T, SubmissionCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$SubmissionPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>
+
+  /**
+   * Delete a Submission.
+   * @param {SubmissionDeleteArgs} args - Arguments to delete one Submission.
+   * @example
+   * // Delete one Submission
+   * const Submission = await prisma.submission.delete({
+   *   where: {
+   *     // ... filter to delete one Submission
+   *   }
+   * })
+   * 
+   */
+  delete<T extends SubmissionDeleteArgs>(args: Prisma.SelectSubset<T, SubmissionDeleteArgs<ExtArgs>>): Prisma.Prisma__SubmissionClient<runtime.Types.Result.GetResult<Prisma.$SubmissionPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Update one Submission.
+   * @param {SubmissionUpdateArgs} args - Arguments to update one Submission.
+   * @example
+   * // Update one Submission
+   * const submission = await prisma.submission.update({
+   *   where: {
+   *     // ... provide filter here
+   *   },
+   *   data: {
+   *     // ... provide data here
+   *   }
+   * })
+   * 
+   */
+  update<T extends SubmissionUpdateArgs>(args: Prisma.SelectSubset<T, SubmissionUpdateArgs<ExtArgs>>): Prisma.Prisma__SubmissionClient<runtime.Types.Result.GetResult<Prisma.$SubmissionPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Delete zero or more Submissions.
+   * @param {SubmissionDeleteManyArgs} args - Arguments to filter Submissions to delete.
+   * @example
+   * // Delete a few Submissions
+   * const { count } = await prisma.submission.deleteMany({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   * 
+   */
+  deleteMany<T extends SubmissionDeleteManyArgs>(args?: Prisma.SelectSubset<T, SubmissionDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>
+
+  /**
+   * Update zero or more Submissions.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {SubmissionUpdateManyArgs} args - Arguments to update one or more rows.
+   * @example
+   * // Update many Submissions
+   * const submission = await prisma.submission.updateMany({
+   *   where: {
+   *     // ... provide filter here
+   *   },
+   *   data: {
+   *     // ... provide data here
+   *   }
+   * })
+   * 
+   */
+  updateMany<T extends SubmissionUpdateManyArgs>(args: Prisma.SelectSubset<T, SubmissionUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>
+
+  /**
+   * Update zero or more Submissions and returns the data updated in the database.
+   * @param {SubmissionUpdateManyAndReturnArgs} args - Arguments to update many Submissions.
+   * @example
+   * // Update many Submissions
+   * const submission = await prisma.submission.updateManyAndReturn({
+   *   where: {
+   *     // ... provide filter here
+   *   },
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   * 
+   * // Update zero or more Submissions and only return the `id`
+   * const submissionWithIdOnly = await prisma.submission.updateManyAndReturn({
+   *   select: { id: true },
+   *   where: {
+   *     // ... provide filter here
+   *   },
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * 
+   */
+  updateManyAndReturn<T extends SubmissionUpdateManyAndReturnArgs>(args: Prisma.SelectSubset<T, SubmissionUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$SubmissionPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>
+
+  /**
+   * Create or update one Submission.
+   * @param {SubmissionUpsertArgs} args - Arguments to update or create a Submission.
+   * @example
+   * // Update or create a Submission
+   * const submission = await prisma.submission.upsert({
+   *   create: {
+   *     // ... data to create a Submission
+   *   },
+   *   update: {
+   *     // ... in case it already exists, update
+   *   },
+   *   where: {
+   *     // ... the filter for the Submission we want to update
+   *   }
+   * })
+   */
+  upsert<T extends SubmissionUpsertArgs>(args: Prisma.SelectSubset<T, SubmissionUpsertArgs<ExtArgs>>): Prisma.Prisma__SubmissionClient<runtime.Types.Result.GetResult<Prisma.$SubmissionPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+
+  /**
+   * Count the number of Submissions.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {SubmissionCountArgs} args - Arguments to filter Submissions to count.
+   * @example
+   * // Count the number of Submissions
+   * const count = await prisma.submission.count({
+   *   where: {
+   *     // ... the filter for the Submissions we want to count
+   *   }
+   * })
+  **/
+  count<T extends SubmissionCountArgs>(
+    args?: Prisma.Subset<T, SubmissionCountArgs>,
+  ): Prisma.PrismaPromise<
+    T extends runtime.Types.Utils.Record<'select', any>
+      ? T['select'] extends true
+        ? number
+        : Prisma.GetScalarType<T['select'], SubmissionCountAggregateOutputType>
+      : number
+  >
+
+  /**
+   * Allows you to perform aggregations operations on a Submission.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {SubmissionAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
+   * @example
+   * // Ordered by age ascending
+   * // Where email contains prisma.io
+   * // Limited to the 10 users
+   * const aggregations = await prisma.user.aggregate({
+   *   _avg: {
+   *     age: true,
+   *   },
+   *   where: {
+   *     email: {
+   *       contains: "prisma.io",
+   *     },
+   *   },
+   *   orderBy: {
+   *     age: "asc",
+   *   },
+   *   take: 10,
+   * })
+  **/
+  aggregate<T extends SubmissionAggregateArgs>(args: Prisma.Subset<T, SubmissionAggregateArgs>): Prisma.PrismaPromise<GetSubmissionAggregateType<T>>
+
+  /**
+   * Group by Submission.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {SubmissionGroupByArgs} args - Group by arguments.
+   * @example
+   * // Group by city, order by createdAt, get count
+   * const result = await prisma.user.groupBy({
+   *   by: ['city', 'createdAt'],
+   *   orderBy: {
+   *     createdAt: true
+   *   },
+   *   _count: {
+   *     _all: true
+   *   },
+   * })
+   * 
+  **/
+  groupBy<
+    T extends SubmissionGroupByArgs,
+    HasSelectOrTake extends Prisma.Or<
+      Prisma.Extends<'skip', Prisma.Keys<T>>,
+      Prisma.Extends<'take', Prisma.Keys<T>>
+    >,
+    OrderByArg extends Prisma.True extends HasSelectOrTake
+      ? { orderBy: SubmissionGroupByArgs['orderBy'] }
+      : { orderBy?: SubmissionGroupByArgs['orderBy'] },
+    OrderFields extends Prisma.ExcludeUnderscoreKeys<Prisma.Keys<Prisma.MaybeTupleToUnion<T['orderBy']>>>,
+    ByFields extends Prisma.MaybeTupleToUnion<T['by']>,
+    ByValid extends Prisma.Has<ByFields, OrderFields>,
+    HavingFields extends Prisma.GetHavingFields<T['having']>,
+    HavingValid extends Prisma.Has<ByFields, HavingFields>,
+    ByEmpty extends T['by'] extends never[] ? Prisma.True : Prisma.False,
+    InputErrors extends ByEmpty extends Prisma.True
+    ? `Error: "by" must not be empty.`
+    : HavingValid extends Prisma.False
+    ? {
+        [P in HavingFields]: P extends ByFields
+          ? never
+          : P extends string
+          ? `Error: Field "${P}" used in "having" needs to be provided in "by".`
+          : [
+              Error,
+              'Field ',
+              P,
+              ` in "having" needs to be provided in "by"`,
+            ]
+      }[HavingFields]
+    : 'take' extends Prisma.Keys<T>
+    ? 'orderBy' extends Prisma.Keys<T>
+      ? ByValid extends Prisma.True
+        ? {}
+        : {
+            [P in OrderFields]: P extends ByFields
+              ? never
+              : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
+          }[OrderFields]
+      : 'Error: If you provide "take", you also need to provide "orderBy"'
+    : 'skip' extends Prisma.Keys<T>
+    ? 'orderBy' extends Prisma.Keys<T>
+      ? ByValid extends Prisma.True
+        ? {}
+        : {
+            [P in OrderFields]: P extends ByFields
+              ? never
+              : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
+          }[OrderFields]
+      : 'Error: If you provide "skip", you also need to provide "orderBy"'
+    : ByValid extends Prisma.True
+    ? {}
+    : {
+        [P in OrderFields]: P extends ByFields
+          ? never
+          : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
+      }[OrderFields]
+  >(args: Prisma.SubsetIntersection<T, SubmissionGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetSubmissionGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
+/**
+ * Fields of the Submission model
+ */
+readonly fields: SubmissionFieldRefs;
+}
+
+/**
+ * The delegate class that acts as a "Promise-like" for Submission.
+ * Why is this prefixed with `Prisma__`?
+ * Because we want to prevent naming conflicts as mentioned in
+ * https://github.com/prisma/prisma-client-js/issues/707
+ */
+export interface Prisma__SubmissionClient<T, Null = never, ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
+  readonly [Symbol.toStringTag]: "PrismaPromise"
+  match<T extends Prisma.MatchDefaultArgs<ExtArgs> = {}>(args?: Prisma.Subset<T, Prisma.MatchDefaultArgs<ExtArgs>>): Prisma.Prisma__MatchClient<runtime.Types.Result.GetResult<Prisma.$MatchPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
+  user<T extends Prisma.UserDefaultArgs<ExtArgs> = {}>(args?: Prisma.Subset<T, Prisma.UserDefaultArgs<ExtArgs>>): Prisma.Prisma__UserClient<runtime.Types.Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
+  question<T extends Prisma.QuestionDefaultArgs<ExtArgs> = {}>(args?: Prisma.Subset<T, Prisma.QuestionDefaultArgs<ExtArgs>>): Prisma.Prisma__QuestionClient<runtime.Types.Result.GetResult<Prisma.$QuestionPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
+  /**
+   * Attaches callbacks for the resolution and/or rejection of the Promise.
+   * @param onfulfilled The callback to execute when the Promise is resolved.
+   * @param onrejected The callback to execute when the Promise is rejected.
+   * @returns A Promise for the completion of which ever callback is executed.
+   */
+  then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): runtime.Types.Utils.JsPromise<TResult1 | TResult2>
+  /**
+   * Attaches a callback for only the rejection of the Promise.
+   * @param onrejected The callback to execute when the Promise is rejected.
+   * @returns A Promise for the completion of the callback.
+   */
+  catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): runtime.Types.Utils.JsPromise<T | TResult>
+  /**
+   * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
+   * resolved value cannot be modified from the callback.
+   * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
+   * @returns A Promise for the completion of the callback.
+   */
+  finally(onfinally?: (() => void) | undefined | null): runtime.Types.Utils.JsPromise<T>
+}
+
+
+
+
+/**
+ * Fields of the Submission model
+ */
+export interface SubmissionFieldRefs {
+  readonly id: Prisma.FieldRef<"Submission", 'String'>
+  readonly matchId: Prisma.FieldRef<"Submission", 'String'>
+  readonly userId: Prisma.FieldRef<"Submission", 'String'>
+  readonly questionId: Prisma.FieldRef<"Submission", 'String'>
+  readonly code: Prisma.FieldRef<"Submission", 'String'>
+  readonly language: Prisma.FieldRef<"Submission", 'String'>
+  readonly charCount: Prisma.FieldRef<"Submission", 'Int'>
+  readonly stdout: Prisma.FieldRef<"Submission", 'String'>
+  readonly stderr: Prisma.FieldRef<"Submission", 'String'>
+  readonly exitCode: Prisma.FieldRef<"Submission", 'Int'>
+  readonly execTimeMs: Prisma.FieldRef<"Submission", 'Int'>
+  readonly testsPassed: Prisma.FieldRef<"Submission", 'Int'>
+  readonly testsTotal: Prisma.FieldRef<"Submission", 'Int'>
+  readonly timeComplexity: Prisma.FieldRef<"Submission", 'String'>
+  readonly timeScore: Prisma.FieldRef<"Submission", 'Float'>
+  readonly spaceComplexity: Prisma.FieldRef<"Submission", 'String'>
+  readonly spaceScore: Prisma.FieldRef<"Submission", 'Float'>
+  readonly originalityScore: Prisma.FieldRef<"Submission", 'Float'>
+  readonly relevanceScore: Prisma.FieldRef<"Submission", 'Float'>
+  readonly submittedAt: Prisma.FieldRef<"Submission", 'DateTime'>
+}
+    
+
+// Custom InputTypes
+/**
+ * Submission findUnique
+ */
+export type SubmissionFindUniqueArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Submission
+   */
+  select?: Prisma.SubmissionSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Submission
+   */
+  omit?: Prisma.SubmissionOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.SubmissionInclude<ExtArgs> | null
+  /**
+   * Filter, which Submission to fetch.
+   */
+  where: Prisma.SubmissionWhereUniqueInput
+}
+
+/**
+ * Submission findUniqueOrThrow
+ */
+export type SubmissionFindUniqueOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Submission
+   */
+  select?: Prisma.SubmissionSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Submission
+   */
+  omit?: Prisma.SubmissionOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.SubmissionInclude<ExtArgs> | null
+  /**
+   * Filter, which Submission to fetch.
+   */
+  where: Prisma.SubmissionWhereUniqueInput
+}
+
+/**
+ * Submission findFirst
+ */
+export type SubmissionFindFirstArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Submission
+   */
+  select?: Prisma.SubmissionSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Submission
+   */
+  omit?: Prisma.SubmissionOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.SubmissionInclude<ExtArgs> | null
+  /**
+   * Filter, which Submission to fetch.
+   */
+  where?: Prisma.SubmissionWhereInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+   * 
+   * Determine the order of Submissions to fetch.
+   */
+  orderBy?: Prisma.SubmissionOrderByWithRelationInput | Prisma.SubmissionOrderByWithRelationInput[]
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+   * 
+   * Sets the position for searching for Submissions.
+   */
+  cursor?: Prisma.SubmissionWhereUniqueInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Take `±n` Submissions from the position of the cursor.
+   */
+  take?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Skip the first `n` Submissions.
+   */
+  skip?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+   * 
+   * Filter by unique combinations of Submissions.
+   */
+  distinct?: Prisma.SubmissionScalarFieldEnum | Prisma.SubmissionScalarFieldEnum[]
+}
+
+/**
+ * Submission findFirstOrThrow
+ */
+export type SubmissionFindFirstOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Submission
+   */
+  select?: Prisma.SubmissionSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Submission
+   */
+  omit?: Prisma.SubmissionOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.SubmissionInclude<ExtArgs> | null
+  /**
+   * Filter, which Submission to fetch.
+   */
+  where?: Prisma.SubmissionWhereInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+   * 
+   * Determine the order of Submissions to fetch.
+   */
+  orderBy?: Prisma.SubmissionOrderByWithRelationInput | Prisma.SubmissionOrderByWithRelationInput[]
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+   * 
+   * Sets the position for searching for Submissions.
+   */
+  cursor?: Prisma.SubmissionWhereUniqueInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Take `±n` Submissions from the position of the cursor.
+   */
+  take?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Skip the first `n` Submissions.
+   */
+  skip?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+   * 
+   * Filter by unique combinations of Submissions.
+   */
+  distinct?: Prisma.SubmissionScalarFieldEnum | Prisma.SubmissionScalarFieldEnum[]
+}
+
+/**
+ * Submission findMany
+ */
+export type SubmissionFindManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Submission
+   */
+  select?: Prisma.SubmissionSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Submission
+   */
+  omit?: Prisma.SubmissionOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.SubmissionInclude<ExtArgs> | null
+  /**
+   * Filter, which Submissions to fetch.
+   */
+  where?: Prisma.SubmissionWhereInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+   * 
+   * Determine the order of Submissions to fetch.
+   */
+  orderBy?: Prisma.SubmissionOrderByWithRelationInput | Prisma.SubmissionOrderByWithRelationInput[]
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+   * 
+   * Sets the position for listing Submissions.
+   */
+  cursor?: Prisma.SubmissionWhereUniqueInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Take `±n` Submissions from the position of the cursor.
+   */
+  take?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Skip the first `n` Submissions.
+   */
+  skip?: number
+  distinct?: Prisma.SubmissionScalarFieldEnum | Prisma.SubmissionScalarFieldEnum[]
+}
+
+/**
+ * Submission create
+ */
+export type SubmissionCreateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Submission
+   */
+  select?: Prisma.SubmissionSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Submission
+   */
+  omit?: Prisma.SubmissionOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.SubmissionInclude<ExtArgs> | null
+  /**
+   * The data needed to create a Submission.
+   */
+  data: Prisma.XOR<Prisma.SubmissionCreateInput, Prisma.SubmissionUncheckedCreateInput>
+}
+
+/**
+ * Submission createMany
+ */
+export type SubmissionCreateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * The data used to create many Submissions.
+   */
+  data: Prisma.SubmissionCreateManyInput | Prisma.SubmissionCreateManyInput[]
+  skipDuplicates?: boolean
+}
+
+/**
+ * Submission createManyAndReturn
+ */
+export type SubmissionCreateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Submission
+   */
+  select?: Prisma.SubmissionSelectCreateManyAndReturn<ExtArgs> | null
+  /**
+   * Omit specific fields from the Submission
+   */
+  omit?: Prisma.SubmissionOmit<ExtArgs> | null
+  /**
+   * The data used to create many Submissions.
+   */
+  data: Prisma.SubmissionCreateManyInput | Prisma.SubmissionCreateManyInput[]
+  skipDuplicates?: boolean
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.SubmissionIncludeCreateManyAndReturn<ExtArgs> | null
+}
+
+/**
+ * Submission update
+ */
+export type SubmissionUpdateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Submission
+   */
+  select?: Prisma.SubmissionSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Submission
+   */
+  omit?: Prisma.SubmissionOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.SubmissionInclude<ExtArgs> | null
+  /**
+   * The data needed to update a Submission.
+   */
+  data: Prisma.XOR<Prisma.SubmissionUpdateInput, Prisma.SubmissionUncheckedUpdateInput>
+  /**
+   * Choose, which Submission to update.
+   */
+  where: Prisma.SubmissionWhereUniqueInput
+}
+
+/**
+ * Submission updateMany
+ */
+export type SubmissionUpdateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * The data used to update Submissions.
+   */
+  data: Prisma.XOR<Prisma.SubmissionUpdateManyMutationInput, Prisma.SubmissionUncheckedUpdateManyInput>
+  /**
+   * Filter which Submissions to update
+   */
+  where?: Prisma.SubmissionWhereInput
+  /**
+   * Limit how many Submissions to update.
+   */
+  limit?: number
+}
+
+/**
+ * Submission updateManyAndReturn
+ */
+export type SubmissionUpdateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Submission
+   */
+  select?: Prisma.SubmissionSelectUpdateManyAndReturn<ExtArgs> | null
+  /**
+   * Omit specific fields from the Submission
+   */
+  omit?: Prisma.SubmissionOmit<ExtArgs> | null
+  /**
+   * The data used to update Submissions.
+   */
+  data: Prisma.XOR<Prisma.SubmissionUpdateManyMutationInput, Prisma.SubmissionUncheckedUpdateManyInput>
+  /**
+   * Filter which Submissions to update
+   */
+  where?: Prisma.SubmissionWhereInput
+  /**
+   * Limit how many Submissions to update.
+   */
+  limit?: number
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.SubmissionIncludeUpdateManyAndReturn<ExtArgs> | null
+}
+
+/**
+ * Submission upsert
+ */
+export type SubmissionUpsertArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Submission
+   */
+  select?: Prisma.SubmissionSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Submission
+   */
+  omit?: Prisma.SubmissionOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.SubmissionInclude<ExtArgs> | null
+  /**
+   * The filter to search for the Submission to update in case it exists.
+   */
+  where: Prisma.SubmissionWhereUniqueInput
+  /**
+   * In case the Submission found by the `where` argument doesn't exist, create a new Submission with this data.
+   */
+  create: Prisma.XOR<Prisma.SubmissionCreateInput, Prisma.SubmissionUncheckedCreateInput>
+  /**
+   * In case the Submission was found with the provided `where` argument, update it with this data.
+   */
+  update: Prisma.XOR<Prisma.SubmissionUpdateInput, Prisma.SubmissionUncheckedUpdateInput>
+}
+
+/**
+ * Submission delete
+ */
+export type SubmissionDeleteArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Submission
+   */
+  select?: Prisma.SubmissionSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Submission
+   */
+  omit?: Prisma.SubmissionOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.SubmissionInclude<ExtArgs> | null
+  /**
+   * Filter which Submission to delete.
+   */
+  where: Prisma.SubmissionWhereUniqueInput
+}
+
+/**
+ * Submission deleteMany
+ */
+export type SubmissionDeleteManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Filter which Submissions to delete
+   */
+  where?: Prisma.SubmissionWhereInput
+  /**
+   * Limit how many Submissions to delete.
+   */
+  limit?: number
+}
+
+/**
+ * Submission without action
+ */
+export type SubmissionDefaultArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Submission
+   */
+  select?: Prisma.SubmissionSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Submission
+   */
+  omit?: Prisma.SubmissionOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.SubmissionInclude<ExtArgs> | null
+}
diff --git a/prisma/generated/prisma/models/User.ts b/prisma/generated/prisma/models/User.ts
new file mode 100644
index 0000000..c3826ea
--- /dev/null
+++ b/prisma/generated/prisma/models/User.ts
@@ -0,0 +1,1918 @@
+
+/* !!! This is code generated by Prisma. Do not edit directly. !!! */
+/* eslint-disable */
+// biome-ignore-all lint: generated file
+// @ts-nocheck 
+/*
+ * This file exports the `User` model and its related types.
+ *
+ * 🟢 You can import this file directly.
+ */
+import type * as runtime from "@prisma/client/runtime/client"
+import type * as $Enums from "../enums"
+import type * as Prisma from "../internal/prismaNamespace"
+
+/**
+ * Model User
+ * 
+ */
+export type UserModel = runtime.Types.Result.DefaultSelection<Prisma.$UserPayload>
+
+export type AggregateUser = {
+  _count: UserCountAggregateOutputType | null
+  _avg: UserAvgAggregateOutputType | null
+  _sum: UserSumAggregateOutputType | null
+  _min: UserMinAggregateOutputType | null
+  _max: UserMaxAggregateOutputType | null
+}
+
+export type UserAvgAggregateOutputType = {
+  elo: number | null
+  totalWins: number | null
+  totalMatches: number | null
+}
+
+export type UserSumAggregateOutputType = {
+  elo: number | null
+  totalWins: number | null
+  totalMatches: number | null
+}
+
+export type UserMinAggregateOutputType = {
+  id: string | null
+  username: string | null
+  email: string | null
+  passwordHash: string | null
+  displayName: string | null
+  avatarUrl: string | null
+  skillTier: $Enums.SkillTier | null
+  elo: number | null
+  totalWins: number | null
+  totalMatches: number | null
+  createdAt: Date | null
+  updatedAt: Date | null
+}
+
+export type UserMaxAggregateOutputType = {
+  id: string | null
+  username: string | null
+  email: string | null
+  passwordHash: string | null
+  displayName: string | null
+  avatarUrl: string | null
+  skillTier: $Enums.SkillTier | null
+  elo: number | null
+  totalWins: number | null
+  totalMatches: number | null
+  createdAt: Date | null
+  updatedAt: Date | null
+}
+
+export type UserCountAggregateOutputType = {
+  id: number
+  username: number
+  email: number
+  passwordHash: number
+  displayName: number
+  avatarUrl: number
+  skillTier: number
+  elo: number
+  totalWins: number
+  totalMatches: number
+  createdAt: number
+  updatedAt: number
+  _all: number
+}
+
+
+export type UserAvgAggregateInputType = {
+  elo?: true
+  totalWins?: true
+  totalMatches?: true
+}
+
+export type UserSumAggregateInputType = {
+  elo?: true
+  totalWins?: true
+  totalMatches?: true
+}
+
+export type UserMinAggregateInputType = {
+  id?: true
+  username?: true
+  email?: true
+  passwordHash?: true
+  displayName?: true
+  avatarUrl?: true
+  skillTier?: true
+  elo?: true
+  totalWins?: true
+  totalMatches?: true
+  createdAt?: true
+  updatedAt?: true
+}
+
+export type UserMaxAggregateInputType = {
+  id?: true
+  username?: true
+  email?: true
+  passwordHash?: true
+  displayName?: true
+  avatarUrl?: true
+  skillTier?: true
+  elo?: true
+  totalWins?: true
+  totalMatches?: true
+  createdAt?: true
+  updatedAt?: true
+}
+
+export type UserCountAggregateInputType = {
+  id?: true
+  username?: true
+  email?: true
+  passwordHash?: true
+  displayName?: true
+  avatarUrl?: true
+  skillTier?: true
+  elo?: true
+  totalWins?: true
+  totalMatches?: true
+  createdAt?: true
+  updatedAt?: true
+  _all?: true
+}
+
+export type UserAggregateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Filter which User to aggregate.
+   */
+  where?: Prisma.UserWhereInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+   * 
+   * Determine the order of Users to fetch.
+   */
+  orderBy?: Prisma.UserOrderByWithRelationInput | Prisma.UserOrderByWithRelationInput[]
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+   * 
+   * Sets the start position
+   */
+  cursor?: Prisma.UserWhereUniqueInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Take `±n` Users from the position of the cursor.
+   */
+  take?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Skip the first `n` Users.
+   */
+  skip?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Count returned Users
+  **/
+  _count?: true | UserCountAggregateInputType
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Select which fields to average
+  **/
+  _avg?: UserAvgAggregateInputType
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Select which fields to sum
+  **/
+  _sum?: UserSumAggregateInputType
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Select which fields to find the minimum value
+  **/
+  _min?: UserMinAggregateInputType
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Select which fields to find the maximum value
+  **/
+  _max?: UserMaxAggregateInputType
+}
+
+export type GetUserAggregateType<T extends UserAggregateArgs> = {
+      [P in keyof T & keyof AggregateUser]: P extends '_count' | 'count'
+    ? T[P] extends true
+      ? number
+      : Prisma.GetScalarType<T[P], AggregateUser[P]>
+    : Prisma.GetScalarType<T[P], AggregateUser[P]>
+}
+
+
+
+
+export type UserGroupByArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  where?: Prisma.UserWhereInput
+  orderBy?: Prisma.UserOrderByWithAggregationInput | Prisma.UserOrderByWithAggregationInput[]
+  by: Prisma.UserScalarFieldEnum[] | Prisma.UserScalarFieldEnum
+  having?: Prisma.UserScalarWhereWithAggregatesInput
+  take?: number
+  skip?: number
+  _count?: UserCountAggregateInputType | true
+  _avg?: UserAvgAggregateInputType
+  _sum?: UserSumAggregateInputType
+  _min?: UserMinAggregateInputType
+  _max?: UserMaxAggregateInputType
+}
+
+export type UserGroupByOutputType = {
+  id: string
+  username: string
+  email: string
+  passwordHash: string
+  displayName: string | null
+  avatarUrl: string | null
+  skillTier: $Enums.SkillTier
+  elo: number
+  totalWins: number
+  totalMatches: number
+  createdAt: Date
+  updatedAt: Date
+  _count: UserCountAggregateOutputType | null
+  _avg: UserAvgAggregateOutputType | null
+  _sum: UserSumAggregateOutputType | null
+  _min: UserMinAggregateOutputType | null
+  _max: UserMaxAggregateOutputType | null
+}
+
+type GetUserGroupByPayload<T extends UserGroupByArgs> = Prisma.PrismaPromise<
+  Array<
+    Prisma.PickEnumerable<UserGroupByOutputType, T['by']> &
+      {
+        [P in ((keyof T) & (keyof UserGroupByOutputType))]: P extends '_count'
+          ? T[P] extends boolean
+            ? number
+            : Prisma.GetScalarType<T[P], UserGroupByOutputType[P]>
+          : Prisma.GetScalarType<T[P], UserGroupByOutputType[P]>
+      }
+    >
+  >
+
+
+
+export type UserWhereInput = {
+  AND?: Prisma.UserWhereInput | Prisma.UserWhereInput[]
+  OR?: Prisma.UserWhereInput[]
+  NOT?: Prisma.UserWhereInput | Prisma.UserWhereInput[]
+  id?: Prisma.StringFilter<"User"> | string
+  username?: Prisma.StringFilter<"User"> | string
+  email?: Prisma.StringFilter<"User"> | string
+  passwordHash?: Prisma.StringFilter<"User"> | string
+  displayName?: Prisma.StringNullableFilter<"User"> | string | null
+  avatarUrl?: Prisma.StringNullableFilter<"User"> | string | null
+  skillTier?: Prisma.EnumSkillTierFilter<"User"> | $Enums.SkillTier
+  elo?: Prisma.IntFilter<"User"> | number
+  totalWins?: Prisma.IntFilter<"User"> | number
+  totalMatches?: Prisma.IntFilter<"User"> | number
+  createdAt?: Prisma.DateTimeFilter<"User"> | Date | string
+  updatedAt?: Prisma.DateTimeFilter<"User"> | Date | string
+  submissions?: Prisma.SubmissionListRelationFilter
+  matchPlayers?: Prisma.MatchPlayerListRelationFilter
+  queueEntries?: Prisma.QueueEntryListRelationFilter
+}
+
+export type UserOrderByWithRelationInput = {
+  id?: Prisma.SortOrder
+  username?: Prisma.SortOrder
+  email?: Prisma.SortOrder
+  passwordHash?: Prisma.SortOrder
+  displayName?: Prisma.SortOrderInput | Prisma.SortOrder
+  avatarUrl?: Prisma.SortOrderInput | Prisma.SortOrder
+  skillTier?: Prisma.SortOrder
+  elo?: Prisma.SortOrder
+  totalWins?: Prisma.SortOrder
+  totalMatches?: Prisma.SortOrder
+  createdAt?: Prisma.SortOrder
+  updatedAt?: Prisma.SortOrder
+  submissions?: Prisma.SubmissionOrderByRelationAggregateInput
+  matchPlayers?: Prisma.MatchPlayerOrderByRelationAggregateInput
+  queueEntries?: Prisma.QueueEntryOrderByRelationAggregateInput
+}
+
+export type UserWhereUniqueInput = Prisma.AtLeast<{
+  id?: string
+  username?: string
+  email?: string
+  AND?: Prisma.UserWhereInput | Prisma.UserWhereInput[]
+  OR?: Prisma.UserWhereInput[]
+  NOT?: Prisma.UserWhereInput | Prisma.UserWhereInput[]
+  passwordHash?: Prisma.StringFilter<"User"> | string
+  displayName?: Prisma.StringNullableFilter<"User"> | string | null
+  avatarUrl?: Prisma.StringNullableFilter<"User"> | string | null
+  skillTier?: Prisma.EnumSkillTierFilter<"User"> | $Enums.SkillTier
+  elo?: Prisma.IntFilter<"User"> | number
+  totalWins?: Prisma.IntFilter<"User"> | number
+  totalMatches?: Prisma.IntFilter<"User"> | number
+  createdAt?: Prisma.DateTimeFilter<"User"> | Date | string
+  updatedAt?: Prisma.DateTimeFilter<"User"> | Date | string
+  submissions?: Prisma.SubmissionListRelationFilter
+  matchPlayers?: Prisma.MatchPlayerListRelationFilter
+  queueEntries?: Prisma.QueueEntryListRelationFilter
+}, "id" | "username" | "email">
+
+export type UserOrderByWithAggregationInput = {
+  id?: Prisma.SortOrder
+  username?: Prisma.SortOrder
+  email?: Prisma.SortOrder
+  passwordHash?: Prisma.SortOrder
+  displayName?: Prisma.SortOrderInput | Prisma.SortOrder
+  avatarUrl?: Prisma.SortOrderInput | Prisma.SortOrder
+  skillTier?: Prisma.SortOrder
+  elo?: Prisma.SortOrder
+  totalWins?: Prisma.SortOrder
+  totalMatches?: Prisma.SortOrder
+  createdAt?: Prisma.SortOrder
+  updatedAt?: Prisma.SortOrder
+  _count?: Prisma.UserCountOrderByAggregateInput
+  _avg?: Prisma.UserAvgOrderByAggregateInput
+  _max?: Prisma.UserMaxOrderByAggregateInput
+  _min?: Prisma.UserMinOrderByAggregateInput
+  _sum?: Prisma.UserSumOrderByAggregateInput
+}
+
+export type UserScalarWhereWithAggregatesInput = {
+  AND?: Prisma.UserScalarWhereWithAggregatesInput | Prisma.UserScalarWhereWithAggregatesInput[]
+  OR?: Prisma.UserScalarWhereWithAggregatesInput[]
+  NOT?: Prisma.UserScalarWhereWithAggregatesInput | Prisma.UserScalarWhereWithAggregatesInput[]
+  id?: Prisma.StringWithAggregatesFilter<"User"> | string
+  username?: Prisma.StringWithAggregatesFilter<"User"> | string
+  email?: Prisma.StringWithAggregatesFilter<"User"> | string
+  passwordHash?: Prisma.StringWithAggregatesFilter<"User"> | string
+  displayName?: Prisma.StringNullableWithAggregatesFilter<"User"> | string | null
+  avatarUrl?: Prisma.StringNullableWithAggregatesFilter<"User"> | string | null
+  skillTier?: Prisma.EnumSkillTierWithAggregatesFilter<"User"> | $Enums.SkillTier
+  elo?: Prisma.IntWithAggregatesFilter<"User"> | number
+  totalWins?: Prisma.IntWithAggregatesFilter<"User"> | number
+  totalMatches?: Prisma.IntWithAggregatesFilter<"User"> | number
+  createdAt?: Prisma.DateTimeWithAggregatesFilter<"User"> | Date | string
+  updatedAt?: Prisma.DateTimeWithAggregatesFilter<"User"> | Date | string
+}
+
+export type UserCreateInput = {
+  id?: string
+  username: string
+  email: string
+  passwordHash: string
+  displayName?: string | null
+  avatarUrl?: string | null
+  skillTier?: $Enums.SkillTier
+  elo?: number
+  totalWins?: number
+  totalMatches?: number
+  createdAt?: Date | string
+  updatedAt?: Date | string
+  submissions?: Prisma.SubmissionCreateNestedManyWithoutUserInput
+  matchPlayers?: Prisma.MatchPlayerCreateNestedManyWithoutUserInput
+  queueEntries?: Prisma.QueueEntryCreateNestedManyWithoutUserInput
+}
+
+export type UserUncheckedCreateInput = {
+  id?: string
+  username: string
+  email: string
+  passwordHash: string
+  displayName?: string | null
+  avatarUrl?: string | null
+  skillTier?: $Enums.SkillTier
+  elo?: number
+  totalWins?: number
+  totalMatches?: number
+  createdAt?: Date | string
+  updatedAt?: Date | string
+  submissions?: Prisma.SubmissionUncheckedCreateNestedManyWithoutUserInput
+  matchPlayers?: Prisma.MatchPlayerUncheckedCreateNestedManyWithoutUserInput
+  queueEntries?: Prisma.QueueEntryUncheckedCreateNestedManyWithoutUserInput
+}
+
+export type UserUpdateInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  username?: Prisma.StringFieldUpdateOperationsInput | string
+  email?: Prisma.StringFieldUpdateOperationsInput | string
+  passwordHash?: Prisma.StringFieldUpdateOperationsInput | string
+  displayName?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  avatarUrl?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  skillTier?: Prisma.EnumSkillTierFieldUpdateOperationsInput | $Enums.SkillTier
+  elo?: Prisma.IntFieldUpdateOperationsInput | number
+  totalWins?: Prisma.IntFieldUpdateOperationsInput | number
+  totalMatches?: Prisma.IntFieldUpdateOperationsInput | number
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  submissions?: Prisma.SubmissionUpdateManyWithoutUserNestedInput
+  matchPlayers?: Prisma.MatchPlayerUpdateManyWithoutUserNestedInput
+  queueEntries?: Prisma.QueueEntryUpdateManyWithoutUserNestedInput
+}
+
+export type UserUncheckedUpdateInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  username?: Prisma.StringFieldUpdateOperationsInput | string
+  email?: Prisma.StringFieldUpdateOperationsInput | string
+  passwordHash?: Prisma.StringFieldUpdateOperationsInput | string
+  displayName?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  avatarUrl?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  skillTier?: Prisma.EnumSkillTierFieldUpdateOperationsInput | $Enums.SkillTier
+  elo?: Prisma.IntFieldUpdateOperationsInput | number
+  totalWins?: Prisma.IntFieldUpdateOperationsInput | number
+  totalMatches?: Prisma.IntFieldUpdateOperationsInput | number
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  submissions?: Prisma.SubmissionUncheckedUpdateManyWithoutUserNestedInput
+  matchPlayers?: Prisma.MatchPlayerUncheckedUpdateManyWithoutUserNestedInput
+  queueEntries?: Prisma.QueueEntryUncheckedUpdateManyWithoutUserNestedInput
+}
+
+export type UserCreateManyInput = {
+  id?: string
+  username: string
+  email: string
+  passwordHash: string
+  displayName?: string | null
+  avatarUrl?: string | null
+  skillTier?: $Enums.SkillTier
+  elo?: number
+  totalWins?: number
+  totalMatches?: number
+  createdAt?: Date | string
+  updatedAt?: Date | string
+}
+
+export type UserUpdateManyMutationInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  username?: Prisma.StringFieldUpdateOperationsInput | string
+  email?: Prisma.StringFieldUpdateOperationsInput | string
+  passwordHash?: Prisma.StringFieldUpdateOperationsInput | string
+  displayName?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  avatarUrl?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  skillTier?: Prisma.EnumSkillTierFieldUpdateOperationsInput | $Enums.SkillTier
+  elo?: Prisma.IntFieldUpdateOperationsInput | number
+  totalWins?: Prisma.IntFieldUpdateOperationsInput | number
+  totalMatches?: Prisma.IntFieldUpdateOperationsInput | number
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+}
+
+export type UserUncheckedUpdateManyInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  username?: Prisma.StringFieldUpdateOperationsInput | string
+  email?: Prisma.StringFieldUpdateOperationsInput | string
+  passwordHash?: Prisma.StringFieldUpdateOperationsInput | string
+  displayName?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  avatarUrl?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  skillTier?: Prisma.EnumSkillTierFieldUpdateOperationsInput | $Enums.SkillTier
+  elo?: Prisma.IntFieldUpdateOperationsInput | number
+  totalWins?: Prisma.IntFieldUpdateOperationsInput | number
+  totalMatches?: Prisma.IntFieldUpdateOperationsInput | number
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+}
+
+export type UserCountOrderByAggregateInput = {
+  id?: Prisma.SortOrder
+  username?: Prisma.SortOrder
+  email?: Prisma.SortOrder
+  passwordHash?: Prisma.SortOrder
+  displayName?: Prisma.SortOrder
+  avatarUrl?: Prisma.SortOrder
+  skillTier?: Prisma.SortOrder
+  elo?: Prisma.SortOrder
+  totalWins?: Prisma.SortOrder
+  totalMatches?: Prisma.SortOrder
+  createdAt?: Prisma.SortOrder
+  updatedAt?: Prisma.SortOrder
+}
+
+export type UserAvgOrderByAggregateInput = {
+  elo?: Prisma.SortOrder
+  totalWins?: Prisma.SortOrder
+  totalMatches?: Prisma.SortOrder
+}
+
+export type UserMaxOrderByAggregateInput = {
+  id?: Prisma.SortOrder
+  username?: Prisma.SortOrder
+  email?: Prisma.SortOrder
+  passwordHash?: Prisma.SortOrder
+  displayName?: Prisma.SortOrder
+  avatarUrl?: Prisma.SortOrder
+  skillTier?: Prisma.SortOrder
+  elo?: Prisma.SortOrder
+  totalWins?: Prisma.SortOrder
+  totalMatches?: Prisma.SortOrder
+  createdAt?: Prisma.SortOrder
+  updatedAt?: Prisma.SortOrder
+}
+
+export type UserMinOrderByAggregateInput = {
+  id?: Prisma.SortOrder
+  username?: Prisma.SortOrder
+  email?: Prisma.SortOrder
+  passwordHash?: Prisma.SortOrder
+  displayName?: Prisma.SortOrder
+  avatarUrl?: Prisma.SortOrder
+  skillTier?: Prisma.SortOrder
+  elo?: Prisma.SortOrder
+  totalWins?: Prisma.SortOrder
+  totalMatches?: Prisma.SortOrder
+  createdAt?: Prisma.SortOrder
+  updatedAt?: Prisma.SortOrder
+}
+
+export type UserSumOrderByAggregateInput = {
+  elo?: Prisma.SortOrder
+  totalWins?: Prisma.SortOrder
+  totalMatches?: Prisma.SortOrder
+}
+
+export type UserScalarRelationFilter = {
+  is?: Prisma.UserWhereInput
+  isNot?: Prisma.UserWhereInput
+}
+
+export type StringFieldUpdateOperationsInput = {
+  set?: string
+}
+
+export type NullableStringFieldUpdateOperationsInput = {
+  set?: string | null
+}
+
+export type EnumSkillTierFieldUpdateOperationsInput = {
+  set?: $Enums.SkillTier
+}
+
+export type IntFieldUpdateOperationsInput = {
+  set?: number
+  increment?: number
+  decrement?: number
+  multiply?: number
+  divide?: number
+}
+
+export type DateTimeFieldUpdateOperationsInput = {
+  set?: Date | string
+}
+
+export type UserCreateNestedOneWithoutQueueEntriesInput = {
+  create?: Prisma.XOR<Prisma.UserCreateWithoutQueueEntriesInput, Prisma.UserUncheckedCreateWithoutQueueEntriesInput>
+  connectOrCreate?: Prisma.UserCreateOrConnectWithoutQueueEntriesInput
+  connect?: Prisma.UserWhereUniqueInput
+}
+
+export type UserUpdateOneRequiredWithoutQueueEntriesNestedInput = {
+  create?: Prisma.XOR<Prisma.UserCreateWithoutQueueEntriesInput, Prisma.UserUncheckedCreateWithoutQueueEntriesInput>
+  connectOrCreate?: Prisma.UserCreateOrConnectWithoutQueueEntriesInput
+  upsert?: Prisma.UserUpsertWithoutQueueEntriesInput
+  connect?: Prisma.UserWhereUniqueInput
+  update?: Prisma.XOR<Prisma.XOR<Prisma.UserUpdateToOneWithWhereWithoutQueueEntriesInput, Prisma.UserUpdateWithoutQueueEntriesInput>, Prisma.UserUncheckedUpdateWithoutQueueEntriesInput>
+}
+
+export type UserCreateNestedOneWithoutMatchPlayersInput = {
+  create?: Prisma.XOR<Prisma.UserCreateWithoutMatchPlayersInput, Prisma.UserUncheckedCreateWithoutMatchPlayersInput>
+  connectOrCreate?: Prisma.UserCreateOrConnectWithoutMatchPlayersInput
+  connect?: Prisma.UserWhereUniqueInput
+}
+
+export type UserUpdateOneRequiredWithoutMatchPlayersNestedInput = {
+  create?: Prisma.XOR<Prisma.UserCreateWithoutMatchPlayersInput, Prisma.UserUncheckedCreateWithoutMatchPlayersInput>
+  connectOrCreate?: Prisma.UserCreateOrConnectWithoutMatchPlayersInput
+  upsert?: Prisma.UserUpsertWithoutMatchPlayersInput
+  connect?: Prisma.UserWhereUniqueInput
+  update?: Prisma.XOR<Prisma.XOR<Prisma.UserUpdateToOneWithWhereWithoutMatchPlayersInput, Prisma.UserUpdateWithoutMatchPlayersInput>, Prisma.UserUncheckedUpdateWithoutMatchPlayersInput>
+}
+
+export type UserCreateNestedOneWithoutSubmissionsInput = {
+  create?: Prisma.XOR<Prisma.UserCreateWithoutSubmissionsInput, Prisma.UserUncheckedCreateWithoutSubmissionsInput>
+  connectOrCreate?: Prisma.UserCreateOrConnectWithoutSubmissionsInput
+  connect?: Prisma.UserWhereUniqueInput
+}
+
+export type UserUpdateOneRequiredWithoutSubmissionsNestedInput = {
+  create?: Prisma.XOR<Prisma.UserCreateWithoutSubmissionsInput, Prisma.UserUncheckedCreateWithoutSubmissionsInput>
+  connectOrCreate?: Prisma.UserCreateOrConnectWithoutSubmissionsInput
+  upsert?: Prisma.UserUpsertWithoutSubmissionsInput
+  connect?: Prisma.UserWhereUniqueInput
+  update?: Prisma.XOR<Prisma.XOR<Prisma.UserUpdateToOneWithWhereWithoutSubmissionsInput, Prisma.UserUpdateWithoutSubmissionsInput>, Prisma.UserUncheckedUpdateWithoutSubmissionsInput>
+}
+
+export type UserCreateWithoutQueueEntriesInput = {
+  id?: string
+  username: string
+  email: string
+  passwordHash: string
+  displayName?: string | null
+  avatarUrl?: string | null
+  skillTier?: $Enums.SkillTier
+  elo?: number
+  totalWins?: number
+  totalMatches?: number
+  createdAt?: Date | string
+  updatedAt?: Date | string
+  submissions?: Prisma.SubmissionCreateNestedManyWithoutUserInput
+  matchPlayers?: Prisma.MatchPlayerCreateNestedManyWithoutUserInput
+}
+
+export type UserUncheckedCreateWithoutQueueEntriesInput = {
+  id?: string
+  username: string
+  email: string
+  passwordHash: string
+  displayName?: string | null
+  avatarUrl?: string | null
+  skillTier?: $Enums.SkillTier
+  elo?: number
+  totalWins?: number
+  totalMatches?: number
+  createdAt?: Date | string
+  updatedAt?: Date | string
+  submissions?: Prisma.SubmissionUncheckedCreateNestedManyWithoutUserInput
+  matchPlayers?: Prisma.MatchPlayerUncheckedCreateNestedManyWithoutUserInput
+}
+
+export type UserCreateOrConnectWithoutQueueEntriesInput = {
+  where: Prisma.UserWhereUniqueInput
+  create: Prisma.XOR<Prisma.UserCreateWithoutQueueEntriesInput, Prisma.UserUncheckedCreateWithoutQueueEntriesInput>
+}
+
+export type UserUpsertWithoutQueueEntriesInput = {
+  update: Prisma.XOR<Prisma.UserUpdateWithoutQueueEntriesInput, Prisma.UserUncheckedUpdateWithoutQueueEntriesInput>
+  create: Prisma.XOR<Prisma.UserCreateWithoutQueueEntriesInput, Prisma.UserUncheckedCreateWithoutQueueEntriesInput>
+  where?: Prisma.UserWhereInput
+}
+
+export type UserUpdateToOneWithWhereWithoutQueueEntriesInput = {
+  where?: Prisma.UserWhereInput
+  data: Prisma.XOR<Prisma.UserUpdateWithoutQueueEntriesInput, Prisma.UserUncheckedUpdateWithoutQueueEntriesInput>
+}
+
+export type UserUpdateWithoutQueueEntriesInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  username?: Prisma.StringFieldUpdateOperationsInput | string
+  email?: Prisma.StringFieldUpdateOperationsInput | string
+  passwordHash?: Prisma.StringFieldUpdateOperationsInput | string
+  displayName?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  avatarUrl?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  skillTier?: Prisma.EnumSkillTierFieldUpdateOperationsInput | $Enums.SkillTier
+  elo?: Prisma.IntFieldUpdateOperationsInput | number
+  totalWins?: Prisma.IntFieldUpdateOperationsInput | number
+  totalMatches?: Prisma.IntFieldUpdateOperationsInput | number
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  submissions?: Prisma.SubmissionUpdateManyWithoutUserNestedInput
+  matchPlayers?: Prisma.MatchPlayerUpdateManyWithoutUserNestedInput
+}
+
+export type UserUncheckedUpdateWithoutQueueEntriesInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  username?: Prisma.StringFieldUpdateOperationsInput | string
+  email?: Prisma.StringFieldUpdateOperationsInput | string
+  passwordHash?: Prisma.StringFieldUpdateOperationsInput | string
+  displayName?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  avatarUrl?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  skillTier?: Prisma.EnumSkillTierFieldUpdateOperationsInput | $Enums.SkillTier
+  elo?: Prisma.IntFieldUpdateOperationsInput | number
+  totalWins?: Prisma.IntFieldUpdateOperationsInput | number
+  totalMatches?: Prisma.IntFieldUpdateOperationsInput | number
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  submissions?: Prisma.SubmissionUncheckedUpdateManyWithoutUserNestedInput
+  matchPlayers?: Prisma.MatchPlayerUncheckedUpdateManyWithoutUserNestedInput
+}
+
+export type UserCreateWithoutMatchPlayersInput = {
+  id?: string
+  username: string
+  email: string
+  passwordHash: string
+  displayName?: string | null
+  avatarUrl?: string | null
+  skillTier?: $Enums.SkillTier
+  elo?: number
+  totalWins?: number
+  totalMatches?: number
+  createdAt?: Date | string
+  updatedAt?: Date | string
+  submissions?: Prisma.SubmissionCreateNestedManyWithoutUserInput
+  queueEntries?: Prisma.QueueEntryCreateNestedManyWithoutUserInput
+}
+
+export type UserUncheckedCreateWithoutMatchPlayersInput = {
+  id?: string
+  username: string
+  email: string
+  passwordHash: string
+  displayName?: string | null
+  avatarUrl?: string | null
+  skillTier?: $Enums.SkillTier
+  elo?: number
+  totalWins?: number
+  totalMatches?: number
+  createdAt?: Date | string
+  updatedAt?: Date | string
+  submissions?: Prisma.SubmissionUncheckedCreateNestedManyWithoutUserInput
+  queueEntries?: Prisma.QueueEntryUncheckedCreateNestedManyWithoutUserInput
+}
+
+export type UserCreateOrConnectWithoutMatchPlayersInput = {
+  where: Prisma.UserWhereUniqueInput
+  create: Prisma.XOR<Prisma.UserCreateWithoutMatchPlayersInput, Prisma.UserUncheckedCreateWithoutMatchPlayersInput>
+}
+
+export type UserUpsertWithoutMatchPlayersInput = {
+  update: Prisma.XOR<Prisma.UserUpdateWithoutMatchPlayersInput, Prisma.UserUncheckedUpdateWithoutMatchPlayersInput>
+  create: Prisma.XOR<Prisma.UserCreateWithoutMatchPlayersInput, Prisma.UserUncheckedCreateWithoutMatchPlayersInput>
+  where?: Prisma.UserWhereInput
+}
+
+export type UserUpdateToOneWithWhereWithoutMatchPlayersInput = {
+  where?: Prisma.UserWhereInput
+  data: Prisma.XOR<Prisma.UserUpdateWithoutMatchPlayersInput, Prisma.UserUncheckedUpdateWithoutMatchPlayersInput>
+}
+
+export type UserUpdateWithoutMatchPlayersInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  username?: Prisma.StringFieldUpdateOperationsInput | string
+  email?: Prisma.StringFieldUpdateOperationsInput | string
+  passwordHash?: Prisma.StringFieldUpdateOperationsInput | string
+  displayName?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  avatarUrl?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  skillTier?: Prisma.EnumSkillTierFieldUpdateOperationsInput | $Enums.SkillTier
+  elo?: Prisma.IntFieldUpdateOperationsInput | number
+  totalWins?: Prisma.IntFieldUpdateOperationsInput | number
+  totalMatches?: Prisma.IntFieldUpdateOperationsInput | number
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  submissions?: Prisma.SubmissionUpdateManyWithoutUserNestedInput
+  queueEntries?: Prisma.QueueEntryUpdateManyWithoutUserNestedInput
+}
+
+export type UserUncheckedUpdateWithoutMatchPlayersInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  username?: Prisma.StringFieldUpdateOperationsInput | string
+  email?: Prisma.StringFieldUpdateOperationsInput | string
+  passwordHash?: Prisma.StringFieldUpdateOperationsInput | string
+  displayName?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  avatarUrl?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  skillTier?: Prisma.EnumSkillTierFieldUpdateOperationsInput | $Enums.SkillTier
+  elo?: Prisma.IntFieldUpdateOperationsInput | number
+  totalWins?: Prisma.IntFieldUpdateOperationsInput | number
+  totalMatches?: Prisma.IntFieldUpdateOperationsInput | number
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  submissions?: Prisma.SubmissionUncheckedUpdateManyWithoutUserNestedInput
+  queueEntries?: Prisma.QueueEntryUncheckedUpdateManyWithoutUserNestedInput
+}
+
+export type UserCreateWithoutSubmissionsInput = {
+  id?: string
+  username: string
+  email: string
+  passwordHash: string
+  displayName?: string | null
+  avatarUrl?: string | null
+  skillTier?: $Enums.SkillTier
+  elo?: number
+  totalWins?: number
+  totalMatches?: number
+  createdAt?: Date | string
+  updatedAt?: Date | string
+  matchPlayers?: Prisma.MatchPlayerCreateNestedManyWithoutUserInput
+  queueEntries?: Prisma.QueueEntryCreateNestedManyWithoutUserInput
+}
+
+export type UserUncheckedCreateWithoutSubmissionsInput = {
+  id?: string
+  username: string
+  email: string
+  passwordHash: string
+  displayName?: string | null
+  avatarUrl?: string | null
+  skillTier?: $Enums.SkillTier
+  elo?: number
+  totalWins?: number
+  totalMatches?: number
+  createdAt?: Date | string
+  updatedAt?: Date | string
+  matchPlayers?: Prisma.MatchPlayerUncheckedCreateNestedManyWithoutUserInput
+  queueEntries?: Prisma.QueueEntryUncheckedCreateNestedManyWithoutUserInput
+}
+
+export type UserCreateOrConnectWithoutSubmissionsInput = {
+  where: Prisma.UserWhereUniqueInput
+  create: Prisma.XOR<Prisma.UserCreateWithoutSubmissionsInput, Prisma.UserUncheckedCreateWithoutSubmissionsInput>
+}
+
+export type UserUpsertWithoutSubmissionsInput = {
+  update: Prisma.XOR<Prisma.UserUpdateWithoutSubmissionsInput, Prisma.UserUncheckedUpdateWithoutSubmissionsInput>
+  create: Prisma.XOR<Prisma.UserCreateWithoutSubmissionsInput, Prisma.UserUncheckedCreateWithoutSubmissionsInput>
+  where?: Prisma.UserWhereInput
+}
+
+export type UserUpdateToOneWithWhereWithoutSubmissionsInput = {
+  where?: Prisma.UserWhereInput
+  data: Prisma.XOR<Prisma.UserUpdateWithoutSubmissionsInput, Prisma.UserUncheckedUpdateWithoutSubmissionsInput>
+}
+
+export type UserUpdateWithoutSubmissionsInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  username?: Prisma.StringFieldUpdateOperationsInput | string
+  email?: Prisma.StringFieldUpdateOperationsInput | string
+  passwordHash?: Prisma.StringFieldUpdateOperationsInput | string
+  displayName?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  avatarUrl?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  skillTier?: Prisma.EnumSkillTierFieldUpdateOperationsInput | $Enums.SkillTier
+  elo?: Prisma.IntFieldUpdateOperationsInput | number
+  totalWins?: Prisma.IntFieldUpdateOperationsInput | number
+  totalMatches?: Prisma.IntFieldUpdateOperationsInput | number
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  matchPlayers?: Prisma.MatchPlayerUpdateManyWithoutUserNestedInput
+  queueEntries?: Prisma.QueueEntryUpdateManyWithoutUserNestedInput
+}
+
+export type UserUncheckedUpdateWithoutSubmissionsInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  username?: Prisma.StringFieldUpdateOperationsInput | string
+  email?: Prisma.StringFieldUpdateOperationsInput | string
+  passwordHash?: Prisma.StringFieldUpdateOperationsInput | string
+  displayName?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  avatarUrl?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  skillTier?: Prisma.EnumSkillTierFieldUpdateOperationsInput | $Enums.SkillTier
+  elo?: Prisma.IntFieldUpdateOperationsInput | number
+  totalWins?: Prisma.IntFieldUpdateOperationsInput | number
+  totalMatches?: Prisma.IntFieldUpdateOperationsInput | number
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  matchPlayers?: Prisma.MatchPlayerUncheckedUpdateManyWithoutUserNestedInput
+  queueEntries?: Prisma.QueueEntryUncheckedUpdateManyWithoutUserNestedInput
+}
+
+
+/**
+ * Count Type UserCountOutputType
+ */
+
+export type UserCountOutputType = {
+  submissions: number
+  matchPlayers: number
+  queueEntries: number
+}
+
+export type UserCountOutputTypeSelect<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  submissions?: boolean | UserCountOutputTypeCountSubmissionsArgs
+  matchPlayers?: boolean | UserCountOutputTypeCountMatchPlayersArgs
+  queueEntries?: boolean | UserCountOutputTypeCountQueueEntriesArgs
+}
+
+/**
+ * UserCountOutputType without action
+ */
+export type UserCountOutputTypeDefaultArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the UserCountOutputType
+   */
+  select?: Prisma.UserCountOutputTypeSelect<ExtArgs> | null
+}
+
+/**
+ * UserCountOutputType without action
+ */
+export type UserCountOutputTypeCountSubmissionsArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  where?: Prisma.SubmissionWhereInput
+}
+
+/**
+ * UserCountOutputType without action
+ */
+export type UserCountOutputTypeCountMatchPlayersArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  where?: Prisma.MatchPlayerWhereInput
+}
+
+/**
+ * UserCountOutputType without action
+ */
+export type UserCountOutputTypeCountQueueEntriesArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  where?: Prisma.QueueEntryWhereInput
+}
+
+
+export type UserSelect<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
+  id?: boolean
+  username?: boolean
+  email?: boolean
+  passwordHash?: boolean
+  displayName?: boolean
+  avatarUrl?: boolean
+  skillTier?: boolean
+  elo?: boolean
+  totalWins?: boolean
+  totalMatches?: boolean
+  createdAt?: boolean
+  updatedAt?: boolean
+  submissions?: boolean | Prisma.User$submissionsArgs<ExtArgs>
+  matchPlayers?: boolean | Prisma.User$matchPlayersArgs<ExtArgs>
+  queueEntries?: boolean | Prisma.User$queueEntriesArgs<ExtArgs>
+  _count?: boolean | Prisma.UserCountOutputTypeDefaultArgs<ExtArgs>
+}, ExtArgs["result"]["user"]>
+
+export type UserSelectCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
+  id?: boolean
+  username?: boolean
+  email?: boolean
+  passwordHash?: boolean
+  displayName?: boolean
+  avatarUrl?: boolean
+  skillTier?: boolean
+  elo?: boolean
+  totalWins?: boolean
+  totalMatches?: boolean
+  createdAt?: boolean
+  updatedAt?: boolean
+}, ExtArgs["result"]["user"]>
+
+export type UserSelectUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
+  id?: boolean
+  username?: boolean
+  email?: boolean
+  passwordHash?: boolean
+  displayName?: boolean
+  avatarUrl?: boolean
+  skillTier?: boolean
+  elo?: boolean
+  totalWins?: boolean
+  totalMatches?: boolean
+  createdAt?: boolean
+  updatedAt?: boolean
+}, ExtArgs["result"]["user"]>
+
+export type UserSelectScalar = {
+  id?: boolean
+  username?: boolean
+  email?: boolean
+  passwordHash?: boolean
+  displayName?: boolean
+  avatarUrl?: boolean
+  skillTier?: boolean
+  elo?: boolean
+  totalWins?: boolean
+  totalMatches?: boolean
+  createdAt?: boolean
+  updatedAt?: boolean
+}
+
+export type UserOmit<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetOmit<"id" | "username" | "email" | "passwordHash" | "displayName" | "avatarUrl" | "skillTier" | "elo" | "totalWins" | "totalMatches" | "createdAt" | "updatedAt", ExtArgs["result"]["user"]>
+export type UserInclude<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  submissions?: boolean | Prisma.User$submissionsArgs<ExtArgs>
+  matchPlayers?: boolean | Prisma.User$matchPlayersArgs<ExtArgs>
+  queueEntries?: boolean | Prisma.User$queueEntriesArgs<ExtArgs>
+  _count?: boolean | Prisma.UserCountOutputTypeDefaultArgs<ExtArgs>
+}
+export type UserIncludeCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {}
+export type UserIncludeUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {}
+
+export type $UserPayload<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  name: "User"
+  objects: {
+    submissions: Prisma.$SubmissionPayload<ExtArgs>[]
+    matchPlayers: Prisma.$MatchPlayerPayload<ExtArgs>[]
+    queueEntries: Prisma.$QueueEntryPayload<ExtArgs>[]
+  }
+  scalars: runtime.Types.Extensions.GetPayloadResult<{
+    id: string
+    username: string
+    email: string
+    passwordHash: string
+    displayName: string | null
+    avatarUrl: string | null
+    skillTier: $Enums.SkillTier
+    elo: number
+    totalWins: number
+    totalMatches: number
+    createdAt: Date
+    updatedAt: Date
+  }, ExtArgs["result"]["user"]>
+  composites: {}
+}
+
+export type UserGetPayload<S extends boolean | null | undefined | UserDefaultArgs> = runtime.Types.Result.GetResult<Prisma.$UserPayload, S>
+
+export type UserCountArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> =
+  Omit<UserFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
+    select?: UserCountAggregateInputType | true
+  }
+
+export interface UserDelegate<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> {
+  [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['User'], meta: { name: 'User' } }
+  /**
+   * Find zero or one User that matches the filter.
+   * @param {UserFindUniqueArgs} args - Arguments to find a User
+   * @example
+   * // Get one User
+   * const user = await prisma.user.findUnique({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   */
+  findUnique<T extends UserFindUniqueArgs>(args: Prisma.SelectSubset<T, UserFindUniqueArgs<ExtArgs>>): Prisma.Prisma__UserClient<runtime.Types.Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Find one User that matches the filter or throw an error with `error.code='P2025'`
+   * if no matches were found.
+   * @param {UserFindUniqueOrThrowArgs} args - Arguments to find a User
+   * @example
+   * // Get one User
+   * const user = await prisma.user.findUniqueOrThrow({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   */
+  findUniqueOrThrow<T extends UserFindUniqueOrThrowArgs>(args: Prisma.SelectSubset<T, UserFindUniqueOrThrowArgs<ExtArgs>>): Prisma.Prisma__UserClient<runtime.Types.Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Find the first User that matches the filter.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {UserFindFirstArgs} args - Arguments to find a User
+   * @example
+   * // Get one User
+   * const user = await prisma.user.findFirst({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   */
+  findFirst<T extends UserFindFirstArgs>(args?: Prisma.SelectSubset<T, UserFindFirstArgs<ExtArgs>>): Prisma.Prisma__UserClient<runtime.Types.Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Find the first User that matches the filter or
+   * throw `PrismaKnownClientError` with `P2025` code if no matches were found.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {UserFindFirstOrThrowArgs} args - Arguments to find a User
+   * @example
+   * // Get one User
+   * const user = await prisma.user.findFirstOrThrow({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   */
+  findFirstOrThrow<T extends UserFindFirstOrThrowArgs>(args?: Prisma.SelectSubset<T, UserFindFirstOrThrowArgs<ExtArgs>>): Prisma.Prisma__UserClient<runtime.Types.Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Find zero or more Users that matches the filter.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {UserFindManyArgs} args - Arguments to filter and select certain fields only.
+   * @example
+   * // Get all Users
+   * const users = await prisma.user.findMany()
+   * 
+   * // Get first 10 Users
+   * const users = await prisma.user.findMany({ take: 10 })
+   * 
+   * // Only select the `id`
+   * const userWithIdOnly = await prisma.user.findMany({ select: { id: true } })
+   * 
+   */
+  findMany<T extends UserFindManyArgs>(args?: Prisma.SelectSubset<T, UserFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>
+
+  /**
+   * Create a User.
+   * @param {UserCreateArgs} args - Arguments to create a User.
+   * @example
+   * // Create one User
+   * const User = await prisma.user.create({
+   *   data: {
+   *     // ... data to create a User
+   *   }
+   * })
+   * 
+   */
+  create<T extends UserCreateArgs>(args: Prisma.SelectSubset<T, UserCreateArgs<ExtArgs>>): Prisma.Prisma__UserClient<runtime.Types.Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Create many Users.
+   * @param {UserCreateManyArgs} args - Arguments to create many Users.
+   * @example
+   * // Create many Users
+   * const user = await prisma.user.createMany({
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   *     
+   */
+  createMany<T extends UserCreateManyArgs>(args?: Prisma.SelectSubset<T, UserCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>
+
+  /**
+   * Create many Users and returns the data saved in the database.
+   * @param {UserCreateManyAndReturnArgs} args - Arguments to create many Users.
+   * @example
+   * // Create many Users
+   * const user = await prisma.user.createManyAndReturn({
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   * 
+   * // Create many Users and only return the `id`
+   * const userWithIdOnly = await prisma.user.createManyAndReturn({
+   *   select: { id: true },
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * 
+   */
+  createManyAndReturn<T extends UserCreateManyAndReturnArgs>(args?: Prisma.SelectSubset<T, UserCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>
+
+  /**
+   * Delete a User.
+   * @param {UserDeleteArgs} args - Arguments to delete one User.
+   * @example
+   * // Delete one User
+   * const User = await prisma.user.delete({
+   *   where: {
+   *     // ... filter to delete one User
+   *   }
+   * })
+   * 
+   */
+  delete<T extends UserDeleteArgs>(args: Prisma.SelectSubset<T, UserDeleteArgs<ExtArgs>>): Prisma.Prisma__UserClient<runtime.Types.Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Update one User.
+   * @param {UserUpdateArgs} args - Arguments to update one User.
+   * @example
+   * // Update one User
+   * const user = await prisma.user.update({
+   *   where: {
+   *     // ... provide filter here
+   *   },
+   *   data: {
+   *     // ... provide data here
+   *   }
+   * })
+   * 
+   */
+  update<T extends UserUpdateArgs>(args: Prisma.SelectSubset<T, UserUpdateArgs<ExtArgs>>): Prisma.Prisma__UserClient<runtime.Types.Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Delete zero or more Users.
+   * @param {UserDeleteManyArgs} args - Arguments to filter Users to delete.
+   * @example
+   * // Delete a few Users
+   * const { count } = await prisma.user.deleteMany({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   * 
+   */
+  deleteMany<T extends UserDeleteManyArgs>(args?: Prisma.SelectSubset<T, UserDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>
+
+  /**
+   * Update zero or more Users.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {UserUpdateManyArgs} args - Arguments to update one or more rows.
+   * @example
+   * // Update many Users
+   * const user = await prisma.user.updateMany({
+   *   where: {
+   *     // ... provide filter here
+   *   },
+   *   data: {
+   *     // ... provide data here
+   *   }
+   * })
+   * 
+   */
+  updateMany<T extends UserUpdateManyArgs>(args: Prisma.SelectSubset<T, UserUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>
+
+  /**
+   * Update zero or more Users and returns the data updated in the database.
+   * @param {UserUpdateManyAndReturnArgs} args - Arguments to update many Users.
+   * @example
+   * // Update many Users
+   * const user = await prisma.user.updateManyAndReturn({
+   *   where: {
+   *     // ... provide filter here
+   *   },
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   * 
+   * // Update zero or more Users and only return the `id`
+   * const userWithIdOnly = await prisma.user.updateManyAndReturn({
+   *   select: { id: true },
+   *   where: {
+   *     // ... provide filter here
+   *   },
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * 
+   */
+  updateManyAndReturn<T extends UserUpdateManyAndReturnArgs>(args: Prisma.SelectSubset<T, UserUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>
+
+  /**
+   * Create or update one User.
+   * @param {UserUpsertArgs} args - Arguments to update or create a User.
+   * @example
+   * // Update or create a User
+   * const user = await prisma.user.upsert({
+   *   create: {
+   *     // ... data to create a User
+   *   },
+   *   update: {
+   *     // ... in case it already exists, update
+   *   },
+   *   where: {
+   *     // ... the filter for the User we want to update
+   *   }
+   * })
+   */
+  upsert<T extends UserUpsertArgs>(args: Prisma.SelectSubset<T, UserUpsertArgs<ExtArgs>>): Prisma.Prisma__UserClient<runtime.Types.Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+
+  /**
+   * Count the number of Users.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {UserCountArgs} args - Arguments to filter Users to count.
+   * @example
+   * // Count the number of Users
+   * const count = await prisma.user.count({
+   *   where: {
+   *     // ... the filter for the Users we want to count
+   *   }
+   * })
+  **/
+  count<T extends UserCountArgs>(
+    args?: Prisma.Subset<T, UserCountArgs>,
+  ): Prisma.PrismaPromise<
+    T extends runtime.Types.Utils.Record<'select', any>
+      ? T['select'] extends true
+        ? number
+        : Prisma.GetScalarType<T['select'], UserCountAggregateOutputType>
+      : number
+  >
+
+  /**
+   * Allows you to perform aggregations operations on a User.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {UserAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
+   * @example
+   * // Ordered by age ascending
+   * // Where email contains prisma.io
+   * // Limited to the 10 users
+   * const aggregations = await prisma.user.aggregate({
+   *   _avg: {
+   *     age: true,
+   *   },
+   *   where: {
+   *     email: {
+   *       contains: "prisma.io",
+   *     },
+   *   },
+   *   orderBy: {
+   *     age: "asc",
+   *   },
+   *   take: 10,
+   * })
+  **/
+  aggregate<T extends UserAggregateArgs>(args: Prisma.Subset<T, UserAggregateArgs>): Prisma.PrismaPromise<GetUserAggregateType<T>>
+
+  /**
+   * Group by User.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {UserGroupByArgs} args - Group by arguments.
+   * @example
+   * // Group by city, order by createdAt, get count
+   * const result = await prisma.user.groupBy({
+   *   by: ['city', 'createdAt'],
+   *   orderBy: {
+   *     createdAt: true
+   *   },
+   *   _count: {
+   *     _all: true
+   *   },
+   * })
+   * 
+  **/
+  groupBy<
+    T extends UserGroupByArgs,
+    HasSelectOrTake extends Prisma.Or<
+      Prisma.Extends<'skip', Prisma.Keys<T>>,
+      Prisma.Extends<'take', Prisma.Keys<T>>
+    >,
+    OrderByArg extends Prisma.True extends HasSelectOrTake
+      ? { orderBy: UserGroupByArgs['orderBy'] }
+      : { orderBy?: UserGroupByArgs['orderBy'] },
+    OrderFields extends Prisma.ExcludeUnderscoreKeys<Prisma.Keys<Prisma.MaybeTupleToUnion<T['orderBy']>>>,
+    ByFields extends Prisma.MaybeTupleToUnion<T['by']>,
+    ByValid extends Prisma.Has<ByFields, OrderFields>,
+    HavingFields extends Prisma.GetHavingFields<T['having']>,
+    HavingValid extends Prisma.Has<ByFields, HavingFields>,
+    ByEmpty extends T['by'] extends never[] ? Prisma.True : Prisma.False,
+    InputErrors extends ByEmpty extends Prisma.True
+    ? `Error: "by" must not be empty.`
+    : HavingValid extends Prisma.False
+    ? {
+        [P in HavingFields]: P extends ByFields
+          ? never
+          : P extends string
+          ? `Error: Field "${P}" used in "having" needs to be provided in "by".`
+          : [
+              Error,
+              'Field ',
+              P,
+              ` in "having" needs to be provided in "by"`,
+            ]
+      }[HavingFields]
+    : 'take' extends Prisma.Keys<T>
+    ? 'orderBy' extends Prisma.Keys<T>
+      ? ByValid extends Prisma.True
+        ? {}
+        : {
+            [P in OrderFields]: P extends ByFields
+              ? never
+              : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
+          }[OrderFields]
+      : 'Error: If you provide "take", you also need to provide "orderBy"'
+    : 'skip' extends Prisma.Keys<T>
+    ? 'orderBy' extends Prisma.Keys<T>
+      ? ByValid extends Prisma.True
+        ? {}
+        : {
+            [P in OrderFields]: P extends ByFields
+              ? never
+              : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
+          }[OrderFields]
+      : 'Error: If you provide "skip", you also need to provide "orderBy"'
+    : ByValid extends Prisma.True
+    ? {}
+    : {
+        [P in OrderFields]: P extends ByFields
+          ? never
+          : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
+      }[OrderFields]
+  >(args: Prisma.SubsetIntersection<T, UserGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetUserGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
+/**
+ * Fields of the User model
+ */
+readonly fields: UserFieldRefs;
+}
+
+/**
+ * The delegate class that acts as a "Promise-like" for User.
+ * Why is this prefixed with `Prisma__`?
+ * Because we want to prevent naming conflicts as mentioned in
+ * https://github.com/prisma/prisma-client-js/issues/707
+ */
+export interface Prisma__UserClient<T, Null = never, ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
+  readonly [Symbol.toStringTag]: "PrismaPromise"
+  submissions<T extends Prisma.User$submissionsArgs<ExtArgs> = {}>(args?: Prisma.Subset<T, Prisma.User$submissionsArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$SubmissionPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
+  matchPlayers<T extends Prisma.User$matchPlayersArgs<ExtArgs> = {}>(args?: Prisma.Subset<T, Prisma.User$matchPlayersArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$MatchPlayerPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
+  queueEntries<T extends Prisma.User$queueEntriesArgs<ExtArgs> = {}>(args?: Prisma.Subset<T, Prisma.User$queueEntriesArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$QueueEntryPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
+  /**
+   * Attaches callbacks for the resolution and/or rejection of the Promise.
+   * @param onfulfilled The callback to execute when the Promise is resolved.
+   * @param onrejected The callback to execute when the Promise is rejected.
+   * @returns A Promise for the completion of which ever callback is executed.
+   */
+  then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): runtime.Types.Utils.JsPromise<TResult1 | TResult2>
+  /**
+   * Attaches a callback for only the rejection of the Promise.
+   * @param onrejected The callback to execute when the Promise is rejected.
+   * @returns A Promise for the completion of the callback.
+   */
+  catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): runtime.Types.Utils.JsPromise<T | TResult>
+  /**
+   * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
+   * resolved value cannot be modified from the callback.
+   * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
+   * @returns A Promise for the completion of the callback.
+   */
+  finally(onfinally?: (() => void) | undefined | null): runtime.Types.Utils.JsPromise<T>
+}
+
+
+
+
+/**
+ * Fields of the User model
+ */
+export interface UserFieldRefs {
+  readonly id: Prisma.FieldRef<"User", 'String'>
+  readonly username: Prisma.FieldRef<"User", 'String'>
+  readonly email: Prisma.FieldRef<"User", 'String'>
+  readonly passwordHash: Prisma.FieldRef<"User", 'String'>
+  readonly displayName: Prisma.FieldRef<"User", 'String'>
+  readonly avatarUrl: Prisma.FieldRef<"User", 'String'>
+  readonly skillTier: Prisma.FieldRef<"User", 'SkillTier'>
+  readonly elo: Prisma.FieldRef<"User", 'Int'>
+  readonly totalWins: Prisma.FieldRef<"User", 'Int'>
+  readonly totalMatches: Prisma.FieldRef<"User", 'Int'>
+  readonly createdAt: Prisma.FieldRef<"User", 'DateTime'>
+  readonly updatedAt: Prisma.FieldRef<"User", 'DateTime'>
+}
+    
+
+// Custom InputTypes
+/**
+ * User findUnique
+ */
+export type UserFindUniqueArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the User
+   */
+  select?: Prisma.UserSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the User
+   */
+  omit?: Prisma.UserOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.UserInclude<ExtArgs> | null
+  /**
+   * Filter, which User to fetch.
+   */
+  where: Prisma.UserWhereUniqueInput
+}
+
+/**
+ * User findUniqueOrThrow
+ */
+export type UserFindUniqueOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the User
+   */
+  select?: Prisma.UserSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the User
+   */
+  omit?: Prisma.UserOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.UserInclude<ExtArgs> | null
+  /**
+   * Filter, which User to fetch.
+   */
+  where: Prisma.UserWhereUniqueInput
+}
+
+/**
+ * User findFirst
+ */
+export type UserFindFirstArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the User
+   */
+  select?: Prisma.UserSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the User
+   */
+  omit?: Prisma.UserOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.UserInclude<ExtArgs> | null
+  /**
+   * Filter, which User to fetch.
+   */
+  where?: Prisma.UserWhereInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+   * 
+   * Determine the order of Users to fetch.
+   */
+  orderBy?: Prisma.UserOrderByWithRelationInput | Prisma.UserOrderByWithRelationInput[]
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+   * 
+   * Sets the position for searching for Users.
+   */
+  cursor?: Prisma.UserWhereUniqueInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Take `±n` Users from the position of the cursor.
+   */
+  take?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Skip the first `n` Users.
+   */
+  skip?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+   * 
+   * Filter by unique combinations of Users.
+   */
+  distinct?: Prisma.UserScalarFieldEnum | Prisma.UserScalarFieldEnum[]
+}
+
+/**
+ * User findFirstOrThrow
+ */
+export type UserFindFirstOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the User
+   */
+  select?: Prisma.UserSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the User
+   */
+  omit?: Prisma.UserOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.UserInclude<ExtArgs> | null
+  /**
+   * Filter, which User to fetch.
+   */
+  where?: Prisma.UserWhereInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+   * 
+   * Determine the order of Users to fetch.
+   */
+  orderBy?: Prisma.UserOrderByWithRelationInput | Prisma.UserOrderByWithRelationInput[]
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+   * 
+   * Sets the position for searching for Users.
+   */
+  cursor?: Prisma.UserWhereUniqueInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Take `±n` Users from the position of the cursor.
+   */
+  take?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Skip the first `n` Users.
+   */
+  skip?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+   * 
+   * Filter by unique combinations of Users.
+   */
+  distinct?: Prisma.UserScalarFieldEnum | Prisma.UserScalarFieldEnum[]
+}
+
+/**
+ * User findMany
+ */
+export type UserFindManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the User
+   */
+  select?: Prisma.UserSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the User
+   */
+  omit?: Prisma.UserOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.UserInclude<ExtArgs> | null
+  /**
+   * Filter, which Users to fetch.
+   */
+  where?: Prisma.UserWhereInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+   * 
+   * Determine the order of Users to fetch.
+   */
+  orderBy?: Prisma.UserOrderByWithRelationInput | Prisma.UserOrderByWithRelationInput[]
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+   * 
+   * Sets the position for listing Users.
+   */
+  cursor?: Prisma.UserWhereUniqueInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Take `±n` Users from the position of the cursor.
+   */
+  take?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Skip the first `n` Users.
+   */
+  skip?: number
+  distinct?: Prisma.UserScalarFieldEnum | Prisma.UserScalarFieldEnum[]
+}
+
+/**
+ * User create
+ */
+export type UserCreateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the User
+   */
+  select?: Prisma.UserSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the User
+   */
+  omit?: Prisma.UserOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.UserInclude<ExtArgs> | null
+  /**
+   * The data needed to create a User.
+   */
+  data: Prisma.XOR<Prisma.UserCreateInput, Prisma.UserUncheckedCreateInput>
+}
+
+/**
+ * User createMany
+ */
+export type UserCreateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * The data used to create many Users.
+   */
+  data: Prisma.UserCreateManyInput | Prisma.UserCreateManyInput[]
+  skipDuplicates?: boolean
+}
+
+/**
+ * User createManyAndReturn
+ */
+export type UserCreateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the User
+   */
+  select?: Prisma.UserSelectCreateManyAndReturn<ExtArgs> | null
+  /**
+   * Omit specific fields from the User
+   */
+  omit?: Prisma.UserOmit<ExtArgs> | null
+  /**
+   * The data used to create many Users.
+   */
+  data: Prisma.UserCreateManyInput | Prisma.UserCreateManyInput[]
+  skipDuplicates?: boolean
+}
+
+/**
+ * User update
+ */
+export type UserUpdateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the User
+   */
+  select?: Prisma.UserSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the User
+   */
+  omit?: Prisma.UserOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.UserInclude<ExtArgs> | null
+  /**
+   * The data needed to update a User.
+   */
+  data: Prisma.XOR<Prisma.UserUpdateInput, Prisma.UserUncheckedUpdateInput>
+  /**
+   * Choose, which User to update.
+   */
+  where: Prisma.UserWhereUniqueInput
+}
+
+/**
+ * User updateMany
+ */
+export type UserUpdateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * The data used to update Users.
+   */
+  data: Prisma.XOR<Prisma.UserUpdateManyMutationInput, Prisma.UserUncheckedUpdateManyInput>
+  /**
+   * Filter which Users to update
+   */
+  where?: Prisma.UserWhereInput
+  /**
+   * Limit how many Users to update.
+   */
+  limit?: number
+}
+
+/**
+ * User updateManyAndReturn
+ */
+export type UserUpdateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the User
+   */
+  select?: Prisma.UserSelectUpdateManyAndReturn<ExtArgs> | null
+  /**
+   * Omit specific fields from the User
+   */
+  omit?: Prisma.UserOmit<ExtArgs> | null
+  /**
+   * The data used to update Users.
+   */
+  data: Prisma.XOR<Prisma.UserUpdateManyMutationInput, Prisma.UserUncheckedUpdateManyInput>
+  /**
+   * Filter which Users to update
+   */
+  where?: Prisma.UserWhereInput
+  /**
+   * Limit how many Users to update.
+   */
+  limit?: number
+}
+
+/**
+ * User upsert
+ */
+export type UserUpsertArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the User
+   */
+  select?: Prisma.UserSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the User
+   */
+  omit?: Prisma.UserOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.UserInclude<ExtArgs> | null
+  /**
+   * The filter to search for the User to update in case it exists.
+   */
+  where: Prisma.UserWhereUniqueInput
+  /**
+   * In case the User found by the `where` argument doesn't exist, create a new User with this data.
+   */
+  create: Prisma.XOR<Prisma.UserCreateInput, Prisma.UserUncheckedCreateInput>
+  /**
+   * In case the User was found with the provided `where` argument, update it with this data.
+   */
+  update: Prisma.XOR<Prisma.UserUpdateInput, Prisma.UserUncheckedUpdateInput>
+}
+
+/**
+ * User delete
+ */
+export type UserDeleteArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the User
+   */
+  select?: Prisma.UserSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the User
+   */
+  omit?: Prisma.UserOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.UserInclude<ExtArgs> | null
+  /**
+   * Filter which User to delete.
+   */
+  where: Prisma.UserWhereUniqueInput
+}
+
+/**
+ * User deleteMany
+ */
+export type UserDeleteManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Filter which Users to delete
+   */
+  where?: Prisma.UserWhereInput
+  /**
+   * Limit how many Users to delete.
+   */
+  limit?: number
+}
+
+/**
+ * User.submissions
+ */
+export type User$submissionsArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Submission
+   */
+  select?: Prisma.SubmissionSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Submission
+   */
+  omit?: Prisma.SubmissionOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.SubmissionInclude<ExtArgs> | null
+  where?: Prisma.SubmissionWhereInput
+  orderBy?: Prisma.SubmissionOrderByWithRelationInput | Prisma.SubmissionOrderByWithRelationInput[]
+  cursor?: Prisma.SubmissionWhereUniqueInput
+  take?: number
+  skip?: number
+  distinct?: Prisma.SubmissionScalarFieldEnum | Prisma.SubmissionScalarFieldEnum[]
+}
+
+/**
+ * User.matchPlayers
+ */
+export type User$matchPlayersArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the MatchPlayer
+   */
+  select?: Prisma.MatchPlayerSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the MatchPlayer
+   */
+  omit?: Prisma.MatchPlayerOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.MatchPlayerInclude<ExtArgs> | null
+  where?: Prisma.MatchPlayerWhereInput
+  orderBy?: Prisma.MatchPlayerOrderByWithRelationInput | Prisma.MatchPlayerOrderByWithRelationInput[]
+  cursor?: Prisma.MatchPlayerWhereUniqueInput
+  take?: number
+  skip?: number
+  distinct?: Prisma.MatchPlayerScalarFieldEnum | Prisma.MatchPlayerScalarFieldEnum[]
+}
+
+/**
+ * User.queueEntries
+ */
+export type User$queueEntriesArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the QueueEntry
+   */
+  select?: Prisma.QueueEntrySelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the QueueEntry
+   */
+  omit?: Prisma.QueueEntryOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.QueueEntryInclude<ExtArgs> | null
+  where?: Prisma.QueueEntryWhereInput
+  orderBy?: Prisma.QueueEntryOrderByWithRelationInput | Prisma.QueueEntryOrderByWithRelationInput[]
+  cursor?: Prisma.QueueEntryWhereUniqueInput
+  take?: number
+  skip?: number
+  distinct?: Prisma.QueueEntryScalarFieldEnum | Prisma.QueueEntryScalarFieldEnum[]
+}
+
+/**
+ * User without action
+ */
+export type UserDefaultArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the User
+   */
+  select?: Prisma.UserSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the User
+   */
+  omit?: Prisma.UserOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.UserInclude<ExtArgs> | null
+}
diff --git a/prisma/schema.prisma b/prisma/schema.prisma
new file mode 100644
index 0000000..4f0df54
--- /dev/null
+++ b/prisma/schema.prisma
@@ -0,0 +1,195 @@
+// ============================================================
+// Compile-n-Conquer — Prisma Schema
+// ============================================================
+
+generator client {
+  provider = "prisma-client"
+  output   = "./generated/prisma"
+}
+
+datasource db {
+  provider = "postgresql"
+}
+
+// ---- Users ----
+
+model User {
+  id           String   @id @default(cuid())
+  username     String   @unique
+  email        String   @unique
+  passwordHash String
+  displayName  String?
+  avatarUrl    String?
+  skillTier    SkillTier @default(BEGINNER)
+  elo          Int       @default(1000)
+  totalWins    Int       @default(0)
+  totalMatches Int       @default(0)
+  createdAt    DateTime  @default(now())
+  updatedAt    DateTime  @updatedAt
+
+  // Relations
+  submissions   Submission[]
+  matchPlayers  MatchPlayer[]
+  queueEntries  QueueEntry[]
+
+  @@map("users")
+}
+
+enum SkillTier {
+  BEGINNER
+  INTERMEDIATE
+  ADVANCED
+  PRO
+}
+
+// ---- Matchmaking Queue ----
+
+model QueueEntry {
+  id        String   @id @default(cuid())
+  userId    String
+  joinedAt  DateTime @default(now())
+  active    Boolean  @default(true)
+
+  user User @relation(fields: [userId], references: [id], onDelete: Cascade)
+
+  @@unique([userId, active])
+  @@map("queue_entries")
+}
+
+// ---- Matches ----
+
+model Match {
+  id          String      @id @default(cuid())
+  status      MatchStatus @default(WAITING)
+  mode        GameMode    @default(FASTEST)
+  startedAt   DateTime?
+  endedAt     DateTime?
+  createdAt   DateTime    @default(now())
+
+  // Backboard thread IDs for evaluation
+  threadTimeComplexity  String?
+  threadSpaceComplexity String?
+  threadOriginality     String?
+  threadRanking         String?
+
+  // Relations
+  players     MatchPlayer[]
+  questions   MatchQuestion[]
+  submissions Submission[]
+
+  @@map("matches")
+}
+
+enum MatchStatus {
+  WAITING      // Waiting for all players to connect
+  IN_PROGRESS  // Match is live
+  EVALUATING   // Code submitted, LLM evaluation running
+  COMPLETED    // Results are in
+  CANCELLED
+}
+
+enum GameMode {
+  FASTEST        // First to pass all test cases
+  SHORTEST       // Shortest code (by chars) that passes
+  REVERSE        // Given output, write the code that produces it
+  DEBUGGING      // Fix broken code
+}
+
+model MatchPlayer {
+  id        String   @id @default(cuid())
+  matchId   String
+  userId    String
+  rank      Int?     // Final rank after evaluation
+  score     Float?   // Final weighted score
+  joinedAt  DateTime @default(now())
+
+  match Match @relation(fields: [matchId], references: [id], onDelete: Cascade)
+  user  User  @relation(fields: [userId], references: [id], onDelete: Cascade)
+
+  @@unique([matchId, userId])
+  @@map("match_players")
+}
+
+// ---- Questions ----
+
+model Question {
+  id          String     @id @default(cuid())
+  title       String
+  description String
+  difficulty  Difficulty @default(MEDIUM)
+  mode        GameMode   @default(FASTEST)
+
+  // For DEBUGGING mode: the broken code to fix
+  brokenCode     String?
+  brokenLanguage String?
+
+  // For REVERSE mode: expected output
+  expectedOutput String?
+
+  // Test cases stored as JSON
+  testCases  Json?    // [{ input: string, expectedOutput: string }]
+
+  createdAt  DateTime @default(now())
+  updatedAt  DateTime @updatedAt
+
+  // Relations
+  matchQuestions MatchQuestion[]
+  submissions    Submission[]
+
+  @@map("questions")
+}
+
+enum Difficulty {
+  EASY
+  MEDIUM
+  HARD
+}
+
+model MatchQuestion {
+  id         String @id @default(cuid())
+  matchId    String
+  questionId String
+  order      Int    @default(0) // Question order in the match
+
+  match    Match    @relation(fields: [matchId], references: [id], onDelete: Cascade)
+  question Question @relation(fields: [questionId], references: [id], onDelete: Cascade)
+
+  @@unique([matchId, questionId])
+  @@map("match_questions")
+}
+
+// ---- Submissions ----
+
+model Submission {
+  id         String   @id @default(cuid())
+  matchId    String
+  userId     String
+  questionId String
+  code       String
+  language   String
+  charCount  Int?     // For SHORTEST mode
+
+  // Piston execution results
+  stdout       String?
+  stderr       String?
+  exitCode     Int?
+  execTimeMs   Int?
+  testsPassed  Int     @default(0)
+  testsTotal   Int     @default(0)
+
+  // LLM evaluation scores
+  timeComplexity  String?  // e.g. "O(n)"
+  timeScore       Float?
+  spaceComplexity String?
+  spaceScore      Float?
+  originalityScore Float?
+  relevanceScore   Float?
+
+  submittedAt DateTime @default(now())
+
+  match    Match    @relation(fields: [matchId], references: [id], onDelete: Cascade)
+  user     User     @relation(fields: [userId], references: [id], onDelete: Cascade)
+  question Question @relation(fields: [questionId], references: [id], onDelete: Cascade)
+
+  @@map("submissions")
+}
diff --git a/prisma/seed.ts b/prisma/seed.ts
new file mode 100644
index 0000000..43ccd52
--- /dev/null
+++ b/prisma/seed.ts
@@ -0,0 +1,207 @@
+// ============================================================
+// Prisma Seed Script — Populate questions for all game modes
+// ============================================================
+// Run: npx tsx prisma/seed.ts
+
+import { PrismaClient } from "@prisma/client";
+
+const prisma = new PrismaClient();
+
+async function main() {
+  console.log("🌱 Seeding questions...\n");
+
+  // ---- FASTEST MODE ----
+  await prisma.question.createMany({
+    data: [
+      {
+        title: "Two Sum",
+        description:
+          "Given an array of integers `nums` and an integer `target`, return the indices of the two numbers that add up to `target`. You may assume each input has exactly one solution.",
+        difficulty: "EASY",
+        mode: "FASTEST",
+        testCases: [
+          { input: "2 7 11 15\n9", expectedOutput: "0 1" },
+          { input: "3 2 4\n6", expectedOutput: "1 2" },
+          { input: "3 3\n6", expectedOutput: "0 1" },
+        ],
+      },
+      {
+        title: "Valid Parentheses",
+        description:
+          "Given a string `s` containing just the characters '(', ')', '{', '}', '[' and ']', determine if the input string is valid. Print 'true' or 'false'.",
+        difficulty: "EASY",
+        mode: "FASTEST",
+        testCases: [
+          { input: "()", expectedOutput: "true" },
+          { input: "()[]{}", expectedOutput: "true" },
+          { input: "(]", expectedOutput: "false" },
+          { input: "([)]", expectedOutput: "false" },
+        ],
+      },
+      {
+        title: "Longest Substring Without Repeating Characters",
+        description:
+          "Given a string `s`, find the length of the longest substring without repeating characters. Print the length.",
+        difficulty: "MEDIUM",
+        mode: "FASTEST",
+        testCases: [
+          { input: "abcabcbb", expectedOutput: "3" },
+          { input: "bbbbb", expectedOutput: "1" },
+          { input: "pwwkew", expectedOutput: "3" },
+        ],
+      },
+      {
+        title: "Merge Intervals",
+        description:
+          "Given an array of intervals where intervals[i] = [start_i, end_i], merge all overlapping intervals and print the merged intervals, one per line as 'start end'.",
+        difficulty: "MEDIUM",
+        mode: "FASTEST",
+        testCases: [
+          { input: "1 3\n2 6\n8 10\n15 18", expectedOutput: "1 6\n8 10\n15 18" },
+          { input: "1 4\n4 5", expectedOutput: "1 5" },
+        ],
+      },
+    ],
+    skipDuplicates: true,
+  });
+
+  // ---- SHORTEST MODE ----
+  await prisma.question.createMany({
+    data: [
+      {
+        title: "FizzBuzz",
+        description:
+          "Print numbers from 1 to N. For multiples of 3 print 'Fizz', for multiples of 5 print 'Buzz', for multiples of both print 'FizzBuzz'. Read N from stdin.",
+        difficulty: "EASY",
+        mode: "SHORTEST",
+        testCases: [
+          {
+            input: "15",
+            expectedOutput:
+              "1\n2\nFizz\n4\nBuzz\nFizz\n7\n8\nFizz\nBuzz\n11\nFizz\n13\n14\nFizzBuzz",
+          },
+        ],
+      },
+      {
+        title: "Reverse a String",
+        description: "Read a string from stdin and print it reversed.",
+        difficulty: "EASY",
+        mode: "SHORTEST",
+        testCases: [
+          { input: "hello", expectedOutput: "olleh" },
+          { input: "world", expectedOutput: "dlrow" },
+        ],
+      },
+      {
+        title: "Fibonacci Sequence",
+        description:
+          "Read N from stdin and print the first N Fibonacci numbers, space-separated. F(0)=0, F(1)=1.",
+        difficulty: "EASY",
+        mode: "SHORTEST",
+        testCases: [
+          { input: "5", expectedOutput: "0 1 1 2 3" },
+          { input: "8", expectedOutput: "0 1 1 2 3 5 8 13" },
+        ],
+      },
+    ],
+    skipDuplicates: true,
+  });
+
+  // ---- REVERSE MODE ----
+  await prisma.question.createMany({
+    data: [
+      {
+        title: "Mystery Pattern",
+        description:
+          "Write code that produces the following output exactly. Read N from stdin.",
+        difficulty: "MEDIUM",
+        mode: "REVERSE",
+        expectedOutput: "*\n**\n***\n****\n*****",
+        testCases: [
+          { input: "5", expectedOutput: "*\n**\n***\n****\n*****" },
+          { input: "3", expectedOutput: "*\n**\n***" },
+        ],
+      },
+      {
+        title: "Decode This Output",
+        description:
+          "Write code that reads a number N and produces this exact output pattern.",
+        difficulty: "HARD",
+        mode: "REVERSE",
+        expectedOutput: "1\n1 2\n1 2 3\n1 2 3 4",
+        testCases: [
+          { input: "4", expectedOutput: "1\n1 2\n1 2 3\n1 2 3 4" },
+          { input: "2", expectedOutput: "1\n1 2" },
+        ],
+      },
+    ],
+    skipDuplicates: true,
+  });
+
+  // ---- DEBUGGING MODE ----
+  await prisma.question.createMany({
+    data: [
+      {
+        title: "Fix the Sort",
+        description:
+          "The following code is supposed to sort an array in ascending order, but it has bugs. Fix it so it reads space-separated integers from stdin and prints them sorted.",
+        difficulty: "EASY",
+        mode: "DEBUGGING",
+        brokenCode: `def sort_array(arr):
+    for i in range(len(arr)):
+        for j in range(len(arr)):  # Bug: should be len(arr)-1-i
+            if arr[j] > arr[j+1]:  # Bug: index out of range
+                arr[j], arr[j+1] = arr[j], arr[j+1]  # Bug: not swapping
+    return arr
+
+nums = list(map(int, input().split()))
+print(' '.join(map(str, sort_array(nums))))`,
+        brokenLanguage: "python",
+        testCases: [
+          { input: "3 1 4 1 5 9", expectedOutput: "1 1 3 4 5 9" },
+          { input: "5 3 1", expectedOutput: "1 3 5" },
+        ],
+      },
+      {
+        title: "Fix the Binary Search",
+        description:
+          "This binary search has bugs. Fix it so it reads a sorted array and a target, and prints the index (or -1).",
+        difficulty: "MEDIUM",
+        mode: "DEBUGGING",
+        brokenCode: `function binarySearch(arr, target) {
+  let left = 0;
+  let right = arr.length; // Bug: should be arr.length - 1
+  while (left < right) { // Bug: should be left <= right
+    let mid = (left + right) / 2; // Bug: should use Math.floor
+    if (arr[mid] === target) return mid;
+    if (arr[mid] < target) left = mid; // Bug: should be mid + 1
+    else right = mid; // Bug: should be mid - 1
+  }
+  return -1;
+}
+const lines = require('fs').readFileSync('/dev/stdin','utf8').trim().split('\\n');
+const arr = lines[0].split(' ').map(Number);
+const target = Number(lines[1]);
+console.log(binarySearch(arr, target));`,
+        brokenLanguage: "javascript",
+        testCases: [
+          { input: "1 3 5 7 9\n5", expectedOutput: "2" },
+          { input: "1 3 5 7 9\n4", expectedOutput: "-1" },
+        ],
+      },
+    ],
+    skipDuplicates: true,
+  });
+
+  const count = await prisma.question.count();
+  console.log(`✅ Seeded ${count} questions across all game modes.`);
+}
+
+main()
+  .catch((e) => {
+    console.error("Seed error:", e);
+    process.exit(1);
+  })
+  .finally(async () => {
+    await prisma.$disconnect();
+  });

From c71715144fb75e97f6652533144b33be7e08caef Mon Sep 17 00:00:00 2001
From: "Sree Raj Muthaiya.A.L" <passiveuser369@gmail.com>
Date: Tue, 10 Feb 2026 04:12:59 +0530
Subject: [PATCH 5/9] nigga push 1.5

---
 app/api/auth/me/route.ts                      |   82 +
 app/api/auth/signin/route.ts                  |    3 +
 app/api/auth/signup/route.ts                  |   11 +-
 app/api/match/available/route.ts              |   25 +
 app/api/match/create/route.ts                 |   93 ++
 app/api/match/join/route.ts                   |  149 ++
 app/api/piston/[...path]/route.ts             |   45 +
 app/api/users/[userId]/route.ts               |  106 ++
 app/arena/lobby/page.tsx                      |  394 +++++
 app/arena/page.tsx                            |  221 ++-
 app/auth/page.tsx                             |  280 ++--
 app/profile/page.tsx                          |  187 ++-
 components/arena/code-editor.tsx              |  387 ++++-
 components/arena/points-panel.tsx             |   35 +-
 components/arena/progress-bar.tsx             |   28 +-
 components/arena/users-panel.tsx              |   42 +-
 components/landing/footer.tsx                 |    2 +-
 components/landing/navbar.tsx                 |    4 +-
 lib/db.ts                                     |   32 +-
 lib/lobby.ts                                  |   34 +
 lib/socket.ts                                 |   12 +
 package-lock.json                             | 1445 ++++++++++++++++-
 package.json                                  |    6 +
 pages/api/socket.ts                           |   43 +
 prisma/generated/prisma/commonInputTypes.ts   |   34 +
 prisma/generated/prisma/enums.ts              |    9 +
 prisma/generated/prisma/internal/class.ts     |    4 +-
 .../prisma/internal/prismaNamespace.ts        |   20 +
 .../prisma/internal/prismaNamespaceBrowser.ts |    6 +
 prisma/generated/prisma/models/Match.ts       |   86 +-
 prisma/generated/prisma/models/MatchPlayer.ts |   94 +-
 prisma/generated/prisma/models/User.ts        |  134 +-
 .../migration.sql                             |  159 ++
 .../migration.sql                             |    4 +
 prisma/migrations/migration_lock.toml         |    3 +
 prisma/schema.prisma                          |   12 +
 36 files changed, 3973 insertions(+), 258 deletions(-)
 create mode 100644 app/api/match/available/route.ts
 create mode 100644 app/api/match/create/route.ts
 create mode 100644 app/api/match/join/route.ts
 create mode 100644 app/api/piston/[...path]/route.ts
 create mode 100644 app/api/users/[userId]/route.ts
 create mode 100644 app/arena/lobby/page.tsx
 create mode 100644 lib/lobby.ts
 create mode 100644 lib/socket.ts
 create mode 100644 pages/api/socket.ts
 create mode 100644 prisma/migrations/20260209192655_intial_migration/migration.sql
 create mode 100644 prisma/migrations/20260209194024_sign_up_changes/migration.sql
 create mode 100644 prisma/migrations/migration_lock.toml

diff --git a/app/api/auth/me/route.ts b/app/api/auth/me/route.ts
index b877060..684c9d0 100644
--- a/app/api/auth/me/route.ts
+++ b/app/api/auth/me/route.ts
@@ -6,6 +6,8 @@
 import { NextRequest, NextResponse } from "next/server";
 import { prisma } from "@/lib/db";
 import { getUserFromRequest } from "@/lib/auth";
+import { getSocketServer } from "@/lib/socket";
+import { listAvailableMatches } from "@/lib/lobby";
 
 export async function GET(req: NextRequest) {
   const payload = getUserFromRequest(req);
@@ -22,10 +24,13 @@ export async function GET(req: NextRequest) {
         username: true,
         email: true,
         displayName: true,
+        title: true,
         skillTier: true,
         elo: true,
         totalWins: true,
         totalMatches: true,
+        totalXP: true,
+        streak: true,
         createdAt: true,
       },
     });
@@ -45,6 +50,83 @@ export async function GET(req: NextRequest) {
 }
 
 export async function POST(req: NextRequest) {
+  const payload = getUserFromRequest(req);
+
+  if (payload) {
+    try {
+      const userId = payload.userId;
+      const entries = await prisma.matchPlayer.findMany({
+        where: { userId },
+        select: { matchId: true },
+      });
+
+      const matchIds = Array.from(
+        new Set(entries.map((entry) => entry.matchId)),
+      );
+
+      if (matchIds.length > 0) {
+        await prisma.matchPlayer.deleteMany({ where: { userId } });
+
+        const updatedMatches: any[] = [];
+        const deletedMatchIds: string[] = [];
+
+        for (const matchId of matchIds) {
+          const match = await prisma.match.findUnique({
+            where: { id: matchId },
+            include: {
+              players: {
+                include: {
+                  user: {
+                    select: {
+                      id: true,
+                      username: true,
+                      displayName: true,
+                      elo: true,
+                    },
+                  },
+                },
+              },
+            },
+          });
+
+          if (!match) continue;
+
+          const playerCount = match.players.length;
+
+          if (playerCount === 0) {
+            if (match.status === "WAITING") {
+              await prisma.match.delete({ where: { id: matchId } });
+              deletedMatchIds.push(matchId);
+              continue;
+            }
+
+            await prisma.match.update({
+              where: { id: matchId },
+              data: { status: "CANCELLED", endedAt: new Date() },
+            });
+            continue;
+          }
+
+          updatedMatches.push(match);
+        }
+
+        const io = getSocketServer();
+        if (io) {
+          const matches = await listAvailableMatches();
+          io.emit("lobby:list", matches);
+          updatedMatches.forEach((match) => {
+            io.emit("lobby:update", match);
+          });
+          deletedMatchIds.forEach((matchId) => {
+            io.emit("lobby:deleted", { matchId });
+          });
+        }
+      }
+    } catch (error) {
+      console.error("Signout cleanup error:", error);
+    }
+  }
+
   // Sign out: clear the cookie
   const response = NextResponse.json({ success: true });
   response.cookies.set("token", "", {
diff --git a/app/api/auth/signin/route.ts b/app/api/auth/signin/route.ts
index 234c8e1..3eb68cb 100644
--- a/app/api/auth/signin/route.ts
+++ b/app/api/auth/signin/route.ts
@@ -55,10 +55,13 @@ export async function POST(req: NextRequest) {
         username: user.username,
         email: user.email,
         displayName: user.displayName,
+        title: user.title,
         skillTier: user.skillTier,
         elo: user.elo,
         totalWins: user.totalWins,
         totalMatches: user.totalMatches,
+        totalXP: user.totalXP,
+        streak: user.streak,
       },
       token,
     });
diff --git a/app/api/auth/signup/route.ts b/app/api/auth/signup/route.ts
index 2c7fb1a..d926422 100644
--- a/app/api/auth/signup/route.ts
+++ b/app/api/auth/signup/route.ts
@@ -65,10 +65,13 @@ export async function POST(req: NextRequest) {
           id: user.id,
           username: user.username,
           email: user.email,
-          displayName: user.displayName,
-          skillTier: user.skillTier,
-          elo: user.elo,
-        },
+        displayName: user.displayName,
+        title: user.title,
+        skillTier: user.skillTier,
+        elo: user.elo,
+        totalXP: user.totalXP,
+        streak: user.streak,
+      },
         token,
       },
       { status: 201 }
diff --git a/app/api/match/available/route.ts b/app/api/match/available/route.ts
new file mode 100644
index 0000000..887f396
--- /dev/null
+++ b/app/api/match/available/route.ts
@@ -0,0 +1,25 @@
+// ============================================================
+// GET /api/match/available — List waiting matches (lobbies)
+// ============================================================
+
+import { NextRequest, NextResponse } from "next/server"
+import { getUserFromRequest } from "@/lib/auth"
+import { listAvailableMatches } from "@/lib/lobby"
+
+export async function GET(req: NextRequest) {
+  const payload = getUserFromRequest(req)
+  if (!payload) {
+    return NextResponse.json({ error: "Not authenticated" }, { status: 401 })
+  }
+
+  try {
+    const matches = await listAvailableMatches()
+    return NextResponse.json({ matches })
+  } catch (error) {
+    console.error("Match list error:", error)
+    return NextResponse.json(
+      { error: "Internal server error" },
+      { status: 500 },
+    )
+  }
+}
diff --git a/app/api/match/create/route.ts b/app/api/match/create/route.ts
new file mode 100644
index 0000000..9bbf268
--- /dev/null
+++ b/app/api/match/create/route.ts
@@ -0,0 +1,93 @@
+// ============================================================
+// POST /api/match/create — Create a new match (lobby)
+// ============================================================
+
+import { NextRequest, NextResponse } from "next/server"
+import { prisma } from "@/lib/db"
+import { getUserFromRequest } from "@/lib/auth"
+import { listAvailableMatches } from "@/lib/lobby"
+import { getSocketServer } from "@/lib/socket"
+
+export async function POST(req: NextRequest) {
+  const payload = getUserFromRequest(req)
+  if (!payload) {
+    return NextResponse.json({ error: "Not authenticated" }, { status: 401 })
+  }
+
+  const body = await req.json().catch(() => ({}))
+  const mode = body?.mode || "FASTEST"
+
+  try {
+    const result = await prisma.$transaction(async (tx) => {
+      const match = await tx.match.create({
+        data: {
+          mode,
+          status: "WAITING",
+        },
+      })
+
+      await tx.matchPlayer.create({
+        data: {
+          matchId: match.id,
+          userId: payload.userId,
+        },
+      })
+
+      const questions = await tx.$queryRaw<{ id: string }[]>
+        `SELECT id FROM "questions" ORDER BY RANDOM() LIMIT 3`
+
+      if (questions.length < 3) {
+        throw new Error("Not enough questions to start a match")
+      }
+
+      await tx.matchQuestion.createMany({
+        data: questions.map((q, index) => ({
+          matchId: match.id,
+          questionId: q.id,
+          order: index,
+        })),
+      })
+
+      return match
+    })
+
+    const hydrated = await prisma.match.findUnique({
+      where: { id: result.id },
+      include: {
+        players: {
+          include: {
+            user: {
+              select: {
+                id: true,
+                username: true,
+                displayName: true,
+                elo: true,
+              },
+            },
+          },
+        },
+      },
+    })
+
+    const io = getSocketServer()
+    if (io) {
+      const matches = await listAvailableMatches()
+      io.emit("lobby:list", matches)
+      io.emit("lobby:update", hydrated)
+    }
+
+    const safeMatch = hydrated
+      ? { ...hydrated, maxPlayers: hydrated.maxPlayers ?? 3 }
+      : hydrated
+
+    return NextResponse.json({
+      match: safeMatch,
+    })
+  } catch (error: any) {
+    console.error("Match create error:", error)
+    const message =
+      error instanceof Error ? error.message : "Internal server error"
+    const status = message.includes("Not enough questions") ? 400 : 500
+    return NextResponse.json({ error: message }, { status })
+  }
+}
diff --git a/app/api/match/join/route.ts b/app/api/match/join/route.ts
new file mode 100644
index 0000000..11f7f00
--- /dev/null
+++ b/app/api/match/join/route.ts
@@ -0,0 +1,149 @@
+// ============================================================
+// POST /api/match/join — Join an existing match by code
+// ============================================================
+
+import { NextRequest, NextResponse } from "next/server"
+import { prisma } from "@/lib/db"
+import { getUserFromRequest } from "@/lib/auth"
+import { listAvailableMatches } from "@/lib/lobby"
+import { getSocketServer } from "@/lib/socket"
+
+export async function POST(req: NextRequest) {
+  const payload = getUserFromRequest(req)
+  if (!payload) {
+    return NextResponse.json({ error: "Not authenticated" }, { status: 401 })
+  }
+
+  const body = await req.json().catch(() => ({}))
+  const matchId = body?.matchId ? String(body.matchId) : null
+
+  if (!matchId) {
+    return NextResponse.json(
+      { error: "matchId is required" },
+      { status: 400 },
+    )
+  }
+
+  try {
+    const { hydrated, shouldStart } = await prisma.$transaction(async (tx) => {
+      const match = await tx.match.findUnique({
+        where: { id: matchId },
+        include: { players: true },
+      })
+
+      if (!match) {
+        throw new Error("MATCH_NOT_FOUND")
+      }
+
+      if (match.status !== "WAITING") {
+        throw new Error(`MATCH_STATUS:${match.status}`)
+      }
+
+      const alreadyInMatch = match.players.some(
+        (p) => p.userId === payload.userId,
+      )
+
+      const maxPlayers = match.maxPlayers ?? 3
+      if (!alreadyInMatch && match.players.length >= maxPlayers) {
+        throw new Error("MATCH_FULL")
+      }
+
+      if (!alreadyInMatch) {
+        await tx.matchPlayer.create({
+          data: {
+            matchId: match.id,
+            userId: payload.userId,
+          },
+        })
+      }
+
+      const totalPlayers = await tx.matchPlayer.count({
+        where: { matchId: match.id },
+      })
+      if (totalPlayers > maxPlayers) {
+        if (!alreadyInMatch) {
+          await tx.matchPlayer.deleteMany({
+            where: { matchId: match.id, userId: payload.userId },
+          })
+        }
+        throw new Error("MATCH_FULL")
+      }
+      const shouldStart = totalPlayers >= maxPlayers
+
+      if (shouldStart) {
+        await tx.match.update({
+          where: { id: match.id },
+          data: {
+            status: "IN_PROGRESS",
+            startedAt: new Date(),
+          },
+        })
+      }
+
+      const hydrated = await tx.match.findUnique({
+        where: { id: match.id },
+        include: {
+          players: {
+            include: {
+              user: {
+                select: {
+                  id: true,
+                  username: true,
+                  displayName: true,
+                  elo: true,
+                },
+              },
+            },
+          },
+        },
+      })
+
+      return { hydrated, shouldStart }
+    })
+
+    if (!hydrated) {
+      return NextResponse.json({ error: "Match not found" }, { status: 404 })
+    }
+
+    const safeMatch = {
+      ...hydrated,
+      maxPlayers: hydrated.maxPlayers ?? 3,
+    }
+
+    const io = getSocketServer()
+    if (io) {
+      const matches = await listAvailableMatches()
+      io.emit("lobby:list", matches)
+      io.emit("lobby:update", safeMatch)
+      if (shouldStart) {
+        io.emit("lobby:started", { matchId: safeMatch.id })
+      }
+    }
+
+    return NextResponse.json({
+      match: safeMatch,
+      started: shouldStart,
+    })
+  } catch (error) {
+    const message = error instanceof Error ? error.message : ""
+    if (message === "MATCH_NOT_FOUND") {
+      return NextResponse.json({ error: "Match not found" }, { status: 404 })
+    }
+    if (message === "MATCH_FULL") {
+      return NextResponse.json({ error: "Match is full" }, { status: 400 })
+    }
+    if (message.startsWith("MATCH_STATUS:")) {
+      const status = message.split(":")[1] || "IN_PROGRESS"
+      return NextResponse.json(
+        { error: `Match already ${status}` },
+        { status: 400 },
+      )
+    }
+
+    console.error("Match join error:", error)
+    return NextResponse.json(
+      { error: "Internal server error" },
+      { status: 500 },
+    )
+  }
+}
diff --git a/app/api/piston/[...path]/route.ts b/app/api/piston/[...path]/route.ts
new file mode 100644
index 0000000..5bc6554
--- /dev/null
+++ b/app/api/piston/[...path]/route.ts
@@ -0,0 +1,45 @@
+export const dynamic = "force-dynamic"
+
+const PISTON_BASE =
+  process.env.PISTON_BASE ??
+  "https://k4l8m636-2000.inc1.devtunnels.ms/api/v2"
+
+const allowedPaths = new Set(["runtimes", "execute"])
+
+const forward = async (
+  req: Request,
+  { params }: { params: { path?: string[] } },
+) => {
+  const path = params.path?.join("/") ?? ""
+  if (!allowedPaths.has(path)) {
+    return new Response("Not found", { status: 404 })
+  }
+
+  const url = `${PISTON_BASE}/${path}`
+  const headers = new Headers(req.headers)
+  headers.delete("host")
+  headers.delete("connection")
+  headers.delete("content-length")
+
+  const init: RequestInit = {
+    method: req.method,
+    headers,
+    cache: "no-store",
+  }
+
+  if (req.method !== "GET" && req.method !== "HEAD") {
+    init.body = await req.text()
+  }
+
+  const response = await fetch(url, init)
+  const responseHeaders = new Headers(response.headers)
+  responseHeaders.delete("content-encoding")
+
+  return new Response(response.body, {
+    status: response.status,
+    headers: responseHeaders,
+  })
+}
+
+export const GET = forward
+export const POST = forward
diff --git a/app/api/users/[userId]/route.ts b/app/api/users/[userId]/route.ts
new file mode 100644
index 0000000..aa46db5
--- /dev/null
+++ b/app/api/users/[userId]/route.ts
@@ -0,0 +1,106 @@
+// ============================================================
+// GET /api/users/:userId — Fetch user profile by id
+// ============================================================
+
+import { NextRequest, NextResponse } from "next/server"
+import { prisma } from "@/lib/db"
+
+export async function GET(
+  _req: NextRequest,
+  { params }: { params: { userId: string } },
+) {
+  const resolvedParams = await Promise.resolve(params)
+  const { userId } = resolvedParams
+
+  if (!userId) {
+    return NextResponse.json({ error: "userId is required" }, { status: 400 })
+  }
+
+  try {
+    const user = await prisma.user.findUnique({
+      where: { id: userId },
+      select: {
+        id: true,
+        username: true,
+        email: true,
+        displayName: true,
+        title: true,
+        skillTier: true,
+        elo: true,
+        totalWins: true,
+        totalMatches: true,
+        totalXP: true,
+        streak: true,
+        createdAt: true,
+      },
+    })
+
+    if (!user) {
+      return NextResponse.json({ error: "User not found" }, { status: 404 })
+    }
+
+    const recentPlayers = await prisma.matchPlayer.findMany({
+      where: { userId },
+      include: {
+        match: {
+          select: {
+            id: true,
+            mode: true,
+            endedAt: true,
+            createdAt: true,
+            players: {
+              include: {
+                user: {
+                  select: {
+                    id: true,
+                    username: true,
+                    displayName: true,
+                  },
+                },
+              },
+            },
+          },
+        },
+      },
+      orderBy: { joinedAt: "desc" },
+      take: 5,
+    })
+
+    const recentMatches = recentPlayers.map((player) => {
+      const opponent = player.match.players.find(
+        (p) => p.userId !== userId,
+      )
+      const opponentName =
+        opponent?.user.displayName || opponent?.user.username || "Unknown"
+
+      return {
+        matchId: player.match.id,
+        opponent: opponentName,
+        result: player.result ?? "PENDING",
+        mode: player.match.mode,
+        xpDelta: player.xpDelta,
+        endedAt: player.match.endedAt ?? player.match.createdAt,
+      }
+    })
+
+    const winRate =
+      user.totalMatches > 0
+        ? Math.round((user.totalWins / user.totalMatches) * 100)
+        : 0
+
+    return NextResponse.json({
+      user,
+      stats: {
+        battles: user.totalMatches,
+        winRate,
+        xp: user.totalXP,
+        streak: user.streak,
+        elo: user.elo,
+      },
+      recentMatches,
+    })
+  } catch (error) {
+    console.error("User fetch error:", error)
+    return NextResponse.json({ error: "Internal server error" }, { status: 500 })
+  }
+}
diff --git a/app/arena/lobby/page.tsx b/app/arena/lobby/page.tsx
new file mode 100644
index 0000000..0903c7d
--- /dev/null
+++ b/app/arena/lobby/page.tsx
@@ -0,0 +1,394 @@
+"use client"
+
+import { useEffect, useMemo, useRef, useState } from "react"
+import { useRouter } from "next/navigation"
+import Link from "next/link"
+import { Terminal, ArrowLeft, Users, PlusCircle } from "lucide-react"
+import { io, type Socket } from "socket.io-client"
+
+type LobbyPlayer = {
+  userId: string
+  user: {
+    id: string
+    username: string
+    displayName: string | null
+    elo: number
+  }
+}
+
+type LobbyMatch = {
+  id: string
+  status: string
+  maxPlayers: number
+  players: LobbyPlayer[]
+}
+
+const sampleLobbies: LobbyMatch[] = [
+  {
+    id: "sample-1",
+    status: "WAITING",
+    maxPlayers: 3,
+    players: [
+      {
+        userId: "u1",
+        user: { id: "u1", username: "n3x_byte", displayName: "n3x_byte", elo: 2103 },
+      },
+    ],
+  },
+  {
+    id: "sample-2",
+    status: "WAITING",
+    maxPlayers: 3,
+    players: [
+      {
+        userId: "u2",
+        user: { id: "u2", username: "c0d3_wr4ith", displayName: "c0d3_wr4ith", elo: 2241 },
+      },
+      {
+        userId: "u3",
+        user: { id: "u3", username: "z3r0_day", displayName: "z3r0_day", elo: 1956 },
+      },
+    ],
+  },
+  {
+    id: "sample-3",
+    status: "WAITING",
+    maxPlayers: 3,
+    players: [],
+  },
+]
+
+export default function LobbyPage() {
+  const router = useRouter()
+  const [available, setAvailable] = useState<LobbyMatch[]>([])
+  const [match, setMatch] = useState<LobbyMatch | null>(null)
+  const [error, setError] = useState<string | null>(null)
+  const [loading, setLoading] = useState(false)
+  const [isSocketConnected, setIsSocketConnected] = useState(false)
+  const socketRef = useRef<Socket | null>(null)
+
+  const playersCount = match?.players.length ?? 0
+  const lobbyReady = match?.status === "IN_PROGRESS"
+
+  useEffect(() => {
+    let active = true
+
+    const initSocket = async () => {
+      await fetch("/api/socket")
+      const socket = io({ path: "/api/socket" })
+      socketRef.current = socket
+
+      socket.on("connect", () => {
+        if (!active) return
+        setIsSocketConnected(true)
+      })
+
+      socket.on("disconnect", () => {
+        if (!active) return
+        setIsSocketConnected(false)
+      })
+
+      socket.on("lobby:list", (matches: LobbyMatch[]) => {
+        if (!active) return
+        setAvailable(matches)
+      })
+
+      socket.on("lobby:update", (updated: LobbyMatch) => {
+        if (!active || !updated) return
+        setMatch((prev) => (prev?.id === updated.id ? updated : prev))
+        setAvailable((prev) => {
+          const exists = prev.some((m) => m.id === updated.id)
+          if (updated.status !== "WAITING") {
+            return prev.filter((m) => m.id !== updated.id)
+          }
+          if (exists) {
+            return prev.map((m) => (m.id === updated.id ? updated : m))
+          }
+          return [updated, ...prev]
+        })
+      })
+
+      socket.on("lobby:started", (payload: { matchId: string }) => {
+        if (!active) return
+        setMatch((prev) => {
+          if (payload?.matchId && prev?.id === payload.matchId) {
+            router.push(`/arena?match=${payload.matchId}`)
+          }
+          return prev
+        })
+      })
+
+      socket.on("lobby:deleted", (payload: { matchId: string }) => {
+        if (!active || !payload?.matchId) return
+        setAvailable((prev) => prev.filter((lobby) => lobby.id !== payload.matchId))
+        setMatch((prev) => (prev?.id === payload.matchId ? null : prev))
+      })
+    }
+
+    initSocket()
+
+    return () => {
+      active = false
+      socketRef.current?.disconnect()
+      socketRef.current = null
+    }
+  }, [router])
+
+  const refreshAvailable = async () => {
+    try {
+      const res = await fetch("/api/match/available")
+      if (!res.ok) return
+      const payload = await res.json().catch(() => ({}))
+      if (payload?.matches) {
+        setAvailable(payload.matches as LobbyMatch[])
+      }
+    } catch {
+      // ignore
+    }
+  }
+
+  const refreshMatch = async (matchId: string) => {
+    try {
+      const res = await fetch(`/api/match/${matchId}`)
+      if (!res.ok) return
+      const payload = await res.json().catch(() => ({}))
+      if (payload?.match) {
+        setMatch(payload.match as LobbyMatch)
+      }
+    } catch {
+      // ignore
+    }
+  }
+
+  useEffect(() => {
+    refreshAvailable()
+  }, [])
+
+  useEffect(() => {
+    if (isSocketConnected) return
+    const interval = setInterval(() => {
+      refreshAvailable()
+      if (match?.id) {
+        refreshMatch(match.id)
+      }
+    }, 4000)
+    return () => clearInterval(interval)
+  }, [isSocketConnected, match?.id])
+
+  useEffect(() => {
+    if (lobbyReady && match?.id) {
+      router.push(`/arena?match=${match.id}`)
+    }
+  }, [lobbyReady, match?.id, router])
+
+  const handleCreate = async () => {
+    setError(null)
+    setLoading(true)
+    try {
+      const res = await fetch("/api/match/create", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({}),
+      })
+      const payload = await res.json().catch(() => ({}))
+      if (!res.ok) {
+        setError(payload?.error || "Failed to create contest.")
+        return
+      }
+      if (payload?.match) {
+        setMatch(payload.match as LobbyMatch)
+      }
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Failed to create contest.")
+    } finally {
+      setLoading(false)
+    }
+  }
+
+  const handleJoin = async (matchId: string) => {
+    setError(null)
+    setLoading(true)
+    try {
+      const res = await fetch("/api/match/join", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ matchId }),
+      })
+      const payload = await res.json().catch(() => ({}))
+      if (!res.ok) {
+        setError(payload?.error || "Failed to join contest.")
+        return
+      }
+      if (payload?.match) {
+        setMatch(payload.match as LobbyMatch)
+      }
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Failed to join contest.")
+    } finally {
+      setLoading(false)
+    }
+  }
+
+  const statusLabel = match?.status ?? "IDLE"
+
+  const playerRows = useMemo(() => {
+    if (!match?.players?.length) return []
+    return match.players.map((p) => ({
+      id: p.userId,
+      name: p.user.displayName || p.user.username,
+      elo: p.user.elo,
+    }))
+  }, [match?.players])
+
+  const listIsSample = available.length === 0
+  const displayLobbies = listIsSample ? sampleLobbies : available
+
+  return (
+    <main className="relative min-h-screen bg-background px-4 py-10">
+      <div className="mx-auto w-full max-w-3xl">
+        <Link
+          href="/"
+          className="mb-6 inline-flex items-center gap-2 text-xs uppercase tracking-widest text-muted-foreground transition-colors hover:text-primary"
+        >
+          <ArrowLeft className="h-3 w-3" />
+          Back to Home
+        </Link>
+
+        <div className="rounded-sm border border-border bg-card p-6">
+          <div className="mb-6 flex items-center gap-3">
+            <div className="flex h-10 w-10 items-center justify-center rounded-sm border border-border bg-secondary">
+              <Terminal className="h-5 w-5 text-primary" />
+            </div>
+            <div>
+              <h1 className="text-lg font-bold uppercase tracking-widest text-foreground">
+                Arena Lobby
+              </h1>
+              <p className="text-xs text-muted-foreground">
+                Create a contest or join an open lobby. Max 3 players.
+              </p>
+            </div>
+          </div>
+
+          {!match && (
+            <div className="flex flex-col gap-6">
+              <div className="rounded-sm border border-border bg-secondary/40 p-4">
+                <div className="mb-3 flex items-center gap-2 text-xs uppercase tracking-widest text-primary">
+                  <PlusCircle className="h-4 w-4" />
+                  Create Contest
+                </div>
+                <p className="mb-4 text-xs text-muted-foreground">
+                  Spin up a lobby and wait for up to 2 opponents.
+                </p>
+                <button
+                  onClick={handleCreate}
+                  disabled={loading}
+                  className="w-full rounded-sm border border-primary bg-primary px-4 py-2 text-xs font-bold uppercase tracking-widest text-primary-foreground transition hover:bg-primary/90 disabled:opacity-70"
+                >
+                  {loading ? "Creating..." : "Create Lobby"}
+                </button>
+              </div>
+
+              <div className="rounded-sm border border-border bg-secondary/40 p-4">
+                <div className="mb-3 flex items-center gap-2 text-xs uppercase tracking-widest text-primary">
+                  <Users className="h-4 w-4" />
+                  Available Contests
+                </div>
+                <p className="mb-4 text-xs text-muted-foreground">
+                  Pick a lobby to join. List updates every few seconds.
+                </p>
+                <div className="space-y-2">
+                  {listIsSample && (
+                    <p className="text-xs text-muted-foreground">
+                      No open contests yet. Sample lobbies shown below.
+                    </p>
+                  )}
+                  {displayLobbies.map((lobby) => {
+                    const maxPlayers = lobby.maxPlayers ?? 3
+                    const isFull = lobby.players.length >= maxPlayers
+                    return (
+                      <div
+                        key={lobby.id}
+                        className="flex w-full items-center justify-between rounded-sm border border-border bg-card px-3 py-2 text-xs font-semibold text-foreground"
+                      >
+                        <div className="flex items-center gap-3">
+                          <span className="tracking-widest text-muted-foreground">
+                            #{lobby.id.slice(0, 6).toUpperCase()}
+                          </span>
+                          <span className="text-xs text-muted-foreground">
+                            {lobby.players.length}/{maxPlayers} players
+                          </span>
+                        </div>
+                        <button
+                          onClick={() => handleJoin(lobby.id)}
+                          disabled={loading || listIsSample || isFull}
+                          className="rounded-sm border border-border bg-secondary px-3 py-1 text-[10px] font-bold uppercase tracking-widest text-foreground transition hover:border-primary hover:text-primary disabled:opacity-70"
+                        >
+                          {isFull ? "Full" : "Join"}
+                        </button>
+                      </div>
+                    )
+                  })}
+                </div>
+              </div>
+            </div>
+          )}
+
+          {match && (
+            <div className="rounded-sm border border-border bg-secondary/40 p-4">
+              <div className="mb-4 flex flex-wrap items-center justify-between gap-3">
+                <div>
+                  <p className="text-xs uppercase tracking-widest text-muted-foreground">
+                    Lobby
+                  </p>
+                  <p className="text-lg font-bold text-primary">
+                    #{match.id.slice(0, 6).toUpperCase()}
+                  </p>
+                </div>
+                <div className="text-right">
+                  <p className="text-xs uppercase tracking-widest text-muted-foreground">
+                    Status
+                  </p>
+                  <p className="text-sm font-semibold text-primary">
+                    {statusLabel}
+                  </p>
+                </div>
+              </div>
+
+              <div className="mb-4 flex items-center gap-2 text-xs text-muted-foreground">
+                <Users className="h-4 w-4 text-primary" />
+                Players {playersCount}/{match.maxPlayers}
+              </div>
+
+              <div className="space-y-2">
+                {playerRows.length === 0 && (
+                  <p className="text-xs text-muted-foreground">
+                    Waiting for players to join...
+                  </p>
+                )}
+                {playerRows.map((player) => (
+                  <div
+                    key={player.id}
+                    className="flex items-center justify-between rounded-sm border border-border bg-card px-3 py-2 text-xs"
+                  >
+                    <span className="font-semibold text-foreground">
+                      {player.name}
+                    </span>
+                    <span className="text-muted-foreground">
+                      {player.elo} ELO
+                    </span>
+                  </div>
+                ))}
+              </div>
+            </div>
+          )}
+
+          {error && (
+            <p className="mt-4 rounded-sm border border-destructive/30 bg-destructive/10 px-3 py-2 text-xs text-destructive">
+              {error}
+            </p>
+          )}
+        </div>
+      </div>
+    </main>
+  )
+}
diff --git a/app/arena/page.tsx b/app/arena/page.tsx
index ca6d747..0d4d106 100644
--- a/app/arena/page.tsx
+++ b/app/arena/page.tsx
@@ -1,13 +1,204 @@
 "use client"
 
-import { ProgressBar } from "@/components/arena/progress-bar"
+import { useEffect, useMemo, useState } from "react"
+import { useSearchParams } from "next/navigation"
 import { CodeEditor } from "@/components/arena/code-editor"
 import { UsersPanel } from "@/components/arena/users-panel"
 import { PointsPanel } from "@/components/arena/points-panel"
 import { Terminal, ArrowLeft } from "lucide-react"
 import Link from "next/link"
 
+type MatchQuestion = {
+  questionId: string
+  order: number
+  question: {
+    id: string
+    title: string
+    description: string
+    difficulty: "EASY" | "MEDIUM" | "HARD"
+    testCases?: Array<{ input: string; expectedOutput: string }>
+  }
+}
+
+type MatchSubmission = {
+  questionId: string
+  testsPassed: number
+  testsTotal: number
+}
+
+type MatchPlayer = {
+  userId: string
+  rank: number | null
+  user: {
+    id: string
+    username: string
+    displayName: string | null
+    elo: number
+  }
+}
+
+type MatchDetails = {
+  id: string
+  status: string
+  mode: string
+  players: MatchPlayer[]
+  questions: MatchQuestion[]
+  submissions: MatchSubmission[]
+}
+
+const difficultyPoints: Record<string, number> = {
+  EASY: 150,
+  MEDIUM: 200,
+  HARD: 250,
+}
+
+const playerColors = [
+  "hsl(120 100% 50%)",
+  "hsl(45 100% 50%)",
+  "hsl(200 100% 50%)",
+  "hsl(0 80% 55%)",
+  "hsl(280 80% 60%)",
+]
+
+const formatDifficulty = (difficulty?: string) => {
+  if (!difficulty) return undefined
+  return difficulty[0] + difficulty.slice(1).toLowerCase()
+}
+
 export default function ArenaPage() {
+  const searchParams = useSearchParams()
+  const matchId = searchParams.get("match")
+  const [match, setMatch] = useState<MatchDetails | null>(null)
+  const [error, setError] = useState<string | null>(null)
+  const [isLoading, setIsLoading] = useState(false)
+  const [currentUserId, setCurrentUserId] = useState<string | null>(null)
+
+  useEffect(() => {
+    if (typeof window === "undefined") return
+    setCurrentUserId(window.localStorage.getItem("cnc.userId"))
+  }, [])
+
+  useEffect(() => {
+    if (!matchId) return
+    let active = true
+
+    const loadMatch = async () => {
+      setIsLoading(true)
+      setError(null)
+      try {
+        const res = await fetch(`/api/match/${matchId}`, {
+          credentials: "include",
+        })
+        const payload = await res.json().catch(() => ({}))
+        if (!res.ok) {
+          throw new Error(payload?.error || "Failed to load match.")
+        }
+        if (!active) return
+        setMatch(payload.match as MatchDetails)
+      } catch (err) {
+        if (!active) return
+        setError(err instanceof Error ? err.message : "Failed to load match.")
+      } finally {
+        if (active) setIsLoading(false)
+      }
+    }
+
+    loadMatch()
+
+    return () => {
+      active = false
+    }
+  }, [matchId])
+
+  const submissionStatus = useMemo(() => {
+    const attempted = new Set<string>()
+    const solved = new Set<string>()
+    if (match?.submissions) {
+      match.submissions.forEach((s) => {
+        attempted.add(s.questionId)
+        if (s.testsTotal > 0 && s.testsPassed === s.testsTotal) {
+          solved.add(s.questionId)
+        }
+      })
+    }
+    return { attempted, solved }
+  }, [match?.submissions])
+
+  const totalQuestions = match?.questions?.length ?? 0
+  const solvedCount = useMemo(() => {
+    if (!match) return 0
+    return match.questions.reduce((count, mq) => {
+      if (submissionStatus.solved.has(mq.questionId)) {
+        return count + 1
+      }
+      return count
+    }, 0)
+  }, [match, submissionStatus])
+
+  const users = useMemo(() => {
+    if (!match) return undefined
+    return match.players.map((player, index) => {
+      const display = player.user.displayName || player.user.username
+      const avatar = display?.trim()?.[0]?.toUpperCase() || "U"
+      const isCurrent = currentUserId === player.userId
+      return {
+        id: player.userId,
+        name: display,
+        avatar,
+        status: "coding" as const,
+        rank: player.rank ?? index + 1,
+        rating: player.user.elo,
+        solved: isCurrent ? solvedCount : 0,
+        total: totalQuestions,
+        color: playerColors[index % playerColors.length],
+      }
+    })
+  }, [currentUserId, match, solvedCount, totalQuestions])
+
+  const scoreboardQuestions = useMemo(() => {
+    if (!match) return undefined
+    return match.questions.map((mq, index) => {
+      let status: "solved" | "attempted" | "locked" = "locked"
+      if (submissionStatus.solved.has(mq.questionId)) {
+        status = "solved"
+      } else if (submissionStatus.attempted.has(mq.questionId)) {
+        status = "attempted"
+      }
+
+      const maxPoints =
+        difficultyPoints[mq.question.difficulty] ??
+        difficultyPoints.MEDIUM
+      const points = status === "solved" ? maxPoints : 0
+
+      return {
+        id: index + 1,
+        title: mq.question.title,
+        status,
+        points,
+        maxPoints,
+        bonuses: [],
+      }
+    })
+  }, [match, submissionStatus])
+
+  const activeQuestion = match?.questions?.[0]?.question
+  const activeExamples = Array.isArray(activeQuestion?.testCases)
+    ? activeQuestion?.testCases
+    : []
+  const problem = activeQuestion
+    ? {
+        title: activeQuestion.title,
+        description: activeQuestion.description,
+        difficulty: formatDifficulty(activeQuestion.difficulty),
+        tag: `Q1 / ${totalQuestions || 1}`,
+        examples: activeExamples.slice(0, 2).map((tc) => ({
+          input: String(tc.input),
+          output: String(tc.expectedOutput),
+        })),
+        constraints: [],
+      }
+    : undefined
+
   return (
     <main className="flex h-screen flex-col overflow-hidden bg-background">
       {/* Top bar */}
@@ -46,22 +237,34 @@ export default function ArenaPage() {
         </div>
       </header>
 
-      {/* Progress bar section */}
-      <div className="border-b border-border px-4 py-2">
-        <ProgressBar />
-      </div>
+      {error && (
+        <div className="border-b border-border bg-destructive/10 px-4 py-2 text-xs text-destructive">
+          {error}
+        </div>
+      )}
 
       {/* Main content area */}
       <div className="flex flex-1 overflow-hidden">
         {/* Code editor - center/left */}
-        <div className="flex flex-1 flex-col overflow-hidden p-2">
-          <CodeEditor />
+        <div className="relative flex flex-1 flex-col overflow-hidden p-2">
+          <CodeEditor problem={problem} />
+          {isLoading && (
+            <div className="absolute bottom-4 left-4 rounded-sm border border-border bg-card px-3 py-1.5 text-xs text-muted-foreground">
+              Loading match...
+            </div>
+          )}
         </div>
 
         {/* Right sidebar: Users + Points */}
         <div className="hidden w-72 flex-col gap-2 overflow-auto border-l border-border p-2 xl:flex">
-          <UsersPanel />
-          <PointsPanel />
+          <UsersPanel users={users} />
+          <PointsPanel
+            questions={
+              scoreboardQuestions && scoreboardQuestions.length > 0
+                ? scoreboardQuestions
+                : undefined
+            }
+          />
         </div>
       </div>
     </main>
diff --git a/app/auth/page.tsx b/app/auth/page.tsx
index 0c3f14f..7733299 100644
--- a/app/auth/page.tsx
+++ b/app/auth/page.tsx
@@ -2,56 +2,137 @@
 
 import { Terminal, ArrowLeft } from "lucide-react"
 import Link from "next/link"
-import { useState } from "react"
 import { useRouter } from "next/navigation"
+import { useState } from "react"
 
 export default function AuthPage() {
-  const router = useRouter()
   const [isLoading, setIsLoading] = useState(false)
-  const [isSignUp, setIsSignUp] = useState(false)
-  const [error, setError] = useState("")
+  const [isSubmitting, setIsSubmitting] = useState(false)
+  const [handle, setHandle] = useState("")
+  const [accessKey, setAccessKey] = useState("")
+  const [status, setStatus] = useState("Awaiting credentials...")
+  const [error, setError] = useState<string | null>(null)
+  const router = useRouter()
 
-  // Form fields
-  const [username, setUsername] = useState("")
-  const [email, setEmail] = useState("")
-  const [password, setPassword] = useState("")
+  const cacheUserId = (userId: string) => {
+    if (typeof window === "undefined") return
+    window.localStorage.setItem("cnc.userId", userId)
+  }
 
-  const handleSubmit = async (e: React.FormEvent) => {
-    e.preventDefault()
+  const handleGoogleSignIn = () => {
     setIsLoading(true)
-    setError("")
+    // Mock: In production, redirect to Supabase Google OAuth
+    setTimeout(() => {
+      setIsLoading(false)
+    }, 2000)
+  }
 
-    try {
-      const endpoint = isSignUp ? "/api/auth/signup" : "/api/auth/signin"
-      const body = isSignUp
-        ? { username, email, password }
-        : { login: username || email, password }
+  const handleSignup = async () => {
+    setError(null)
+
+    const username = handle.trim()
+    if (!username) {
+      setError("Handle is required.")
+      return
+    }
+    if (!accessKey.trim()) {
+      setError("Access key is required.")
+      return
+    }
+
+    const slug =
+      username
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, ".")
+        .replace(/^\.+|\.+$/g, "") || "user"
+    const email = `${slug}@cnc.local`
 
-      const res = await fetch(endpoint, {
+    setIsSubmitting(true)
+    setStatus("Initializing session...")
+    try {
+      const response = await fetch("/api/auth/signup", {
         method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify(body),
+        headers: {
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+          username,
+          email,
+          password: accessKey,
+          displayName: username,
+        }),
       })
 
-      const data = await res.json()
+      const payload = await response.json().catch(() => ({}))
+      if (!response.ok) {
+        setStatus("Awaiting credentials...")
+        setError(payload?.error || "Signup failed.")
+        return
+      }
 
-      if (!res.ok) {
-        setError(data.error || "Authentication failed")
+      if (!payload?.user?.id) {
+        setStatus("Awaiting credentials...")
+        setError("Signup succeeded but user id was missing.")
         return
       }
+      cacheUserId(payload.user.id)
+      setStatus("Session initialized.")
+      router.push("/profile")
+    } catch (err) {
+      setStatus("Awaiting credentials...")
+      setError(err instanceof Error ? err.message : "Signup failed.")
+    } finally {
+      setIsSubmitting(false)
+    }
+  }
+
+  const handleSignIn = async () => {
+    setError(null)
+
+    const login = handle.trim()
+    if (!login) {
+      setError("Handle is required.")
+      return
+    }
+    if (!accessKey.trim()) {
+      setError("Access key is required.")
+      return
+    }
 
-      // Store token in localStorage for client-side access
-      if (data.token) {
-        localStorage.setItem("token", data.token)
-        localStorage.setItem("user", JSON.stringify(data.user))
+    setIsSubmitting(true)
+    setStatus("Accessing terminal...")
+    try {
+      const response = await fetch("/api/auth/signin", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+          login,
+          password: accessKey,
+        }),
+      })
+
+      const payload = await response.json().catch(() => ({}))
+      if (!response.ok) {
+        setStatus("Awaiting credentials...")
+        setError(payload?.error || "Sign in failed.")
+        return
       }
 
-      // Redirect to arena
-      router.push("/arena")
+      if (!payload?.user?.id) {
+        setStatus("Awaiting credentials...")
+        setError("Sign in succeeded but user id was missing.")
+        return
+      }
+      cacheUserId(payload.user.id)
+      setStatus("Access granted.")
+      router.push("/profile")
     } catch (err) {
-      setError("Network error. Try again.")
+      setStatus("Awaiting credentials...")
+      setError(err instanceof Error ? err.message : "Sign in failed.")
     } finally {
-      setIsLoading(false)
+      setIsSubmitting(false)
     }
   }
 
@@ -91,12 +172,10 @@ export default function AuthPage() {
             </div>
             <div>
               <h1 className="text-xl font-bold uppercase tracking-wider text-foreground">
-                {isSignUp ? "Register Terminal" : "Access Terminal"}
+                {"Access Terminal"}
               </h1>
               <p className="mt-1 text-xs text-muted-foreground">
-                {isSignUp
-                  ? "// create your operative profile"
-                  : "// authenticate to enter the arena"}
+                {"// authenticate to enter the arena"}
               </p>
             </div>
           </div>
@@ -105,63 +184,67 @@ export default function AuthPage() {
           <div className="mb-6 rounded-sm border border-border bg-secondary/50 p-3">
             <div className="flex items-center gap-2 text-xs text-muted-foreground">
               <span className="text-primary">{"$"}</span>
-              <span>{isSignUp ? "system.register --new" : "system.auth --status"}</span>
+              <span>{"system.auth --status"}</span>
             </div>
             <div className="mt-1 flex items-center gap-2 text-xs">
               <span className="text-primary">{">"}</span>
-              <span className="text-foreground">{"Awaiting credentials..."}</span>
+              <span className="text-foreground">{status}</span>
               <span className="animate-blink text-primary">{"_"}</span>
             </div>
           </div>
 
-          {/* Error message */}
-          {error && (
-            <div className="mb-4 rounded-sm border border-red-500/30 bg-red-500/10 p-3 text-xs text-red-400">
-              <span className="text-red-500">{"ERROR: "}</span>
-              {error}
-            </div>
-          )}
+          {/* Google Sign In button */}
+          <button
+            onClick={handleGoogleSignIn}
+            disabled={isLoading}
+            className="flex w-full items-center justify-center gap-3 rounded-sm border border-border bg-secondary px-4 py-3 text-sm font-bold uppercase tracking-widest text-foreground transition-all hover:border-primary hover:text-primary disabled:opacity-50"
+          >
+            <svg className="h-5 w-5" viewBox="0 0 24 24">
+              <path
+                d="M22.56 12.25c0-.78-.07-1.53-.2-2.25H12v4.26h5.92a5.06 5.06 0 0 1-2.2 3.32v2.77h3.57c2.08-1.92 3.28-4.74 3.28-8.1z"
+                fill="#4285F4"
+              />
+              <path
+                d="M12 23c2.97 0 5.46-.98 7.28-2.66l-3.57-2.77c-.98.66-2.23 1.06-3.71 1.06-2.86 0-5.29-1.93-6.16-4.53H2.18v2.84C3.99 20.53 7.7 23 12 23z"
+                fill="#34A853"
+              />
+              <path
+                d="M5.84 14.09c-.22-.66-.35-1.36-.35-2.09s.13-1.43.35-2.09V7.07H2.18C1.43 8.55 1 10.22 1 12s.43 3.45 1.18 4.93l2.85-2.22.81-.62z"
+                fill="#FBBC05"
+              />
+              <path
+                d="M12 5.38c1.62 0 3.06.56 4.21 1.64l3.15-3.15C17.45 2.09 14.97 1 12 1 7.7 1 3.99 3.47 2.18 7.07l3.66 2.84c.87-2.6 3.3-4.53 6.16-4.53z"
+                fill="#EA4335"
+              />
+            </svg>
+            {isLoading ? "Connecting..." : "Sign in with Google"}
+          </button>
 
-          {/* Auth form */}
-          <form onSubmit={handleSubmit} className="flex flex-col gap-4">
+          {/* Divider */}
+          <div className="my-6 flex items-center gap-4">
+            <div className="h-px flex-1 bg-border" />
+            <span className="text-xs text-muted-foreground">{"or"}</span>
+            <div className="h-px flex-1 bg-border" />
+          </div>
+
+          {/* Username/Email mock fields */}
+          <div className="flex flex-col gap-4">
             <div>
               <label
                 htmlFor="username"
                 className="mb-1 block text-xs uppercase tracking-widest text-muted-foreground"
               >
-                Handle{isSignUp ? "" : " / Email"}
+                Handle
               </label>
               <input
                 id="username"
                 type="text"
-                value={username}
-                onChange={(e) => setUsername(e.target.value)}
                 placeholder="your_callsign"
-                required
+                value={handle}
+                onChange={(e) => setHandle(e.target.value)}
                 className="w-full rounded-sm border border-border bg-input px-3 py-2 text-sm text-foreground placeholder:text-muted-foreground focus:border-primary focus:outline-none focus:ring-1 focus:ring-primary"
               />
             </div>
-
-            {isSignUp && (
-              <div>
-                <label
-                  htmlFor="email"
-                  className="mb-1 block text-xs uppercase tracking-widest text-muted-foreground"
-                >
-                  Comm Channel (Email)
-                </label>
-                <input
-                  id="email"
-                  type="email"
-                  value={email}
-                  onChange={(e) => setEmail(e.target.value)}
-                  placeholder="operative@domain.com"
-                  required
-                  className="w-full rounded-sm border border-border bg-input px-3 py-2 text-sm text-foreground placeholder:text-muted-foreground focus:border-primary focus:outline-none focus:ring-1 focus:ring-primary"
-                />
-              </div>
-            )}
-
             <div>
               <label
                 htmlFor="password"
@@ -172,40 +255,41 @@ export default function AuthPage() {
               <input
                 id="password"
                 type="password"
-                value={password}
-                onChange={(e) => setPassword(e.target.value)}
                 placeholder="**************"
-                required
-                minLength={6}
+                value={accessKey}
+                onChange={(e) => setAccessKey(e.target.value)}
                 className="w-full rounded-sm border border-border bg-input px-3 py-2 text-sm text-foreground placeholder:text-muted-foreground focus:border-primary focus:outline-none focus:ring-1 focus:ring-primary"
               />
             </div>
+            <div className="flex flex-col gap-2">
+              <button
+                onClick={handleSignup}
+                disabled={isSubmitting}
+                className="animate-pulse-glow w-full rounded-sm border border-primary bg-primary px-4 py-2.5 text-sm font-bold uppercase tracking-widest text-primary-foreground transition-all hover:bg-primary/90 disabled:cursor-not-allowed disabled:opacity-70"
+              >
+                {isSubmitting ? "Initializing..." : "Initialize Session"}
+              </button>
+              <button
+                onClick={handleSignIn}
+                disabled={isSubmitting}
+                className="w-full rounded-sm border border-border bg-secondary px-4 py-2.5 text-xs font-bold uppercase tracking-widest text-foreground transition-all hover:border-primary hover:text-primary disabled:cursor-not-allowed disabled:opacity-70"
+              >
+                {isSubmitting ? "Accessing..." : "Access Existing"}
+              </button>
+            </div>
+            {error && (
+              <p className="rounded-sm border border-destructive/30 bg-destructive/10 px-3 py-2 text-xs text-destructive">
+                {error}
+              </p>
+            )}
+          </div>
 
-            <button
-              type="submit"
-              disabled={isLoading}
-              className="animate-pulse-glow w-full rounded-sm border border-primary bg-primary px-4 py-2.5 text-sm font-bold uppercase tracking-widest text-primary-foreground transition-all hover:bg-primary/90 disabled:opacity-50"
-            >
-              {isLoading
-                ? "Connecting..."
-                : isSignUp
-                  ? "Create Operative"
-                  : "Initialize Session"}
-            </button>
-          </form>
-
-          {/* Toggle signup/signin */}
+          {/* Footer text */}
           <p className="mt-6 text-center text-xs text-muted-foreground">
-            {isSignUp ? "Already an operative? " : "New operative? "}
-            <button
-              onClick={() => {
-                setIsSignUp(!isSignUp)
-                setError("")
-              }}
-              className="text-primary hover:underline"
-            >
-              {isSignUp ? "Sign In" : "Request Access"}
-            </button>
+            {"New operative? "}
+            <Link href="/auth" className="text-primary hover:underline">
+              {"Request Access"}
+            </Link>
           </p>
         </div>
       </div>
diff --git a/app/profile/page.tsx b/app/profile/page.tsx
index 2d0f980..543db95 100644
--- a/app/profile/page.tsx
+++ b/app/profile/page.tsx
@@ -1,26 +1,40 @@
+"use client"
+
+import { useEffect, useMemo, useState } from "react"
 import { Terminal, ArrowLeft, Trophy, Zap, Code, Target, Clock, TrendingUp } from "lucide-react"
 import Link from "next/link"
 
-const profile = {
-  name: "you",
-  rating: 1847,
-  rank: "#342",
-  title: "Code Warrior",
-  joined: "Jan 2026",
-  totalBattles: 128,
-  wins: 87,
-  losses: 41,
-  winRate: "68%",
-  totalXP: 24850,
-  streak: 7,
+type ProfileUser = {
+  id: string
+  username: string
+  email: string
+  displayName: string | null
+  title: string
+  skillTier: string
+  elo: number
+  totalWins: number
+  totalMatches: number
+  totalXP: number
+  streak: number
+  createdAt: string
 }
 
-const stats = [
-  { label: "Battles", value: "128", icon: Target },
-  { label: "Win Rate", value: "68%", icon: TrendingUp },
-  { label: "XP", value: "24,850", icon: Zap },
-  { label: "Streak", value: "7", icon: Trophy },
-]
+type ProfileStats = {
+  battles: number
+  winRate: number
+  xp: number
+  streak: number
+  elo: number
+}
+
+type RecentMatch = {
+  matchId: string
+  opponent: string
+  result: "WIN" | "LOSS" | "DRAW" | "PENDING"
+  mode: string
+  xpDelta: number
+  endedAt: string
+}
 
 const recentMatches = [
   { opponent: "n3x_byte", result: "WIN", points: "+175", mode: "Scratch", date: "2 hrs ago" },
@@ -30,6 +44,21 @@ const recentMatches = [
   { opponent: "byteB1aster", result: "WIN", points: "+180", mode: "Debug", date: "2 days ago" },
 ]
 
+const toDisplayMatch = (match: RecentMatch) => {
+  const points = match.xpDelta >= 0 ? `+${match.xpDelta}` : `${match.xpDelta}`
+  const date = new Date(match.endedAt).toLocaleDateString("en-US", {
+    month: "short",
+    day: "numeric",
+  })
+  return {
+    opponent: match.opponent,
+    result: match.result === "PENDING" ? "LOSS" : match.result,
+    points: `${points} XP`,
+    mode: match.mode,
+    date,
+  }
+}
+
 const skillBreakdown = [
   { skill: "DSA", level: 78, color: "hsl(120 100% 50%)" },
   { skill: "Clean Code", level: 85, color: "hsl(45 100% 50%)" },
@@ -39,6 +68,92 @@ const skillBreakdown = [
 ]
 
 export default function ProfilePage() {
+  const [user, setUser] = useState<ProfileUser | null>(null)
+  const [stats, setStats] = useState<ProfileStats | null>(null)
+  const [matches, setMatches] = useState<RecentMatch[]>([])
+  const [error, setError] = useState<string | null>(null)
+  const [loading, setLoading] = useState(true)
+
+  useEffect(() => {
+    const cachedId =
+      typeof window !== "undefined" ? window.localStorage.getItem("cnc.userId") : null
+
+    if (!cachedId) {
+      setError("No cached user found. Please sign in.")
+      setLoading(false)
+      return
+    }
+
+    const loadProfile = async () => {
+      try {
+        const response = await fetch(`/api/users/${cachedId}`)
+        const payload = await response.json().catch(() => ({}))
+        if (!response.ok) {
+          setError(payload?.error || "Failed to load profile.")
+          setLoading(false)
+          return
+        }
+        setUser(payload.user as ProfileUser)
+        setStats(payload.stats as ProfileStats)
+        setMatches((payload.recentMatches as RecentMatch[]) ?? [])
+      } catch (err) {
+        setError(err instanceof Error ? err.message : "Failed to load profile.")
+      } finally {
+        setLoading(false)
+      }
+    }
+
+    loadProfile()
+  }, [])
+
+  const derived = useMemo(() => {
+    const displayName = user?.displayName || user?.username || "you"
+    const rating = stats?.elo ?? user?.elo ?? 0
+    const totalBattles = stats?.battles ?? user?.totalMatches ?? 0
+    const wins = user?.totalWins ?? 0
+    const losses = Math.max(totalBattles - wins, 0)
+    const winRate = stats
+      ? `${stats.winRate}%`
+      : totalBattles > 0
+        ? `${Math.round((wins / totalBattles) * 100)}%`
+        : "0%"
+    const joined = user?.createdAt
+      ? new Date(user.createdAt).toLocaleDateString("en-US", {
+          month: "short",
+          year: "numeric",
+        })
+      : "-"
+    const title = user?.title || "Code Warrior"
+    const totalXP = stats?.xp ?? user?.totalXP ?? 0
+    const streak = stats?.streak ?? user?.streak ?? 0
+
+    return {
+      displayName,
+      rating,
+      rank: "Unranked",
+      title,
+      joined,
+      totalBattles,
+      wins,
+      losses,
+      winRate,
+      totalXP,
+      streak,
+    }
+  }, [user])
+
+  const statCards = [
+    { label: "Battles", value: String(derived.totalBattles), icon: Target },
+    { label: "Win Rate", value: derived.winRate, icon: TrendingUp },
+    { label: "XP", value: derived.totalXP.toLocaleString("en-US"), icon: Zap },
+    { label: "Streak", value: String(derived.streak), icon: Trophy },
+  ]
+
+  const hasRecentMatches = matches.length > 0
+  const displayMatches = hasRecentMatches
+    ? matches.map(toDisplayMatch)
+    : recentMatches
+
   return (
     <main className="min-h-screen bg-background">
       {/* Top bar */}
@@ -59,7 +174,7 @@ export default function ProfilePage() {
             </div>
           </div>
           <Link
-            href="/arena"
+            href="/arena/lobby"
             className="rounded-sm border border-primary bg-primary px-4 py-1.5 text-xs font-bold uppercase tracking-widest text-primary-foreground transition-all hover:bg-primary/90"
           >
             Enter Arena
@@ -68,29 +183,39 @@ export default function ProfilePage() {
       </header>
 
       <div className="mx-auto max-w-5xl px-4 py-8">
+        {loading && (
+          <div className="mb-6 rounded-sm border border-border bg-card p-4 text-xs text-muted-foreground">
+            Loading profile...
+          </div>
+        )}
+        {error && !loading && (
+          <div className="mb-6 rounded-sm border border-destructive/30 bg-destructive/10 p-4 text-xs text-destructive">
+            {error}
+          </div>
+        )}
         {/* Profile header */}
         <div className="mb-8 flex flex-col gap-6 md:flex-row md:items-center md:gap-8">
           <div className="flex h-20 w-20 items-center justify-center rounded-sm border border-primary/30 bg-primary/10 text-3xl font-bold text-primary">
-            Y
+            {derived.displayName.slice(0, 1).toUpperCase()}
           </div>
           <div className="flex-1">
             <div className="flex flex-wrap items-center gap-3">
-              <h1 className="text-2xl font-bold text-foreground">{profile.name}</h1>
+              <h1 className="text-2xl font-bold text-foreground">{derived.displayName}</h1>
               <span className="rounded-sm border border-primary/30 bg-primary/10 px-2 py-0.5 text-xs text-primary">
-                {profile.title}
+                {derived.title}
               </span>
             </div>
             <div className="mt-2 flex flex-wrap items-center gap-4 text-xs text-muted-foreground">
-              <span>ELO: <span className="font-bold text-primary">{profile.rating}</span></span>
-              <span>Global Rank: <span className="font-bold text-foreground">{profile.rank}</span></span>
-              <span>Joined: {profile.joined}</span>
+              <span>ELO: <span className="font-bold text-primary">{derived.rating}</span></span>
+              <span>Global Rank: <span className="font-bold text-foreground">{derived.rank}</span></span>
+              <span>Joined: {derived.joined}</span>
             </div>
           </div>
         </div>
 
         {/* Stats grid */}
         <div className="mb-8 grid grid-cols-2 gap-3 md:grid-cols-4">
-          {stats.map((stat) => (
+          {statCards.map((stat) => (
             <div key={stat.label} className="rounded-sm border border-border bg-card p-4">
               <div className="mb-2 flex items-center gap-2">
                 <stat.icon className="h-4 w-4 text-primary" />
@@ -112,6 +237,9 @@ export default function ProfilePage() {
                 Skill Breakdown
               </span>
             </div>
+            <p className="mb-4 text-xs text-muted-foreground">
+              Skill metrics are coming soon. Sample bars shown below.
+            </p>
             <div className="flex flex-col gap-4">
               {skillBreakdown.map((s) => (
                 <div key={s.skill} className="flex flex-col gap-1.5">
@@ -142,8 +270,13 @@ export default function ProfilePage() {
                 Recent Matches
               </span>
             </div>
+            {!hasRecentMatches && (
+              <p className="mb-3 text-xs text-muted-foreground">
+                No matches found yet. Sample history shown below.
+              </p>
+            )}
             <div className="flex flex-col">
-              {recentMatches.map((match, i) => (
+              {displayMatches.map((match, i) => (
                 <div
                   key={i}
                   className="flex items-center justify-between border-b border-border/50 py-3 last:border-b-0"
diff --git a/components/arena/code-editor.tsx b/components/arena/code-editor.tsx
index 51e56a4..a43a4ac 100644
--- a/components/arena/code-editor.tsx
+++ b/components/arena/code-editor.tsx
@@ -1,7 +1,70 @@
 "use client"
 
-import { useState } from "react"
+import { useEffect, useMemo, useState } from "react"
 import { Play, RotateCcw, Send, ChevronDown } from "lucide-react"
+import dynamic from "next/dynamic"
+
+const MonacoEditor = dynamic(
+  () => import("@monaco-editor/react").then((mod) => mod.default),
+  { ssr: false },
+)
+
+const PISTON_BASE = "https://emkc.org/api/v2/piston"
+
+interface PistonRuntime {
+  language: string
+  version: string
+  aliases: string[]
+  runtime?: string
+}
+
+interface PistonStageResult {
+  stdout: string
+  stderr: string
+  output: string
+  code: number | null
+  signal: string | null
+}
+
+interface PistonExecuteResponse {
+  language: string
+  version: string
+  run: PistonStageResult
+  compile?: PistonStageResult
+}
+
+const jsonGuard = async <T,>(res: Response): Promise<T> => {
+  const contentType = res.headers.get("content-type") ?? ""
+  const text = await res.text()
+
+  if (!res.ok) {
+    throw new Error(
+      `Piston returned ${res.status}. ${text.slice(0, 160) || "Empty body"}`,
+    )
+  }
+
+  if (!contentType.toLowerCase().includes("application/json")) {
+    throw new Error(
+      `Piston responded with non-JSON (content-type: ${contentType || "unknown"}). Body starts with: ${text
+        .replace(/\s+/g, " ")
+        .slice(0, 160)}`,
+    )
+  }
+
+  try {
+    return JSON.parse(text) as T
+  } catch (err) {
+    throw new Error(
+      `Failed to parse Piston JSON: ${(err as Error).message}. Body starts with: ${text
+        .replace(/\s+/g, " ")
+        .slice(0, 160)}`,
+    )
+  }
+}
+
+const baseHeaders = {
+  Accept: "application/json",
+}
 
 const defaultCode = `def two_sum(nums, target):
     """
@@ -21,6 +84,83 @@ const defaultCode = `def two_sum(nums, target):
 print(two_sum([2, 7, 11, 15], 9))
 `
 
+const starterSnippets: Record<string, string> = {
+  python: defaultCode,
+  javascript: 'console.log("Hello, Piston!");',
+  java: `public class Main {
+    public static void main(String[] args) {
+        System.out.println("Hello, Piston!");
+    }
+}`,
+  "c++": `#include <bits/stdc++.h>
+using namespace std;
+
+int main() {
+    cout << "Hello, Piston!" << "\\n";
+    return 0;
+}`,
+}
+
+const normalizeLanguage = (language: string) => language.trim().toLowerCase()
+
+const snippetForLanguage = (language: string) => {
+  const key = normalizeLanguage(language)
+  if (key.includes("python")) return starterSnippets.python
+  if (key.includes("javascript") || key === "js" || key.includes("node")) {
+    return starterSnippets.javascript
+  }
+  if (key === "java") return starterSnippets.java
+  if (key.includes("c++") || key.includes("cpp")) return starterSnippets["c++"]
+  return undefined
+}
+
+const fileNameForLanguage = (language: string) => {
+  const key = normalizeLanguage(language)
+  if (key.includes("python")) return "main.py"
+  if (key.includes("javascript") || key === "js" || key.includes("node")) {
+    return "main.js"
+  }
+  if (key === "java") return "Main.java"
+  if (key.includes("c++") || key.includes("cpp")) return "main.cpp"
+  return undefined
+}
+
+const matchesLanguage = (runtime: PistonRuntime, selection: string) => {
+  const target = normalizeLanguage(selection)
+  const runtimeName = normalizeLanguage(runtime.language)
+  const aliases = runtime.aliases?.map(normalizeLanguage) ?? []
+
+  if (target === "c++") {
+    return (
+      runtimeName.includes("c++") ||
+      runtimeName.includes("cpp") ||
+      aliases.includes("c++") ||
+      aliases.includes("cpp")
+    )
+  }
+  if (target === "javascript") {
+    return (
+      runtimeName.includes("javascript") ||
+      runtimeName.includes("node") ||
+      aliases.includes("javascript") ||
+      aliases.includes("node")
+    )
+  }
+  return runtimeName === target || aliases.includes(target)
+}
+
+const outputFromResult = (result: PistonExecuteResponse) => {
+  const compileOutput = result.compile?.output?.trim()
+  if (compileOutput) return compileOutput
+
+  const runOutput = result.run.output?.trim()
+  if (runOutput) return runOutput
+
+  if (result.run.stderr) return result.run.stderr
+  if (result.run.stdout) return result.run.stdout
+  return "No output produced."
+}
+
 const problemStatement = {
   title: "Two Sum",
   difficulty: "Easy",
@@ -38,21 +178,139 @@ const problemStatement = {
   ],
 }
 
-export function CodeEditor() {
+type CodeEditorProblem = {
+  title: string
+  difficulty?: string
+  tag?: string
+  description: string
+  examples?: { input: string; output: string }[]
+  constraints?: string[]
+}
+
+type CodeEditorProps = {
+  problem?: CodeEditorProblem
+}
+
+export function CodeEditor({ problem }: CodeEditorProps) {
   const [code, setCode] = useState(defaultCode)
   const [activeTab, setActiveTab] = useState<"problem" | "output">("problem")
   const [language, setLanguage] = useState("python")
   const [showLangDropdown, setShowLangDropdown] = useState(false)
   const [output, setOutput] = useState("")
+  const [runtimes, setRuntimes] = useState<PistonRuntime[]>([])
+  const [runtimeError, setRuntimeError] = useState<string | null>(null)
+  const [isLoadingRuntimes, setIsLoadingRuntimes] = useState(false)
+  const [isRunning, setIsRunning] = useState(false)
+  const activeProblem = problem ?? problemStatement
+  const problemTag = activeProblem.tag ?? problemStatement.tag
+  const problemDifficulty =
+    activeProblem.difficulty ?? problemStatement.difficulty
 
-  const handleRun = () => {
+  const handleEditorWillMount = (monaco: any) => {
+    monaco.editor.defineTheme("black-green", {
+      base: "vs-dark",
+      inherit: false,
+      semanticHighlighting: false,
+      rules: [
+        { token: "", foreground: "FFFFFF", background: "000000" },
+        { token: "comment", foreground: "FFFFFF" },
+        { token: "string", foreground: "FFFFFF" },
+        { token: "number", foreground: "FFFFFF" },
+        { token: "keyword", foreground: "FFFFFF" },
+        { token: "identifier", foreground: "FFFFFF" },
+        { token: "delimiter", foreground: "FFFFFF" },
+        { token: "type", foreground: "FFFFFF" },
+        { token: "function", foreground: "FFFFFF" },
+      ],
+      colors: {
+        "editor.background": "#000000",
+        "editor.foreground": "#FFFFFF",
+        "editorLineNumber.foreground": "#5AAA5A",
+        "editorCursor.foreground": "#FFFFFF",
+        "editor.selectionBackground": "#0B2A0B",
+        "editor.inactiveSelectionBackground": "#082008",
+        "editor.lineHighlightBackground": "#081B08",
+        "editorIndentGuide.background": "#123312",
+        "editorIndentGuide.activeBackground": "#39FF14",
+      },
+    })
+  }
+
+  const selectedRuntime = useMemo(() => {
+    return runtimes.find((runtime) => matchesLanguage(runtime, language)) ?? null
+  }, [language, runtimes])
+
+  useEffect(() => {
+    let isActive = true
+
+    const loadRuntimes = async () => {
+      setIsLoadingRuntimes(true)
+      setRuntimeError(null)
+      try {
+        const response = await fetch(`${PISTON_BASE}/runtimes`, {
+          cache: "no-store",
+          headers: baseHeaders,
+        })
+        const data = await jsonGuard<PistonRuntime[]>(response)
+        if (!isActive) return
+        setRuntimes(data)
+      } catch (err: unknown) {
+        if (!isActive) return
+        const message = err instanceof Error ? err.message : "Failed to load runtimes."
+        setRuntimeError(message)
+        setRuntimes([])
+      } finally {
+        if (isActive) setIsLoadingRuntimes(false)
+      }
+    }
+
+    loadRuntimes()
+
+    return () => {
+      isActive = false
+    }
+  }, [])
+
+  const handleRun = async () => {
     setActiveTab("output")
     setOutput("Running...\n")
-    setTimeout(() => {
-      setOutput(
-        `$ python solution.py\n[0, 1]\n\n---\nTest Case 1: PASSED\nTest Case 2: PASSED\nTest Case 3: PASSED\n\nAll test cases passed.\nExecution time: 4ms\nMemory: 14.2 MB`
-      )
-    }, 1200)
+    setIsRunning(true)
+
+    if (!selectedRuntime) {
+      setOutput("No runtime available for the selected language.")
+      setIsRunning(false)
+      return
+    }
+
+    try {
+      const fileName = fileNameForLanguage(language)
+      const submissionRes = await fetch(`${PISTON_BASE}/execute`, {
+        method: "POST",
+        headers: {
+          ...baseHeaders,
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+          language: selectedRuntime.language,
+          version: selectedRuntime.version,
+          files: [
+            {
+              ...(fileName ? { name: fileName } : {}),
+              content: code,
+            },
+          ],
+          stdin: "",
+        }),
+      })
+
+      const execution = await jsonGuard<PistonExecuteResponse>(submissionRes)
+      setOutput(outputFromResult(execution))
+    } catch (err: unknown) {
+      const message = err instanceof Error ? err.message : "Failed to run code."
+      setOutput(`Error: ${message}`)
+    } finally {
+      setIsRunning(false)
+    }
   }
 
   const handleSubmit = () => {
@@ -98,22 +356,27 @@ export function CodeEditor() {
           {activeTab === "problem" ? (
             <div className="flex flex-col gap-4">
               <div className="flex items-center gap-3">
-                <span className="text-xs text-primary">{problemStatement.tag}</span>
+                <span className="text-xs text-primary">{problemTag}</span>
                 <h2 className="text-lg font-bold text-foreground">
-                  {problemStatement.title}
+                  {activeProblem.title}
                 </h2>
-                <span className="rounded-sm border border-primary/30 bg-primary/10 px-2 py-0.5 text-xs text-primary">
-                  {problemStatement.difficulty}
-                </span>
+                {problemDifficulty && (
+                  <span className="rounded-sm border border-primary/30 bg-primary/10 px-2 py-0.5 text-xs text-primary">
+                    {problemDifficulty}
+                  </span>
+                )}
               </div>
               <p className="text-sm leading-relaxed text-muted-foreground">
-                {problemStatement.description}
+                {activeProblem.description}
               </p>
               <div className="flex flex-col gap-3">
                 <span className="text-xs uppercase tracking-widest text-primary">
                   {"Examples"}
                 </span>
-                {problemStatement.examples.map((ex, i) => (
+                {(activeProblem.examples && activeProblem.examples.length > 0
+                  ? activeProblem.examples
+                  : problemStatement.examples
+                ).map((ex, i) => (
                   <div
                     key={i}
                     className="rounded-sm border border-border bg-secondary/50 p-3"
@@ -129,19 +392,22 @@ export function CodeEditor() {
                   </div>
                 ))}
               </div>
-              <div className="flex flex-col gap-2">
-                <span className="text-xs uppercase tracking-widest text-primary">
-                  {"Constraints"}
-                </span>
-                <ul className="flex flex-col gap-1">
-                  {problemStatement.constraints.map((c) => (
-                    <li key={c} className="flex items-center gap-2 text-xs text-muted-foreground">
-                      <span className="text-primary">{">"}</span>
-                      {c}
-                    </li>
-                  ))}
-                </ul>
-              </div>
+              {activeProblem.constraints &&
+                activeProblem.constraints.length > 0 && (
+                  <div className="flex flex-col gap-2">
+                    <span className="text-xs uppercase tracking-widest text-primary">
+                      {"Constraints"}
+                    </span>
+                    <ul className="flex flex-col gap-1">
+                      {activeProblem.constraints.map((c) => (
+                        <li key={c} className="flex items-center gap-2 text-xs text-muted-foreground">
+                          <span className="text-primary">{">"}</span>
+                          {c}
+                        </li>
+                      ))}
+                    </ul>
+                  </div>
+                )}
             </div>
           ) : (
             <pre className="whitespace-pre-wrap text-xs leading-relaxed text-foreground">
@@ -155,7 +421,7 @@ export function CodeEditor() {
       <div className="flex flex-1 flex-col">
         {/* Toolbar */}
         <div className="flex items-center justify-between border-b border-border px-4 py-2">
-          <div className="relative">
+          <div className="relative flex flex-col">
             <button
               onClick={() => setShowLangDropdown(!showLangDropdown)}
               className="flex items-center gap-1 text-xs uppercase tracking-widest text-muted-foreground hover:text-foreground"
@@ -169,6 +435,14 @@ export function CodeEditor() {
                   <button
                     key={lang}
                     onClick={() => {
+                      const nextSnippet = snippetForLanguage(lang)
+                      const currentSnippet = snippetForLanguage(language)
+                      if (
+                        nextSnippet &&
+                        (code.trim() === "" || code === currentSnippet)
+                      ) {
+                        setCode(nextSnippet)
+                      }
                       setLanguage(lang)
                       setShowLangDropdown(false)
                     }}
@@ -181,10 +455,22 @@ export function CodeEditor() {
                 ))}
               </div>
             )}
+            {runtimeError && (
+              <span className="mt-1 text-[10px] text-destructive">
+                {runtimeError}
+              </span>
+            )}
+            {!runtimeError && isLoadingRuntimes && (
+              <span className="mt-1 text-[10px] text-muted-foreground">
+                Loading runtimes...
+              </span>
+            )}
           </div>
           <div className="flex items-center gap-2">
             <button
-              onClick={() => setCode(defaultCode)}
+              onClick={() => {
+                setCode(snippetForLanguage(language) ?? defaultCode)
+              }}
               className="rounded-sm border border-border p-1.5 text-muted-foreground transition-colors hover:border-primary/50 hover:text-foreground"
               aria-label="Reset code"
             >
@@ -192,10 +478,11 @@ export function CodeEditor() {
             </button>
             <button
               onClick={handleRun}
+              disabled={isRunning || isLoadingRuntimes}
               className="flex items-center gap-1.5 rounded-sm border border-border bg-secondary px-3 py-1.5 text-xs uppercase tracking-widest text-foreground transition-all hover:border-primary/50"
             >
               <Play className="h-3 w-3 text-primary" />
-              Run
+              {isRunning ? "Running" : "Run"}
             </button>
             <button
               onClick={handleSubmit}
@@ -207,29 +494,23 @@ export function CodeEditor() {
           </div>
         </div>
 
-        {/* Line numbers + textarea */}
-        <div className="relative flex flex-1 overflow-auto">
-          {/* Line numbers */}
-          <div className="flex flex-col border-r border-border bg-secondary/30 px-3 py-3 text-right">
-            {code.split("\n").map((_, i) => (
-              <span
-                key={i}
-                className="text-xs leading-5 text-muted-foreground/50"
-              >
-                {i + 1}
-              </span>
-            ))}
-          </div>
-
-          {/* Code area */}
-          <textarea
+        {/* Monaco Code Editor */}
+        <div className="flex-1 min-h-0">
+          <MonacoEditor
+            height="100%"
+            defaultLanguage={language === "c++" ? "cpp" : language}
+            language={language === "c++" ? "cpp" : language}
             value={code}
-            onChange={(e) => setCode(e.target.value)}
-            className="flex-1 resize-none bg-transparent p-3 text-xs leading-5 text-foreground caret-primary focus:outline-none"
-            spellCheck={false}
-            autoComplete="off"
-            autoCorrect="off"
-            autoCapitalize="off"
+            onChange={(value) => setCode(value || "")}
+            theme="black-green"
+            options={{
+              fontSize: 14,
+              minimap: { enabled: false },
+              wordWrap: "on",
+              scrollBeyondLastLine: false,
+              automaticLayout: true,
+            }}
+            beforeMount={handleEditorWillMount}
           />
         </div>
 
diff --git a/components/arena/points-panel.tsx b/components/arena/points-panel.tsx
index 21673e9..1ab55af 100644
--- a/components/arena/points-panel.tsx
+++ b/components/arena/points-panel.tsx
@@ -16,7 +16,7 @@ const questions: QuestionResult[] = [
     status: "solved",
     points: 150,
     maxPoints: 150,
-    bonuses: ["First Blood +50", "Clean Code +20"],
+    bonuses: ["First Blood +50"],
   },
   {
     id: 2,
@@ -24,7 +24,7 @@ const questions: QuestionResult[] = [
     status: "solved",
     points: 120,
     maxPoints: 150,
-    bonuses: ["Speed +15"],
+    bonuses: [],
   },
   {
     id: 3,
@@ -61,12 +61,18 @@ const statusStyles = {
 const statusLabels = {
   solved: "SOLVED",
   attempted: "IN PROGRESS",
-  locked: "LOCKED",
+  locked: "NOT SEEN",
+}
+
+type PointsPanelProps = {
+  questions?: QuestionResult[]
 }
 
-export function PointsPanel() {
-  const totalPoints = questions.reduce((sum, q) => sum + q.points, 0)
-  const maxPoints = questions.reduce((sum, q) => sum + q.maxPoints, 0)
+export function PointsPanel({ questions: questionsProp }: PointsPanelProps) {
+  const resolvedQuestions =
+    questionsProp && questionsProp.length > 0 ? questionsProp : questions
+  const totalPoints = resolvedQuestions.reduce((sum, q) => sum + q.points, 0)
+  const maxPoints = resolvedQuestions.reduce((sum, q) => sum + q.maxPoints, 0)
 
   return (
     <div className="flex flex-col rounded-sm border border-border bg-card">
@@ -84,12 +90,11 @@ export function PointsPanel() {
 
       {/* Question breakdown */}
       <div className="flex flex-col">
-        {questions.map((q) => (
-          <div
+        {resolvedQuestions.map((q) => (
+          <button
             key={q.id}
-            className={`flex flex-col gap-1.5 border-b border-border/50 px-3 py-2.5 last:border-b-0 ${
-              q.status === "locked" ? "opacity-40" : ""
-            }`}
+            type="button"
+            className="flex w-full flex-col gap-1.5 border-b border-border/50 px-3 py-2.5 text-left transition hover:bg-primary/5 focus:outline-none focus-visible:ring-1 focus-visible:ring-primary last:border-b-0"
           >
             <div className="flex items-center justify-between">
               <div className="flex items-center gap-2">
@@ -109,12 +114,6 @@ export function PointsPanel() {
 
             {/* Points bar */}
             <div className="flex items-center gap-2">
-              <div className="relative h-1.5 flex-1 overflow-hidden rounded-sm bg-secondary">
-                <div
-                  className="h-full rounded-sm bg-primary transition-all"
-                  style={{ width: `${(q.points / q.maxPoints) * 100}%` }}
-                />
-              </div>
               <span className="text-xs text-muted-foreground">
                 {q.points}/{q.maxPoints}
               </span>
@@ -134,7 +133,7 @@ export function PointsPanel() {
                 ))}
               </div>
             )}
-          </div>
+          </button>
         ))}
       </div>
 
diff --git a/components/arena/progress-bar.tsx b/components/arena/progress-bar.tsx
index 8bc3a4d..088a052 100644
--- a/components/arena/progress-bar.tsx
+++ b/components/arena/progress-bar.tsx
@@ -20,11 +20,31 @@ const initialPlayers: Player[] = [
   { id: "5", name: "algo_gh0st", avatar: "A", progress: 28, solved: 1, total: 5, color: "hsl(280 80% 60%)" },
 ]
 
-export function ProgressBar() {
-  const [players, setPlayers] = useState(initialPlayers)
+type ProgressBarProps = {
+  players?: Player[]
+  roundLabel?: string
+  timerLabel?: string
+}
+
+export function ProgressBar({ players: playersProp, roundLabel, timerLabel }: ProgressBarProps) {
+  const hasProvidedPlayers = Boolean(playersProp && playersProp.length > 0)
+  const [players, setPlayers] = useState<Player[]>(
+    hasProvidedPlayers ? (playersProp as Player[]) : initialPlayers,
+  )
+  const resolvedRoundLabel = roundLabel || "Round 1 / 5"
+  const resolvedTimerLabel = timerLabel || "04:32"
+
+  useEffect(() => {
+    if (hasProvidedPlayers) {
+      setPlayers(playersProp as Player[])
+      return
+    }
+    setPlayers(initialPlayers)
+  }, [hasProvidedPlayers, playersProp])
 
   // Simulate live progress updates
   useEffect(() => {
+    if (hasProvidedPlayers) return
     const interval = setInterval(() => {
       setPlayers((prev) =>
         prev.map((p) => ({
@@ -49,8 +69,8 @@ export function ProgressBar() {
           </span>
         </div>
         <div className="flex items-center gap-2">
-          <span className="text-xs text-muted-foreground">{"Round 1 / 5"}</span>
-          <span className="text-xs text-muted-foreground">{"04:32"}</span>
+          <span className="text-xs text-muted-foreground">{resolvedRoundLabel}</span>
+          <span className="text-xs text-muted-foreground">{resolvedTimerLabel}</span>
         </div>
       </div>
 
diff --git a/components/arena/users-panel.tsx b/components/arena/users-panel.tsx
index 951a1f7..54c71ed 100644
--- a/components/arena/users-panel.tsx
+++ b/components/arena/users-panel.tsx
@@ -10,15 +10,17 @@ interface User {
   status: "coding" | "idle" | "submitted"
   rank: number
   rating: number
+  solved: number
+  total: number
   color: string
 }
 
 const initialUsers: User[] = [
-  { id: "1", name: "you", avatar: "Y", status: "coding", rank: 1, rating: 1847, color: "hsl(120 100% 50%)" },
-  { id: "2", name: "n3x_byte", avatar: "N", status: "coding", rank: 2, rating: 2103, color: "hsl(45 100% 50%)" },
-  { id: "3", name: "z3r0_day", avatar: "Z", status: "idle", rank: 3, rating: 1956, color: "hsl(200 100% 50%)" },
-  { id: "4", name: "c0d3_wr4ith", avatar: "C", status: "submitted", rank: 4, rating: 2241, color: "hsl(0 80% 55%)" },
-  { id: "5", name: "algo_gh0st", avatar: "A", status: "coding", rank: 5, rating: 1724, color: "hsl(280 80% 60%)" },
+  { id: "1", name: "you", avatar: "Y", status: "coding", rank: 1, rating: 1847, solved: 2, total: 5, color: "hsl(120 100% 50%)" },
+  { id: "2", name: "n3x_byte", avatar: "N", status: "coding", rank: 2, rating: 2103, solved: 3, total: 5, color: "hsl(45 100% 50%)" },
+  { id: "3", name: "z3r0_day", avatar: "Z", status: "idle", rank: 3, rating: 1956, solved: 2, total: 5, color: "hsl(200 100% 50%)" },
+  { id: "4", name: "c0d3_wr4ith", avatar: "C", status: "submitted", rank: 4, rating: 2241, solved: 4, total: 5, color: "hsl(0 80% 55%)" },
+  { id: "5", name: "algo_gh0st", avatar: "A", status: "coding", rank: 5, rating: 1724, solved: 1, total: 5, color: "hsl(280 80% 60%)" },
 ]
 
 const statusConfig = {
@@ -27,11 +29,27 @@ const statusConfig = {
   submitted: { label: "DONE", dotClass: "bg-yellow-400" },
 }
 
-export function UsersPanel() {
-  const [users, setUsers] = useState(initialUsers)
+type UsersPanelProps = {
+  users?: User[]
+}
+
+export function UsersPanel({ users: usersProp }: UsersPanelProps) {
+  const hasProvidedUsers = Boolean(usersProp && usersProp.length > 0)
+  const [users, setUsers] = useState<User[]>(
+    hasProvidedUsers ? (usersProp as User[]) : initialUsers,
+  )
+
+  useEffect(() => {
+    if (hasProvidedUsers) {
+      setUsers(usersProp as User[])
+      return
+    }
+    setUsers(initialUsers)
+  }, [hasProvidedUsers, usersProp])
 
   // Simulate status changes
   useEffect(() => {
+    if (hasProvidedUsers) return
     const interval = setInterval(() => {
       setUsers((prev) =>
         prev.map((u) => {
@@ -46,6 +64,11 @@ export function UsersPanel() {
     return () => clearInterval(interval)
   }, [])
 
+  const sortedUsers = [...users].sort((a, b) => {
+    if (b.solved !== a.solved) return b.solved - a.solved
+    return b.rating - a.rating
+  })
+
   return (
     <div className="flex flex-col rounded-sm border border-border bg-card">
       {/* Header */}
@@ -61,7 +84,7 @@ export function UsersPanel() {
 
       {/* User list */}
       <div className="flex flex-col">
-        {users.map((user) => {
+        {sortedUsers.map((user) => {
           const sc = statusConfig[user.status]
           return (
             <div
@@ -101,6 +124,9 @@ export function UsersPanel() {
                 <div className={`h-1.5 w-1.5 rounded-full ${sc.dotClass}`} />
                 <span className="text-xs text-muted-foreground">{sc.label}</span>
               </div>
+              <div className="ml-2 text-xs text-muted-foreground">
+                {user.solved}/{user.total}
+              </div>
             </div>
           )
         })}
diff --git a/components/landing/footer.tsx b/components/landing/footer.tsx
index 6473dd8..f18e134 100644
--- a/components/landing/footer.tsx
+++ b/components/landing/footer.tsx
@@ -19,7 +19,7 @@ export function Footer() {
             Features
           </Link>
           <Link
-            href="/arena"
+            href="/arena/lobby"
             className="text-xs uppercase tracking-widest text-muted-foreground transition-colors hover:text-primary"
           >
             Arena
diff --git a/components/landing/navbar.tsx b/components/landing/navbar.tsx
index 0cc43a0..7433c3c 100644
--- a/components/landing/navbar.tsx
+++ b/components/landing/navbar.tsx
@@ -32,7 +32,7 @@ export function Navbar() {
             Modes
           </Link>
           <Link
-            href="/arena"
+            href="/arena/lobby"
             className="text-xs uppercase tracking-widest text-muted-foreground transition-colors hover:text-primary"
           >
             Arena
@@ -74,7 +74,7 @@ export function Navbar() {
               Modes
             </Link>
             <Link
-              href="/arena"
+              href="/arena/lobby"
               onClick={() => setOpen(false)}
               className="text-xs uppercase tracking-widest text-muted-foreground transition-colors hover:text-primary"
             >
diff --git a/lib/db.ts b/lib/db.ts
index 74aa3b1..5e1db6a 100644
--- a/lib/db.ts
+++ b/lib/db.ts
@@ -1,7 +1,33 @@
 import { PrismaClient } from "../prisma/generated/prisma/client";
+import { PrismaPg } from "@prisma/adapter-pg";
+import { Pool } from "pg";
 
-const globalForPrisma = globalThis as unknown as { prisma: PrismaClient };
+const globalForPrisma = globalThis as unknown as {
+  prisma: PrismaClient | undefined;
+  prismaPool: Pool | undefined;
+};
 
-export const prisma = globalForPrisma.prisma || new PrismaClient();
+const databaseUrl = process.env.DATABASE_URL;
+if (!databaseUrl) {
+  throw new Error("DATABASE_URL is not set");
+}
 
-if (process.env.NODE_ENV !== "production") globalForPrisma.prisma = prisma;
+const url = new URL(databaseUrl);
+const isLocalhost =
+  url.hostname === "localhost" || url.hostname === "127.0.0.1";
+
+const pool =
+  globalForPrisma.prismaPool ||
+  new Pool({
+    connectionString: databaseUrl,
+    ssl: isLocalhost ? undefined : { rejectUnauthorized: false },
+  });
+
+const adapter = new PrismaPg(pool);
+
+export const prisma = globalForPrisma.prisma || new PrismaClient({ adapter });
+
+if (process.env.NODE_ENV !== "production") {
+  globalForPrisma.prisma = prisma;
+  globalForPrisma.prismaPool = pool;
+}
diff --git a/lib/lobby.ts b/lib/lobby.ts
new file mode 100644
index 0000000..c01c093
--- /dev/null
+++ b/lib/lobby.ts
@@ -0,0 +1,34 @@
+import { prisma } from "@/lib/db"
+
+export const listAvailableMatches = async () => {
+  const matches = await prisma.match.findMany({
+    where: { status: "WAITING" },
+    orderBy: { createdAt: "desc" },
+    include: {
+      players: {
+        include: {
+          user: {
+            select: {
+              id: true,
+              username: true,
+              displayName: true,
+              elo: true,
+            },
+          },
+        },
+      },
+    },
+    take: 20,
+  })
+
+  return matches.map((match) => ({
+    id: match.id,
+    status: match.status,
+    maxPlayers: match.maxPlayers ?? 3,
+    createdAt: match.createdAt,
+    players: match.players.map((p) => ({
+      userId: p.userId,
+      user: p.user,
+    })),
+  }))
+}
diff --git a/lib/socket.ts b/lib/socket.ts
new file mode 100644
index 0000000..2b2b878
--- /dev/null
+++ b/lib/socket.ts
@@ -0,0 +1,12 @@
+import type { Server as IOServer } from "socket.io"
+
+declare global {
+  // eslint-disable-next-line no-var
+  var __cncSocketServer: IOServer | undefined
+}
+
+export const setSocketServer = (server: IOServer) => {
+  globalThis.__cncSocketServer = server
+}
+
+export const getSocketServer = () => globalThis.__cncSocketServer ?? null
diff --git a/package-lock.json b/package-lock.json
index 2c2ab86..909f89f 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -8,16 +8,22 @@
       "name": "compile-n-conquer",
       "version": "0.1.0",
       "dependencies": {
+        "@monaco-editor/react": "^4.7.0",
+        "@prisma/adapter-pg": "^7.3.0",
         "@prisma/client": "^7.3.0",
         "backboard-sdk": "^1.4.12",
         "bcryptjs": "^3.0.3",
         "clsx": "^2.1.1",
+        "firebase": "^12.9.0",
         "jsonwebtoken": "^9.0.3",
         "lucide-react": "^0.460.0",
         "next": "16.1.6",
+        "pg": "^8.18.0",
         "prisma": "^7.3.0",
         "react": "19.2.3",
         "react-dom": "19.2.3",
+        "socket.io": "^4.8.3",
+        "socket.io-client": "^4.8.3",
         "tailwind-merge": "^2.5.4",
         "tailwindcss-animate": "^1.0.7"
       },
@@ -78,7 +84,6 @@
       "integrity": "sha512-CGOfOJqWjg2qW/Mb6zNsDm+u5vFQ8DxXfbM09z69p5Z6+mE1ikP2jUXw+j42Pf1XTYED2Rni5f95npYeuwMDQA==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@babel/code-frame": "^7.29.0",
         "@babel/generator": "^7.29.0",
@@ -325,8 +330,7 @@
       "version": "0.3.15",
       "resolved": "https://registry.npmjs.org/@electric-sql/pglite/-/pglite-0.3.15.tgz",
       "integrity": "sha512-Cj++n1Mekf9ETfdc16TlDi+cDDQF0W7EcbyRHYOAeZdsAe8M/FJg18itDTSwyHfar2WIezawM9o0EKaRGVKygQ==",
-      "license": "Apache-2.0",
-      "peer": true
+      "license": "Apache-2.0"
     },
     "node_modules/@electric-sql/pglite-socket": {
       "version": "0.0.20",
@@ -526,6 +530,645 @@
         "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
       }
     },
+    "node_modules/@firebase/ai": {
+      "version": "2.8.0",
+      "resolved": "https://registry.npmjs.org/@firebase/ai/-/ai-2.8.0.tgz",
+      "integrity": "sha512-grWYGFPsSo+pt+6CYeKR0kWnUfoLLS3xgWPvNrhAS5EPxl6xWq7+HjDZqX24yLneETyl45AVgDsTbVgxeWeRfg==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@firebase/app-check-interop-types": "0.3.3",
+        "@firebase/component": "0.7.0",
+        "@firebase/logger": "0.5.0",
+        "@firebase/util": "1.13.0",
+        "tslib": "^2.1.0"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      },
+      "peerDependencies": {
+        "@firebase/app": "0.x",
+        "@firebase/app-types": "0.x"
+      }
+    },
+    "node_modules/@firebase/analytics": {
+      "version": "0.10.19",
+      "resolved": "https://registry.npmjs.org/@firebase/analytics/-/analytics-0.10.19.tgz",
+      "integrity": "sha512-3wU676fh60gaiVYQEEXsbGS4HbF2XsiBphyvvqDbtC1U4/dO4coshbYktcCHq+HFaGIK07iHOh4pME0hEq1fcg==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@firebase/component": "0.7.0",
+        "@firebase/installations": "0.6.19",
+        "@firebase/logger": "0.5.0",
+        "@firebase/util": "1.13.0",
+        "tslib": "^2.1.0"
+      },
+      "peerDependencies": {
+        "@firebase/app": "0.x"
+      }
+    },
+    "node_modules/@firebase/analytics-compat": {
+      "version": "0.2.25",
+      "resolved": "https://registry.npmjs.org/@firebase/analytics-compat/-/analytics-compat-0.2.25.tgz",
+      "integrity": "sha512-fdzoaG0BEKbqksRDhmf4JoyZf16Wosrl0Y7tbZtJyVDOOwziE0vrFjmZuTdviL0yhak+Nco6rMsUUbkbD+qb6Q==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@firebase/analytics": "0.10.19",
+        "@firebase/analytics-types": "0.8.3",
+        "@firebase/component": "0.7.0",
+        "@firebase/util": "1.13.0",
+        "tslib": "^2.1.0"
+      },
+      "peerDependencies": {
+        "@firebase/app-compat": "0.x"
+      }
+    },
+    "node_modules/@firebase/analytics-types": {
+      "version": "0.8.3",
+      "resolved": "https://registry.npmjs.org/@firebase/analytics-types/-/analytics-types-0.8.3.tgz",
+      "integrity": "sha512-VrIp/d8iq2g501qO46uGz3hjbDb8xzYMrbu8Tp0ovzIzrvJZ2fvmj649gTjge/b7cCCcjT0H37g1gVtlNhnkbg==",
+      "license": "Apache-2.0"
+    },
+    "node_modules/@firebase/app": {
+      "version": "0.14.8",
+      "resolved": "https://registry.npmjs.org/@firebase/app/-/app-0.14.8.tgz",
+      "integrity": "sha512-WiE9uCGRLUnShdjb9iP20sA3ToWrBbNXr14/N5mow7Nls9dmKgfGaGX5cynLvrltxq2OrDLh1VDNaUgsnS/k/g==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@firebase/component": "0.7.0",
+        "@firebase/logger": "0.5.0",
+        "@firebase/util": "1.13.0",
+        "idb": "7.1.1",
+        "tslib": "^2.1.0"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@firebase/app-check": {
+      "version": "0.11.0",
+      "resolved": "https://registry.npmjs.org/@firebase/app-check/-/app-check-0.11.0.tgz",
+      "integrity": "sha512-XAvALQayUMBJo58U/rxW02IhsesaxxfWVmVkauZvGEz3vOAjMEQnzFlyblqkc2iAaO82uJ2ZVyZv9XzPfxjJ6w==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@firebase/component": "0.7.0",
+        "@firebase/logger": "0.5.0",
+        "@firebase/util": "1.13.0",
+        "tslib": "^2.1.0"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      },
+      "peerDependencies": {
+        "@firebase/app": "0.x"
+      }
+    },
+    "node_modules/@firebase/app-check-compat": {
+      "version": "0.4.0",
+      "resolved": "https://registry.npmjs.org/@firebase/app-check-compat/-/app-check-compat-0.4.0.tgz",
+      "integrity": "sha512-UfK2Q8RJNjYM/8MFORltZRG9lJj11k0nW84rrffiKvcJxLf1jf6IEjCIkCamykHE73C6BwqhVfhIBs69GXQV0g==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@firebase/app-check": "0.11.0",
+        "@firebase/app-check-types": "0.5.3",
+        "@firebase/component": "0.7.0",
+        "@firebase/logger": "0.5.0",
+        "@firebase/util": "1.13.0",
+        "tslib": "^2.1.0"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      },
+      "peerDependencies": {
+        "@firebase/app-compat": "0.x"
+      }
+    },
+    "node_modules/@firebase/app-check-interop-types": {
+      "version": "0.3.3",
+      "resolved": "https://registry.npmjs.org/@firebase/app-check-interop-types/-/app-check-interop-types-0.3.3.tgz",
+      "integrity": "sha512-gAlxfPLT2j8bTI/qfe3ahl2I2YcBQ8cFIBdhAQA4I2f3TndcO+22YizyGYuttLHPQEpWkhmpFW60VCFEPg4g5A==",
+      "license": "Apache-2.0"
+    },
+    "node_modules/@firebase/app-check-types": {
+      "version": "0.5.3",
+      "resolved": "https://registry.npmjs.org/@firebase/app-check-types/-/app-check-types-0.5.3.tgz",
+      "integrity": "sha512-hyl5rKSj0QmwPdsAxrI5x1otDlByQ7bvNvVt8G/XPO2CSwE++rmSVf3VEhaeOR4J8ZFaF0Z0NDSmLejPweZ3ng==",
+      "license": "Apache-2.0"
+    },
+    "node_modules/@firebase/app-compat": {
+      "version": "0.5.8",
+      "resolved": "https://registry.npmjs.org/@firebase/app-compat/-/app-compat-0.5.8.tgz",
+      "integrity": "sha512-4De6SUZ36zozl9kh5rZSxKWULpgty27rMzZ6x+xkoo7+NWyhWyFdsdvhFsWhTw/9GGj0wXIcbTjwHYCUIUuHyg==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@firebase/app": "0.14.8",
+        "@firebase/component": "0.7.0",
+        "@firebase/logger": "0.5.0",
+        "@firebase/util": "1.13.0",
+        "tslib": "^2.1.0"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@firebase/app-types": {
+      "version": "0.9.3",
+      "resolved": "https://registry.npmjs.org/@firebase/app-types/-/app-types-0.9.3.tgz",
+      "integrity": "sha512-kRVpIl4vVGJ4baogMDINbyrIOtOxqhkZQg4jTq3l8Lw6WSk0xfpEYzezFu+Kl4ve4fbPl79dvwRtaFqAC/ucCw==",
+      "license": "Apache-2.0"
+    },
+    "node_modules/@firebase/auth": {
+      "version": "1.12.0",
+      "resolved": "https://registry.npmjs.org/@firebase/auth/-/auth-1.12.0.tgz",
+      "integrity": "sha512-zkvLpsrxynWHk07qGrUDfCSqKf4AvfZGEqJ7mVCtYGjNNDbGE71k0Yn84rg8QEZu4hQw1BC0qDEHzpNVBcSVmA==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@firebase/component": "0.7.0",
+        "@firebase/logger": "0.5.0",
+        "@firebase/util": "1.13.0",
+        "tslib": "^2.1.0"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      },
+      "peerDependencies": {
+        "@firebase/app": "0.x",
+        "@react-native-async-storage/async-storage": "^2.2.0"
+      },
+      "peerDependenciesMeta": {
+        "@react-native-async-storage/async-storage": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@firebase/auth-compat": {
+      "version": "0.6.2",
+      "resolved": "https://registry.npmjs.org/@firebase/auth-compat/-/auth-compat-0.6.2.tgz",
+      "integrity": "sha512-8UhCzF6pav9bw/eXA8Zy1QAKssPRYEYXaWagie1ewLTwHkXv6bKp/j6/IwzSYQP67sy/BMFXIFaCCsoXzFLr7A==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@firebase/auth": "1.12.0",
+        "@firebase/auth-types": "0.13.0",
+        "@firebase/component": "0.7.0",
+        "@firebase/util": "1.13.0",
+        "tslib": "^2.1.0"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      },
+      "peerDependencies": {
+        "@firebase/app-compat": "0.x"
+      }
+    },
+    "node_modules/@firebase/auth-interop-types": {
+      "version": "0.2.4",
+      "resolved": "https://registry.npmjs.org/@firebase/auth-interop-types/-/auth-interop-types-0.2.4.tgz",
+      "integrity": "sha512-JPgcXKCuO+CWqGDnigBtvo09HeBs5u/Ktc2GaFj2m01hLarbxthLNm7Fk8iOP1aqAtXV+fnnGj7U28xmk7IwVA==",
+      "license": "Apache-2.0"
+    },
+    "node_modules/@firebase/auth-types": {
+      "version": "0.13.0",
+      "resolved": "https://registry.npmjs.org/@firebase/auth-types/-/auth-types-0.13.0.tgz",
+      "integrity": "sha512-S/PuIjni0AQRLF+l9ck0YpsMOdE8GO2KU6ubmBB7P+7TJUCQDa3R1dlgYm9UzGbbePMZsp0xzB93f2b/CgxMOg==",
+      "license": "Apache-2.0",
+      "peerDependencies": {
+        "@firebase/app-types": "0.x",
+        "@firebase/util": "1.x"
+      }
+    },
+    "node_modules/@firebase/component": {
+      "version": "0.7.0",
+      "resolved": "https://registry.npmjs.org/@firebase/component/-/component-0.7.0.tgz",
+      "integrity": "sha512-wR9En2A+WESUHexjmRHkqtaVH94WLNKt6rmeqZhSLBybg4Wyf0Umk04SZsS6sBq4102ZsDBFwoqMqJYj2IoDSg==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@firebase/util": "1.13.0",
+        "tslib": "^2.1.0"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@firebase/data-connect": {
+      "version": "0.3.12",
+      "resolved": "https://registry.npmjs.org/@firebase/data-connect/-/data-connect-0.3.12.tgz",
+      "integrity": "sha512-baPddcoNLj/+vYo+HSJidJUdr5W4OkhT109c5qhR8T1dJoZcyJpkv/dFpYlw/VJ3dV66vI8GHQFrmAZw/xUS4g==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@firebase/auth-interop-types": "0.2.4",
+        "@firebase/component": "0.7.0",
+        "@firebase/logger": "0.5.0",
+        "@firebase/util": "1.13.0",
+        "tslib": "^2.1.0"
+      },
+      "peerDependencies": {
+        "@firebase/app": "0.x"
+      }
+    },
+    "node_modules/@firebase/database": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@firebase/database/-/database-1.1.0.tgz",
+      "integrity": "sha512-gM6MJFae3pTyNLoc9VcJNuaUDej0ctdjn3cVtILo3D5lpp0dmUHHLFN/pUKe7ImyeB1KAvRlEYxvIHNF04Filg==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@firebase/app-check-interop-types": "0.3.3",
+        "@firebase/auth-interop-types": "0.2.4",
+        "@firebase/component": "0.7.0",
+        "@firebase/logger": "0.5.0",
+        "@firebase/util": "1.13.0",
+        "faye-websocket": "0.11.4",
+        "tslib": "^2.1.0"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@firebase/database-compat": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/@firebase/database-compat/-/database-compat-2.1.0.tgz",
+      "integrity": "sha512-8nYc43RqxScsePVd1qe1xxvWNf0OBnbwHxmXJ7MHSuuTVYFO3eLyLW3PiCKJ9fHnmIz4p4LbieXwz+qtr9PZDg==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@firebase/component": "0.7.0",
+        "@firebase/database": "1.1.0",
+        "@firebase/database-types": "1.0.16",
+        "@firebase/logger": "0.5.0",
+        "@firebase/util": "1.13.0",
+        "tslib": "^2.1.0"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@firebase/database-types": {
+      "version": "1.0.16",
+      "resolved": "https://registry.npmjs.org/@firebase/database-types/-/database-types-1.0.16.tgz",
+      "integrity": "sha512-xkQLQfU5De7+SPhEGAXFBnDryUWhhlFXelEg2YeZOQMCdoe7dL64DDAd77SQsR+6uoXIZY5MB4y/inCs4GTfcw==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@firebase/app-types": "0.9.3",
+        "@firebase/util": "1.13.0"
+      }
+    },
+    "node_modules/@firebase/firestore": {
+      "version": "4.11.0",
+      "resolved": "https://registry.npmjs.org/@firebase/firestore/-/firestore-4.11.0.tgz",
+      "integrity": "sha512-Zb88s8rssBd0J2Tt+NUXMPt2sf+Dq7meatKiJf5t9oto1kZ8w9gK59Koe1uPVbaKfdgBp++N/z0I4G/HamyEhg==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@firebase/component": "0.7.0",
+        "@firebase/logger": "0.5.0",
+        "@firebase/util": "1.13.0",
+        "@firebase/webchannel-wrapper": "1.0.5",
+        "@grpc/grpc-js": "~1.9.0",
+        "@grpc/proto-loader": "^0.7.8",
+        "tslib": "^2.1.0"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      },
+      "peerDependencies": {
+        "@firebase/app": "0.x"
+      }
+    },
+    "node_modules/@firebase/firestore-compat": {
+      "version": "0.4.5",
+      "resolved": "https://registry.npmjs.org/@firebase/firestore-compat/-/firestore-compat-0.4.5.tgz",
+      "integrity": "sha512-yVX1CkVvqBI4qbA56uZo42xFA4TNU0ICQ+9AFDvYq9U9Xu6iAx9lFDAk/tN+NGereQQXXCSnpISwc/oxsQqPLA==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@firebase/component": "0.7.0",
+        "@firebase/firestore": "4.11.0",
+        "@firebase/firestore-types": "3.0.3",
+        "@firebase/util": "1.13.0",
+        "tslib": "^2.1.0"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      },
+      "peerDependencies": {
+        "@firebase/app-compat": "0.x"
+      }
+    },
+    "node_modules/@firebase/firestore-types": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/@firebase/firestore-types/-/firestore-types-3.0.3.tgz",
+      "integrity": "sha512-hD2jGdiWRxB/eZWF89xcK9gF8wvENDJkzpVFb4aGkzfEaKxVRD1kjz1t1Wj8VZEp2LCB53Yx1zD8mrhQu87R6Q==",
+      "license": "Apache-2.0",
+      "peerDependencies": {
+        "@firebase/app-types": "0.x",
+        "@firebase/util": "1.x"
+      }
+    },
+    "node_modules/@firebase/functions": {
+      "version": "0.13.1",
+      "resolved": "https://registry.npmjs.org/@firebase/functions/-/functions-0.13.1.tgz",
+      "integrity": "sha512-sUeWSb0rw5T+6wuV2o9XNmh9yHxjFI9zVGFnjFi+n7drTEWpl7ZTz1nROgGrSu472r+LAaj+2YaSicD4R8wfbw==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@firebase/app-check-interop-types": "0.3.3",
+        "@firebase/auth-interop-types": "0.2.4",
+        "@firebase/component": "0.7.0",
+        "@firebase/messaging-interop-types": "0.2.3",
+        "@firebase/util": "1.13.0",
+        "tslib": "^2.1.0"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      },
+      "peerDependencies": {
+        "@firebase/app": "0.x"
+      }
+    },
+    "node_modules/@firebase/functions-compat": {
+      "version": "0.4.1",
+      "resolved": "https://registry.npmjs.org/@firebase/functions-compat/-/functions-compat-0.4.1.tgz",
+      "integrity": "sha512-AxxUBXKuPrWaVNQ8o1cG1GaCAtXT8a0eaTDfqgS5VsRYLAR0ALcfqDLwo/QyijZj1w8Qf8n3Qrfy/+Im245hOQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@firebase/component": "0.7.0",
+        "@firebase/functions": "0.13.1",
+        "@firebase/functions-types": "0.6.3",
+        "@firebase/util": "1.13.0",
+        "tslib": "^2.1.0"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      },
+      "peerDependencies": {
+        "@firebase/app-compat": "0.x"
+      }
+    },
+    "node_modules/@firebase/functions-types": {
+      "version": "0.6.3",
+      "resolved": "https://registry.npmjs.org/@firebase/functions-types/-/functions-types-0.6.3.tgz",
+      "integrity": "sha512-EZoDKQLUHFKNx6VLipQwrSMh01A1SaL3Wg6Hpi//x6/fJ6Ee4hrAeswK99I5Ht8roiniKHw4iO0B1Oxj5I4plg==",
+      "license": "Apache-2.0"
+    },
+    "node_modules/@firebase/installations": {
+      "version": "0.6.19",
+      "resolved": "https://registry.npmjs.org/@firebase/installations/-/installations-0.6.19.tgz",
+      "integrity": "sha512-nGDmiwKLI1lerhwfwSHvMR9RZuIH5/8E3kgUWnVRqqL7kGVSktjLTWEMva7oh5yxQ3zXfIlIwJwMcaM5bK5j8Q==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@firebase/component": "0.7.0",
+        "@firebase/util": "1.13.0",
+        "idb": "7.1.1",
+        "tslib": "^2.1.0"
+      },
+      "peerDependencies": {
+        "@firebase/app": "0.x"
+      }
+    },
+    "node_modules/@firebase/installations-compat": {
+      "version": "0.2.19",
+      "resolved": "https://registry.npmjs.org/@firebase/installations-compat/-/installations-compat-0.2.19.tgz",
+      "integrity": "sha512-khfzIY3EI5LePePo7vT19/VEIH1E3iYsHknI/6ek9T8QCozAZshWT9CjlwOzZrKvTHMeNcbpo/VSOSIWDSjWdQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@firebase/component": "0.7.0",
+        "@firebase/installations": "0.6.19",
+        "@firebase/installations-types": "0.5.3",
+        "@firebase/util": "1.13.0",
+        "tslib": "^2.1.0"
+      },
+      "peerDependencies": {
+        "@firebase/app-compat": "0.x"
+      }
+    },
+    "node_modules/@firebase/installations-types": {
+      "version": "0.5.3",
+      "resolved": "https://registry.npmjs.org/@firebase/installations-types/-/installations-types-0.5.3.tgz",
+      "integrity": "sha512-2FJI7gkLqIE0iYsNQ1P751lO3hER+Umykel+TkLwHj6plzWVxqvfclPUZhcKFVQObqloEBTmpi2Ozn7EkCABAA==",
+      "license": "Apache-2.0",
+      "peerDependencies": {
+        "@firebase/app-types": "0.x"
+      }
+    },
+    "node_modules/@firebase/logger": {
+      "version": "0.5.0",
+      "resolved": "https://registry.npmjs.org/@firebase/logger/-/logger-0.5.0.tgz",
+      "integrity": "sha512-cGskaAvkrnh42b3BA3doDWeBmuHFO/Mx5A83rbRDYakPjO9bJtRL3dX7javzc2Rr/JHZf4HlterTW2lUkfeN4g==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "tslib": "^2.1.0"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@firebase/messaging": {
+      "version": "0.12.23",
+      "resolved": "https://registry.npmjs.org/@firebase/messaging/-/messaging-0.12.23.tgz",
+      "integrity": "sha512-cfuzv47XxqW4HH/OcR5rM+AlQd1xL/VhuaeW/wzMW1LFrsFcTn0GND/hak1vkQc2th8UisBcrkVcQAnOnKwYxg==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@firebase/component": "0.7.0",
+        "@firebase/installations": "0.6.19",
+        "@firebase/messaging-interop-types": "0.2.3",
+        "@firebase/util": "1.13.0",
+        "idb": "7.1.1",
+        "tslib": "^2.1.0"
+      },
+      "peerDependencies": {
+        "@firebase/app": "0.x"
+      }
+    },
+    "node_modules/@firebase/messaging-compat": {
+      "version": "0.2.23",
+      "resolved": "https://registry.npmjs.org/@firebase/messaging-compat/-/messaging-compat-0.2.23.tgz",
+      "integrity": "sha512-SN857v/kBUvlQ9X/UjAqBoQ2FEaL1ZozpnmL1ByTe57iXkmnVVFm9KqAsTfmf+OEwWI4kJJe9NObtN/w22lUgg==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@firebase/component": "0.7.0",
+        "@firebase/messaging": "0.12.23",
+        "@firebase/util": "1.13.0",
+        "tslib": "^2.1.0"
+      },
+      "peerDependencies": {
+        "@firebase/app-compat": "0.x"
+      }
+    },
+    "node_modules/@firebase/messaging-interop-types": {
+      "version": "0.2.3",
+      "resolved": "https://registry.npmjs.org/@firebase/messaging-interop-types/-/messaging-interop-types-0.2.3.tgz",
+      "integrity": "sha512-xfzFaJpzcmtDjycpDeCUj0Ge10ATFi/VHVIvEEjDNc3hodVBQADZ7BWQU7CuFpjSHE+eLuBI13z5F/9xOoGX8Q==",
+      "license": "Apache-2.0"
+    },
+    "node_modules/@firebase/performance": {
+      "version": "0.7.9",
+      "resolved": "https://registry.npmjs.org/@firebase/performance/-/performance-0.7.9.tgz",
+      "integrity": "sha512-UzybENl1EdM2I1sjYm74xGt/0JzRnU/0VmfMAKo2LSpHJzaj77FCLZXmYQ4oOuE+Pxtt8Wy2BVJEENiZkaZAzQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@firebase/component": "0.7.0",
+        "@firebase/installations": "0.6.19",
+        "@firebase/logger": "0.5.0",
+        "@firebase/util": "1.13.0",
+        "tslib": "^2.1.0",
+        "web-vitals": "^4.2.4"
+      },
+      "peerDependencies": {
+        "@firebase/app": "0.x"
+      }
+    },
+    "node_modules/@firebase/performance-compat": {
+      "version": "0.2.22",
+      "resolved": "https://registry.npmjs.org/@firebase/performance-compat/-/performance-compat-0.2.22.tgz",
+      "integrity": "sha512-xLKxaSAl/FVi10wDX/CHIYEUP13jXUjinL+UaNXT9ByIvxII5Ne5150mx6IgM8G6Q3V+sPiw9C8/kygkyHUVxg==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@firebase/component": "0.7.0",
+        "@firebase/logger": "0.5.0",
+        "@firebase/performance": "0.7.9",
+        "@firebase/performance-types": "0.2.3",
+        "@firebase/util": "1.13.0",
+        "tslib": "^2.1.0"
+      },
+      "peerDependencies": {
+        "@firebase/app-compat": "0.x"
+      }
+    },
+    "node_modules/@firebase/performance-types": {
+      "version": "0.2.3",
+      "resolved": "https://registry.npmjs.org/@firebase/performance-types/-/performance-types-0.2.3.tgz",
+      "integrity": "sha512-IgkyTz6QZVPAq8GSkLYJvwSLr3LS9+V6vNPQr0x4YozZJiLF5jYixj0amDtATf1X0EtYHqoPO48a9ija8GocxQ==",
+      "license": "Apache-2.0"
+    },
+    "node_modules/@firebase/remote-config": {
+      "version": "0.8.0",
+      "resolved": "https://registry.npmjs.org/@firebase/remote-config/-/remote-config-0.8.0.tgz",
+      "integrity": "sha512-sJz7C2VACeE257Z/3kY9Ap2WXbFsgsDLfaGfZmmToKAK39ipXxFan+vzB9CSbF6mP7bzjyzEnqPcMXhAnYE6fQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@firebase/component": "0.7.0",
+        "@firebase/installations": "0.6.19",
+        "@firebase/logger": "0.5.0",
+        "@firebase/util": "1.13.0",
+        "tslib": "^2.1.0"
+      },
+      "peerDependencies": {
+        "@firebase/app": "0.x"
+      }
+    },
+    "node_modules/@firebase/remote-config-compat": {
+      "version": "0.2.21",
+      "resolved": "https://registry.npmjs.org/@firebase/remote-config-compat/-/remote-config-compat-0.2.21.tgz",
+      "integrity": "sha512-9+lm0eUycxbu8GO25JfJe4s6R2xlDqlVt0CR6CvN9E6B4AFArEV4qfLoDVRgIEB7nHKwvH2nYRocPWfmjRQTnw==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@firebase/component": "0.7.0",
+        "@firebase/logger": "0.5.0",
+        "@firebase/remote-config": "0.8.0",
+        "@firebase/remote-config-types": "0.5.0",
+        "@firebase/util": "1.13.0",
+        "tslib": "^2.1.0"
+      },
+      "peerDependencies": {
+        "@firebase/app-compat": "0.x"
+      }
+    },
+    "node_modules/@firebase/remote-config-types": {
+      "version": "0.5.0",
+      "resolved": "https://registry.npmjs.org/@firebase/remote-config-types/-/remote-config-types-0.5.0.tgz",
+      "integrity": "sha512-vI3bqLoF14L/GchtgayMiFpZJF+Ao3uR8WCde0XpYNkSokDpAKca2DxvcfeZv7lZUqkUwQPL2wD83d3vQ4vvrg==",
+      "license": "Apache-2.0"
+    },
+    "node_modules/@firebase/storage": {
+      "version": "0.14.0",
+      "resolved": "https://registry.npmjs.org/@firebase/storage/-/storage-0.14.0.tgz",
+      "integrity": "sha512-xWWbb15o6/pWEw8H01UQ1dC5U3rf8QTAzOChYyCpafV6Xki7KVp3Yaw2nSklUwHEziSWE9KoZJS7iYeyqWnYFA==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@firebase/component": "0.7.0",
+        "@firebase/util": "1.13.0",
+        "tslib": "^2.1.0"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      },
+      "peerDependencies": {
+        "@firebase/app": "0.x"
+      }
+    },
+    "node_modules/@firebase/storage-compat": {
+      "version": "0.4.0",
+      "resolved": "https://registry.npmjs.org/@firebase/storage-compat/-/storage-compat-0.4.0.tgz",
+      "integrity": "sha512-vDzhgGczr1OfcOy285YAPur5pWDEvD67w4thyeCUh6Ys0izN9fNYtA1MJERmNBfqjqu0lg0FM5GLbw0Il21M+g==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@firebase/component": "0.7.0",
+        "@firebase/storage": "0.14.0",
+        "@firebase/storage-types": "0.8.3",
+        "@firebase/util": "1.13.0",
+        "tslib": "^2.1.0"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      },
+      "peerDependencies": {
+        "@firebase/app-compat": "0.x"
+      }
+    },
+    "node_modules/@firebase/storage-types": {
+      "version": "0.8.3",
+      "resolved": "https://registry.npmjs.org/@firebase/storage-types/-/storage-types-0.8.3.tgz",
+      "integrity": "sha512-+Muk7g9uwngTpd8xn9OdF/D48uiQ7I1Fae7ULsWPuKoCH3HU7bfFPhxtJYzyhjdniowhuDpQcfPmuNRAqZEfvg==",
+      "license": "Apache-2.0",
+      "peerDependencies": {
+        "@firebase/app-types": "0.x",
+        "@firebase/util": "1.x"
+      }
+    },
+    "node_modules/@firebase/util": {
+      "version": "1.13.0",
+      "resolved": "https://registry.npmjs.org/@firebase/util/-/util-1.13.0.tgz",
+      "integrity": "sha512-0AZUyYUfpMNcztR5l09izHwXkZpghLgCUaAGjtMwXnCg3bj4ml5VgiwqOMOxJ+Nw4qN/zJAaOQBcJ7KGkWStqQ==",
+      "hasInstallScript": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "tslib": "^2.1.0"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@firebase/webchannel-wrapper": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/@firebase/webchannel-wrapper/-/webchannel-wrapper-1.0.5.tgz",
+      "integrity": "sha512-+uGNN7rkfn41HLO0vekTFhTxk61eKa8mTpRGLO0QSqlQdKvIoGAvLp3ppdVIWbTGYJWM6Kp0iN+PjMIOcnVqTw==",
+      "license": "Apache-2.0"
+    },
+    "node_modules/@grpc/grpc-js": {
+      "version": "1.9.15",
+      "resolved": "https://registry.npmjs.org/@grpc/grpc-js/-/grpc-js-1.9.15.tgz",
+      "integrity": "sha512-nqE7Hc0AzI+euzUwDAy0aY5hCp10r734gMGRdU+qOPX0XSceI2ULrcXB5U2xSc5VkWwalCj4M7GzCAygZl2KoQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@grpc/proto-loader": "^0.7.8",
+        "@types/node": ">=12.12.47"
+      },
+      "engines": {
+        "node": "^8.13.0 || >=10.10.0"
+      }
+    },
+    "node_modules/@grpc/proto-loader": {
+      "version": "0.7.15",
+      "resolved": "https://registry.npmjs.org/@grpc/proto-loader/-/proto-loader-0.7.15.tgz",
+      "integrity": "sha512-tMXdRCfYVixjuFK+Hk0Q1s38gV9zDiDJfWL3h1rv4Qc39oILCu1TRTDt7+fGUI8K4G1Fj125Hx/ru3azECWTyQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "lodash.camelcase": "^4.3.0",
+        "long": "^5.0.0",
+        "protobufjs": "^7.2.5",
+        "yargs": "^17.7.2"
+      },
+      "bin": {
+        "proto-loader-gen-types": "build/bin/proto-loader-gen-types.js"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
     "node_modules/@hono/node-server": {
       "version": "1.19.9",
       "resolved": "https://registry.npmjs.org/@hono/node-server/-/node-server-1.19.9.tgz",
@@ -1106,6 +1749,29 @@
         "@jridgewell/sourcemap-codec": "^1.4.14"
       }
     },
+    "node_modules/@monaco-editor/loader": {
+      "version": "1.7.0",
+      "resolved": "https://registry.npmjs.org/@monaco-editor/loader/-/loader-1.7.0.tgz",
+      "integrity": "sha512-gIwR1HrJrrx+vfyOhYmCZ0/JcWqG5kbfG7+d3f/C1LXk2EvzAbHSg3MQ5lO2sMlo9izoAZ04shohfKLVT6crVA==",
+      "license": "MIT",
+      "dependencies": {
+        "state-local": "^1.0.6"
+      }
+    },
+    "node_modules/@monaco-editor/react": {
+      "version": "4.7.0",
+      "resolved": "https://registry.npmjs.org/@monaco-editor/react/-/react-4.7.0.tgz",
+      "integrity": "sha512-cyzXQCtO47ydzxpQtCGSQGOC8Gk3ZUeBXFAxD+CWXYFo5OqZyZUonFl0DwUlTyAfRHntBfw2p3w4s9R6oe1eCA==",
+      "license": "MIT",
+      "dependencies": {
+        "@monaco-editor/loader": "^1.5.0"
+      },
+      "peerDependencies": {
+        "monaco-editor": ">= 0.25.0 < 1",
+        "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0",
+        "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0"
+      }
+    },
     "node_modules/@mrleebo/prisma-ast": {
       "version": "0.13.1",
       "resolved": "https://registry.npmjs.org/@mrleebo/prisma-ast/-/prisma-ast-0.13.1.tgz",
@@ -1324,6 +1990,17 @@
         "node": ">=12.4.0"
       }
     },
+    "node_modules/@prisma/adapter-pg": {
+      "version": "7.3.0",
+      "resolved": "https://registry.npmjs.org/@prisma/adapter-pg/-/adapter-pg-7.3.0.tgz",
+      "integrity": "sha512-iuYQMbIPO6i9O45Fv8TB7vWu00BXhCaNAShenqF7gLExGDbnGp5BfFB4yz1K59zQ59jF6tQ9YHrg0P6/J3OoLg==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@prisma/driver-adapter-utils": "7.3.0",
+        "pg": "^8.16.3",
+        "postgres-array": "3.0.4"
+      }
+    },
     "node_modules/@prisma/client": {
       "version": "7.3.0",
       "resolved": "https://registry.npmjs.org/@prisma/client/-/client-7.3.0.tgz",
@@ -1397,6 +2074,15 @@
         "zeptomatch": "2.1.0"
       }
     },
+    "node_modules/@prisma/driver-adapter-utils": {
+      "version": "7.3.0",
+      "resolved": "https://registry.npmjs.org/@prisma/driver-adapter-utils/-/driver-adapter-utils-7.3.0.tgz",
+      "integrity": "sha512-Wdlezh1ck0Rq2dDINkfSkwbR53q53//Eo1vVqVLwtiZ0I6fuWDGNPxwq+SNAIHnsU+FD/m3aIJKevH3vF13U3w==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@prisma/debug": "7.3.0"
+      }
+    },
     "node_modules/@prisma/engines": {
       "version": "7.3.0",
       "resolved": "https://registry.npmjs.org/@prisma/engines/-/engines-7.3.0.tgz",
@@ -1477,6 +2163,70 @@
         "react-dom": "^18.0.0 || ^19.0.0"
       }
     },
+    "node_modules/@protobufjs/aspromise": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/@protobufjs/aspromise/-/aspromise-1.1.2.tgz",
+      "integrity": "sha512-j+gKExEuLmKwvz3OgROXtrJ2UG2x8Ch2YZUxahh+s1F2HZ+wAceUNLkvy6zKCPVRkU++ZWQrdxsUeQXmcg4uoQ==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@protobufjs/base64": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/@protobufjs/base64/-/base64-1.1.2.tgz",
+      "integrity": "sha512-AZkcAA5vnN/v4PDqKyMR5lx7hZttPDgClv83E//FMNhR2TMcLUhfRUBHCmSl0oi9zMgDDqRUJkSxO3wm85+XLg==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@protobufjs/codegen": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/@protobufjs/codegen/-/codegen-2.0.4.tgz",
+      "integrity": "sha512-YyFaikqM5sH0ziFZCN3xDC7zeGaB/d0IUb9CATugHWbd1FRFwWwt4ld4OYMPWu5a3Xe01mGAULCdqhMlPl29Jg==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@protobufjs/eventemitter": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@protobufjs/eventemitter/-/eventemitter-1.1.0.tgz",
+      "integrity": "sha512-j9ednRT81vYJ9OfVuXG6ERSTdEL1xVsNgqpkxMsbIabzSo3goCjDIveeGv5d03om39ML71RdmrGNjG5SReBP/Q==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@protobufjs/fetch": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@protobufjs/fetch/-/fetch-1.1.0.tgz",
+      "integrity": "sha512-lljVXpqXebpsijW71PZaCYeIcE5on1w5DlQy5WH6GLbFryLUrBD4932W/E2BSpfRJWseIL4v/KPgBFxDOIdKpQ==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "@protobufjs/aspromise": "^1.1.1",
+        "@protobufjs/inquire": "^1.1.0"
+      }
+    },
+    "node_modules/@protobufjs/float": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/@protobufjs/float/-/float-1.0.2.tgz",
+      "integrity": "sha512-Ddb+kVXlXst9d+R9PfTIxh1EdNkgoRe5tOX6t01f1lYWOvJnSPDBlG241QLzcyPdoNTsblLUdujGSE4RzrTZGQ==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@protobufjs/inquire": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@protobufjs/inquire/-/inquire-1.1.0.tgz",
+      "integrity": "sha512-kdSefcPdruJiFMVSbn801t4vFK7KB/5gd2fYvrxhuJYg8ILrmn9SKSX2tZdV6V+ksulWqS7aXjBcRXl3wHoD9Q==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@protobufjs/path": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/@protobufjs/path/-/path-1.1.2.tgz",
+      "integrity": "sha512-6JOcJ5Tm08dOHAbdR3GrvP+yUUfkjG5ePsHYczMFLq3ZmMkAD98cDgcT2iA1lJ9NVwFd4tH/iSSoe44YWkltEA==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@protobufjs/pool": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@protobufjs/pool/-/pool-1.1.0.tgz",
+      "integrity": "sha512-0kELaGSIDBKvcgS4zkjz1PeddatrjYcmMWOlAuAPwAeccUrPHdUqo/J6LiymHHEiJT5NrF1UVwxY14f+fy4WQw==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@protobufjs/utf8": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@protobufjs/utf8/-/utf8-1.1.0.tgz",
+      "integrity": "sha512-Vvn3zZrhQZkkBE8LSuW3em98c0FwgO4nxzv6OdSxPKJIEKY2bGbHn+mhGIPerzI4twdxaP8/0+06HBpwf345Lw==",
+      "license": "BSD-3-Clause"
+    },
     "node_modules/@rtsao/scc": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/@rtsao/scc/-/scc-1.1.0.tgz",
@@ -1484,6 +2234,12 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/@socket.io/component-emitter": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/@socket.io/component-emitter/-/component-emitter-3.1.2.tgz",
+      "integrity": "sha512-9BCxFwvbGg/RsZK9tjXd8s4UcwR0MWeFQ1XEKIQVVvAGJyINdrqKMcTRyLoK8Rse1GjzLV9cwjWV1olXRWEXVA==",
+      "license": "MIT"
+    },
     "node_modules/@standard-schema/spec": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/@standard-schema/spec/-/spec-1.1.0.tgz",
@@ -1788,6 +2544,15 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/@types/cors": {
+      "version": "2.8.19",
+      "resolved": "https://registry.npmjs.org/@types/cors/-/cors-2.8.19.tgz",
+      "integrity": "sha512-mFNylyeyqN93lfe/9CSxOGREz8cpzAhH+E93xJ4xWQf62V8sQ/24reV2nyzUWM6H6Xji+GGHpkbLe7pVoUEskg==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "*"
+      }
+    },
     "node_modules/@types/estree": {
       "version": "1.0.8",
       "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz",
@@ -1831,7 +2596,6 @@
       "version": "20.19.33",
       "resolved": "https://registry.npmjs.org/@types/node/-/node-20.19.33.tgz",
       "integrity": "sha512-Rs1bVAIdBs5gbTIKza/tgpMuG1k3U/UMJLWecIMxNdJFDMzcM5LOiLVRYh3PilWEYDIeUDv7bpiHPLPsbydGcw==",
-      "dev": true,
       "license": "MIT",
       "dependencies": {
         "undici-types": "~6.21.0"
@@ -1842,7 +2606,6 @@
       "resolved": "https://registry.npmjs.org/@types/react/-/react-19.2.13.tgz",
       "integrity": "sha512-KkiJeU6VbYbUOp5ITMIc7kBfqlYkKA5KhEHVrGMmUUMt7NeaZg65ojdPk+FtNrBAOXNVM5QM72jnADjM+XVRAQ==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "csstype": "^3.2.2"
       }
@@ -1857,6 +2620,14 @@
         "@types/react": "^19.2.0"
       }
     },
+    "node_modules/@types/trusted-types": {
+      "version": "2.0.7",
+      "resolved": "https://registry.npmjs.org/@types/trusted-types/-/trusted-types-2.0.7.tgz",
+      "integrity": "sha512-ScaPdn1dQczgbl0QFTeTOmVHFULt394XJgOQNoyVhZ6r2vLnMLJfBPd53SB52T/3G36VI1/g2MZaX0cwDuXsfw==",
+      "license": "MIT",
+      "optional": true,
+      "peer": true
+    },
     "node_modules/@typescript-eslint/eslint-plugin": {
       "version": "8.54.0",
       "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-8.54.0.tgz",
@@ -1902,7 +2673,6 @@
       "integrity": "sha512-BtE0k6cjwjLZoZixN0t5AKP0kSzlGu7FctRXYuPAm//aaiZhmfq1JwdYpYr1brzEspYyFeF+8XF5j2VK6oalrA==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@typescript-eslint/scope-manager": "8.54.0",
         "@typescript-eslint/types": "8.54.0",
@@ -2396,13 +3166,25 @@
         "win32"
       ]
     },
+    "node_modules/accepts": {
+      "version": "1.3.8",
+      "resolved": "https://registry.npmjs.org/accepts/-/accepts-1.3.8.tgz",
+      "integrity": "sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw==",
+      "license": "MIT",
+      "dependencies": {
+        "mime-types": "~2.1.34",
+        "negotiator": "0.6.3"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
     "node_modules/acorn": {
       "version": "8.15.0",
       "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.15.0.tgz",
       "integrity": "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "bin": {
         "acorn": "bin/acorn"
       },
@@ -2437,11 +3219,19 @@
         "url": "https://github.com/sponsors/epoberezkin"
       }
     },
+    "node_modules/ansi-regex": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
+      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/ansi-styles": {
       "version": "4.3.0",
       "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
       "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
-      "dev": true,
       "license": "MIT",
       "dependencies": {
         "color-convert": "^2.0.1"
@@ -2718,6 +3508,15 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/base64id": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/base64id/-/base64id-2.0.0.tgz",
+      "integrity": "sha512-lGe34o6EHj9y3Kts9R4ZYs/Gr+6N7MCaMlIFA3F1R2O5/m7K06AxfSeO5530PEERE6/WyEg3lsuyw4GHlPZHog==",
+      "license": "MIT",
+      "engines": {
+        "node": "^4.5.0 || >= 5.9"
+      }
+    },
     "node_modules/baseline-browser-mapping": {
       "version": "2.9.19",
       "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.9.19.tgz",
@@ -2780,7 +3579,6 @@
         }
       ],
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "baseline-browser-mapping": "^2.9.0",
         "caniuse-lite": "^1.0.30001759",
@@ -2969,6 +3767,20 @@
       "integrity": "sha512-IV3Ou0jSMzZrd3pZ48nLkT9DA7Ag1pnPzaiQhpW7c3RbcqqzvzzVu+L8gfqMp/8IM2MQtSiqaCxrrcfu8I8rMA==",
       "license": "MIT"
     },
+    "node_modules/cliui": {
+      "version": "8.0.1",
+      "resolved": "https://registry.npmjs.org/cliui/-/cliui-8.0.1.tgz",
+      "integrity": "sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==",
+      "license": "ISC",
+      "dependencies": {
+        "string-width": "^4.2.0",
+        "strip-ansi": "^6.0.1",
+        "wrap-ansi": "^7.0.0"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
     "node_modules/clsx": {
       "version": "2.1.1",
       "resolved": "https://registry.npmjs.org/clsx/-/clsx-2.1.1.tgz",
@@ -2982,7 +3794,6 @@
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
       "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
-      "dev": true,
       "license": "MIT",
       "dependencies": {
         "color-name": "~1.1.4"
@@ -2995,7 +3806,6 @@
       "version": "1.1.4",
       "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
       "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
-      "dev": true,
       "license": "MIT"
     },
     "node_modules/combined-stream": {
@@ -3039,6 +3849,32 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/cookie": {
+      "version": "0.7.2",
+      "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.7.2.tgz",
+      "integrity": "sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/cors": {
+      "version": "2.8.6",
+      "resolved": "https://registry.npmjs.org/cors/-/cors-2.8.6.tgz",
+      "integrity": "sha512-tJtZBBHA6vjIAaF6EnIaq6laBBP9aq/Y3ouVJjEfoHbRBcHBAHYcMh/w8LDrk2PvIMMq8gmopa5D4V8RmbrxGw==",
+      "license": "MIT",
+      "dependencies": {
+        "object-assign": "^4",
+        "vary": "^1"
+      },
+      "engines": {
+        "node": ">= 0.10"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
     "node_modules/cross-spawn": {
       "version": "7.0.6",
       "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",
@@ -3133,7 +3969,6 @@
       "version": "4.4.3",
       "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
       "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
-      "dev": true,
       "license": "MIT",
       "dependencies": {
         "ms": "^2.1.3"
@@ -3252,6 +4087,16 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/dompurify": {
+      "version": "3.2.7",
+      "resolved": "https://registry.npmjs.org/dompurify/-/dompurify-3.2.7.tgz",
+      "integrity": "sha512-WhL/YuveyGXJaerVlMYGWhvQswa7myDG17P7Vu65EWC05o8vfeNbvNf4d/BOvH99+ZW+LlQsc1GDKMa1vNK6dw==",
+      "license": "(MPL-2.0 OR Apache-2.0)",
+      "peer": true,
+      "optionalDependencies": {
+        "@types/trusted-types": "^2.0.7"
+      }
+    },
     "node_modules/dotenv": {
       "version": "16.6.1",
       "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-16.6.1.tgz",
@@ -3320,6 +4165,48 @@
         "node": ">=14"
       }
     },
+    "node_modules/engine.io": {
+      "version": "6.6.5",
+      "resolved": "https://registry.npmjs.org/engine.io/-/engine.io-6.6.5.tgz",
+      "integrity": "sha512-2RZdgEbXmp5+dVbRm0P7HQUImZpICccJy7rN7Tv+SFa55pH+lxnuw6/K1ZxxBfHoYpSkHLAO92oa8O4SwFXA2A==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/cors": "^2.8.12",
+        "@types/node": ">=10.0.0",
+        "accepts": "~1.3.4",
+        "base64id": "2.0.0",
+        "cookie": "~0.7.2",
+        "cors": "~2.8.5",
+        "debug": "~4.4.1",
+        "engine.io-parser": "~5.2.1",
+        "ws": "~8.18.3"
+      },
+      "engines": {
+        "node": ">=10.2.0"
+      }
+    },
+    "node_modules/engine.io-client": {
+      "version": "6.6.4",
+      "resolved": "https://registry.npmjs.org/engine.io-client/-/engine.io-client-6.6.4.tgz",
+      "integrity": "sha512-+kjUJnZGwzewFDw951CDWcwj35vMNf2fcj7xQWOctq1F2i1jkDdVvdFG9kM/BEChymCH36KgjnW0NsL58JYRxw==",
+      "license": "MIT",
+      "dependencies": {
+        "@socket.io/component-emitter": "~3.1.0",
+        "debug": "~4.4.1",
+        "engine.io-parser": "~5.2.1",
+        "ws": "~8.18.3",
+        "xmlhttprequest-ssl": "~2.1.1"
+      }
+    },
+    "node_modules/engine.io-parser": {
+      "version": "5.2.3",
+      "resolved": "https://registry.npmjs.org/engine.io-parser/-/engine.io-parser-5.2.3.tgz",
+      "integrity": "sha512-HqD3yTBfnBxIrbnM1DoD6Pcq8NECnh8d4As1Qgh0z5Gg3jRRIqijury0CL3ghu/edArpUYiYqQiDUQBIs4np3Q==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=10.0.0"
+      }
+    },
     "node_modules/enhanced-resolve": {
       "version": "5.19.0",
       "resolved": "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-5.19.0.tgz",
@@ -3511,7 +4398,6 @@
       "version": "3.2.0",
       "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
       "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
-      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">=6"
@@ -3536,7 +4422,6 @@
       "integrity": "sha512-LEyamqS7W5HB3ujJyvi0HQK/dtVINZvd5mAAp9eT5S/ujByGjiZLCzPcHVzuXbpJDJF/cxwHlfceVUDZ2lnSTw==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@eslint-community/eslint-utils": "^4.8.0",
         "@eslint-community/regexpp": "^4.12.1",
@@ -3722,7 +4607,6 @@
       "integrity": "sha512-whOE1HFo/qJDyX4SnXzP4N6zOWn79WhnCUY/iDR0mPfQZO8wcYE4JClzI2oZrhBnnMUCBCHZhO6VQyoBU95mZA==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@rtsao/scc": "^1.1.0",
         "array-includes": "^3.1.9",
@@ -4045,6 +4929,18 @@
         "reusify": "^1.0.4"
       }
     },
+    "node_modules/faye-websocket": {
+      "version": "0.11.4",
+      "resolved": "https://registry.npmjs.org/faye-websocket/-/faye-websocket-0.11.4.tgz",
+      "integrity": "sha512-CzbClwlXAuiRQAlUyfqPgvPoNKTckTPGfwZV4ZdAhVcP2lh9KUxJg2b5GkE7XbjKQ3YJnQ9z6D9ntLAlB+tP8g==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "websocket-driver": ">=0.5.1"
+      },
+      "engines": {
+        "node": ">=0.8.0"
+      }
+    },
     "node_modules/fetch-blob": {
       "version": "3.2.0",
       "resolved": "https://registry.npmjs.org/fetch-blob/-/fetch-blob-3.2.0.tgz",
@@ -4111,6 +5007,42 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/firebase": {
+      "version": "12.9.0",
+      "resolved": "https://registry.npmjs.org/firebase/-/firebase-12.9.0.tgz",
+      "integrity": "sha512-CwwTYoqZg6KxygPOaaJqIc4aoLvo0RCRrXoln9GoxLE8QyAwTydBaSLGVlR4WPcuOgN3OEL0tJLT1H4IU/dv7w==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@firebase/ai": "2.8.0",
+        "@firebase/analytics": "0.10.19",
+        "@firebase/analytics-compat": "0.2.25",
+        "@firebase/app": "0.14.8",
+        "@firebase/app-check": "0.11.0",
+        "@firebase/app-check-compat": "0.4.0",
+        "@firebase/app-compat": "0.5.8",
+        "@firebase/app-types": "0.9.3",
+        "@firebase/auth": "1.12.0",
+        "@firebase/auth-compat": "0.6.2",
+        "@firebase/data-connect": "0.3.12",
+        "@firebase/database": "1.1.0",
+        "@firebase/database-compat": "2.1.0",
+        "@firebase/firestore": "4.11.0",
+        "@firebase/firestore-compat": "0.4.5",
+        "@firebase/functions": "0.13.1",
+        "@firebase/functions-compat": "0.4.1",
+        "@firebase/installations": "0.6.19",
+        "@firebase/installations-compat": "0.2.19",
+        "@firebase/messaging": "0.12.23",
+        "@firebase/messaging-compat": "0.2.23",
+        "@firebase/performance": "0.7.9",
+        "@firebase/performance-compat": "0.2.22",
+        "@firebase/remote-config": "0.8.0",
+        "@firebase/remote-config-compat": "0.2.21",
+        "@firebase/storage": "0.14.0",
+        "@firebase/storage-compat": "0.4.0",
+        "@firebase/util": "1.13.0"
+      }
+    },
     "node_modules/flat-cache": {
       "version": "4.0.1",
       "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-4.0.1.tgz",
@@ -4261,6 +5193,15 @@
         "node": ">=6.9.0"
       }
     },
+    "node_modules/get-caller-file": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz",
+      "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==",
+      "license": "ISC",
+      "engines": {
+        "node": "6.* || 8.* || >= 10.*"
+      }
+    },
     "node_modules/get-intrinsic": {
       "version": "1.3.0",
       "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz",
@@ -4537,11 +5478,16 @@
       "resolved": "https://registry.npmjs.org/hono/-/hono-4.11.4.tgz",
       "integrity": "sha512-U7tt8JsyrxSRKspfhtLET79pU8K+tInj5QZXs1jSugO1Vq5dFj3kmZsRldo29mTBfcjDRVRXrEZ6LS63Cog9ZA==",
       "license": "MIT",
-      "peer": true,
       "engines": {
         "node": ">=16.9.0"
       }
     },
+    "node_modules/http-parser-js": {
+      "version": "0.5.10",
+      "resolved": "https://registry.npmjs.org/http-parser-js/-/http-parser-js-0.5.10.tgz",
+      "integrity": "sha512-Pysuw9XpUq5dVc/2SMHpuTY01RFl8fttgcyunjL7eEMhGM3cI4eOmiCycJDVCo/7O7ClfQD3SaI6ftDzqOXYMA==",
+      "license": "MIT"
+    },
     "node_modules/http-status-codes": {
       "version": "2.3.0",
       "resolved": "https://registry.npmjs.org/http-status-codes/-/http-status-codes-2.3.0.tgz",
@@ -4564,6 +5510,12 @@
         "url": "https://opencollective.com/express"
       }
     },
+    "node_modules/idb": {
+      "version": "7.1.1",
+      "resolved": "https://registry.npmjs.org/idb/-/idb-7.1.1.tgz",
+      "integrity": "sha512-gchesWBzyvGHRO9W8tzUWFDycow5gwjvFKfyV9FF32Y7F50yZMp7mP+T2mJIWFx49zicqyC4uefHM17o6xKIVQ==",
+      "license": "ISC"
+    },
     "node_modules/ignore": {
       "version": "5.3.2",
       "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz",
@@ -4800,6 +5752,15 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/is-fullwidth-code-point": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
+      "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/is-generator-function": {
       "version": "1.1.2",
       "resolved": "https://registry.npmjs.org/is-generator-function/-/is-generator-function-1.1.2.tgz",
@@ -5551,6 +6512,12 @@
       "integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==",
       "license": "MIT"
     },
+    "node_modules/lodash.camelcase": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/lodash.camelcase/-/lodash.camelcase-4.3.0.tgz",
+      "integrity": "sha512-TwuEnCnxbc3rAvhf/LbG7tJUDzhqXyFnv3dtzLOPgCG/hODL7WFnsbwktkD7yUV0RrreP/l1PALq/YSg6VvjlA==",
+      "license": "MIT"
+    },
     "node_modules/lodash.includes": {
       "version": "4.3.0",
       "resolved": "https://registry.npmjs.org/lodash.includes/-/lodash.includes-4.3.0.tgz",
@@ -5663,6 +6630,19 @@
         "@jridgewell/sourcemap-codec": "^1.5.5"
       }
     },
+    "node_modules/marked": {
+      "version": "14.0.0",
+      "resolved": "https://registry.npmjs.org/marked/-/marked-14.0.0.tgz",
+      "integrity": "sha512-uIj4+faQ+MgHgwUW1l2PsPglZLOLOT1uErt06dAPtx2kjteLAkbsd/0FiYg/MGS+i7ZKLb7w2WClxHkzOOuryQ==",
+      "license": "MIT",
+      "peer": true,
+      "bin": {
+        "marked": "bin/marked.js"
+      },
+      "engines": {
+        "node": ">= 18"
+      }
+    },
     "node_modules/math-intrinsics": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
@@ -5740,6 +6720,17 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/monaco-editor": {
+      "version": "0.55.1",
+      "resolved": "https://registry.npmjs.org/monaco-editor/-/monaco-editor-0.55.1.tgz",
+      "integrity": "sha512-jz4x+TJNFHwHtwuV9vA9rMujcZRb0CEilTEwG2rRSpe/A7Jdkuj8xPKttCgOh+v/lkHy7HsZ64oj+q3xoAFl9A==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "dompurify": "3.2.7",
+        "marked": "14.0.0"
+      }
+    },
     "node_modules/ms": {
       "version": "2.1.3",
       "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
@@ -5819,6 +6810,15 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/negotiator": {
+      "version": "0.6.3",
+      "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-0.6.3.tgz",
+      "integrity": "sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
     "node_modules/next": {
       "version": "16.1.6",
       "resolved": "https://registry.npmjs.org/next/-/next-16.1.6.tgz",
@@ -5978,7 +6978,6 @@
       "version": "4.1.1",
       "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz",
       "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==",
-      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">=0.10.0"
@@ -6222,6 +7221,104 @@
       "integrity": "sha512-xCy9V055GLEqoFaHoC1SoLIaLmWctgCUaBaWxDZ7/Zx4CTyX7cJQLJOok/orfjZAh9kEYpjJa4d0KcJmCbctZA==",
       "license": "MIT"
     },
+    "node_modules/pg": {
+      "version": "8.18.0",
+      "resolved": "https://registry.npmjs.org/pg/-/pg-8.18.0.tgz",
+      "integrity": "sha512-xqrUDL1b9MbkydY/s+VZ6v+xiMUmOUk7SS9d/1kpyQxoJ6U9AO1oIJyUWVZojbfe5Cc/oluutcgFG4L9RDP1iQ==",
+      "license": "MIT",
+      "dependencies": {
+        "pg-connection-string": "^2.11.0",
+        "pg-pool": "^3.11.0",
+        "pg-protocol": "^1.11.0",
+        "pg-types": "2.2.0",
+        "pgpass": "1.0.5"
+      },
+      "engines": {
+        "node": ">= 16.0.0"
+      },
+      "optionalDependencies": {
+        "pg-cloudflare": "^1.3.0"
+      },
+      "peerDependencies": {
+        "pg-native": ">=3.0.1"
+      },
+      "peerDependenciesMeta": {
+        "pg-native": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/pg-cloudflare": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/pg-cloudflare/-/pg-cloudflare-1.3.0.tgz",
+      "integrity": "sha512-6lswVVSztmHiRtD6I8hw4qP/nDm1EJbKMRhf3HCYaqud7frGysPv7FYJ5noZQdhQtN2xJnimfMtvQq21pdbzyQ==",
+      "license": "MIT",
+      "optional": true
+    },
+    "node_modules/pg-connection-string": {
+      "version": "2.11.0",
+      "resolved": "https://registry.npmjs.org/pg-connection-string/-/pg-connection-string-2.11.0.tgz",
+      "integrity": "sha512-kecgoJwhOpxYU21rZjULrmrBJ698U2RxXofKVzOn5UDj61BPj/qMb7diYUR1nLScCDbrztQFl1TaQZT0t1EtzQ==",
+      "license": "MIT"
+    },
+    "node_modules/pg-int8": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/pg-int8/-/pg-int8-1.0.1.tgz",
+      "integrity": "sha512-WCtabS6t3c8SkpDBUlb1kjOs7l66xsGdKpIPZsg4wR+B3+u9UAum2odSsF9tnvxg80h4ZxLWMy4pRjOsFIqQpw==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=4.0.0"
+      }
+    },
+    "node_modules/pg-pool": {
+      "version": "3.11.0",
+      "resolved": "https://registry.npmjs.org/pg-pool/-/pg-pool-3.11.0.tgz",
+      "integrity": "sha512-MJYfvHwtGp870aeusDh+hg9apvOe2zmpZJpyt+BMtzUWlVqbhFmMK6bOBXLBUPd7iRtIF9fZplDc7KrPN3PN7w==",
+      "license": "MIT",
+      "peerDependencies": {
+        "pg": ">=8.0"
+      }
+    },
+    "node_modules/pg-protocol": {
+      "version": "1.11.0",
+      "resolved": "https://registry.npmjs.org/pg-protocol/-/pg-protocol-1.11.0.tgz",
+      "integrity": "sha512-pfsxk2M9M3BuGgDOfuy37VNRRX3jmKgMjcvAcWqNDpZSf4cUmv8HSOl5ViRQFsfARFn0KuUQTgLxVMbNq5NW3g==",
+      "license": "MIT"
+    },
+    "node_modules/pg-types": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/pg-types/-/pg-types-2.2.0.tgz",
+      "integrity": "sha512-qTAAlrEsl8s4OiEQY69wDvcMIdQN6wdz5ojQiOy6YRMuynxenON0O5oCpJI6lshc6scgAY8qvJ2On/p+CXY0GA==",
+      "license": "MIT",
+      "dependencies": {
+        "pg-int8": "1.0.1",
+        "postgres-array": "~2.0.0",
+        "postgres-bytea": "~1.0.0",
+        "postgres-date": "~1.0.4",
+        "postgres-interval": "^1.1.0"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/pg-types/node_modules/postgres-array": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/postgres-array/-/postgres-array-2.0.0.tgz",
+      "integrity": "sha512-VpZrUqU5A69eQyW2c5CA1jtLecCsN2U/bD6VilrFDWq5+5UIEVO7nazS3TEcHf1zuPYO/sqGvUvW62g86RXZuA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/pgpass": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/pgpass/-/pgpass-1.0.5.tgz",
+      "integrity": "sha512-FdW9r/jQZhSeohs1Z3sI1yxFQNFvMcnmfuj4WBMUTxOrAyLMaTcE1aAMBiTlbMNaXvBCQuVi0R7hd8udDSP7ug==",
+      "license": "MIT",
+      "dependencies": {
+        "split2": "^4.1.0"
+      }
+    },
     "node_modules/picocolors": {
       "version": "1.1.1",
       "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
@@ -6304,6 +7401,45 @@
         "url": "https://github.com/sponsors/porsager"
       }
     },
+    "node_modules/postgres-array": {
+      "version": "3.0.4",
+      "resolved": "https://registry.npmjs.org/postgres-array/-/postgres-array-3.0.4.tgz",
+      "integrity": "sha512-nAUSGfSDGOaOAEGwqsRY27GPOea7CNipJPOA7lPbdEpx5Kg3qzdP0AaWC5MlhTWV9s4hFX39nomVZ+C4tnGOJQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/postgres-bytea": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/postgres-bytea/-/postgres-bytea-1.0.1.tgz",
+      "integrity": "sha512-5+5HqXnsZPE65IJZSMkZtURARZelel2oXUEO8rH83VS/hxH5vv1uHquPg5wZs8yMAfdv971IU+kcPUczi7NVBQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/postgres-date": {
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/postgres-date/-/postgres-date-1.0.7.tgz",
+      "integrity": "sha512-suDmjLVQg78nMK2UZ454hAG+OAW+HQPZ6n++TNDUX+L0+uUlLywnoxJKDou51Zm+zTCjrCl0Nq6J9C5hP9vK/Q==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/postgres-interval": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/postgres-interval/-/postgres-interval-1.2.0.tgz",
+      "integrity": "sha512-9ZhXKM/rw350N1ovuWHbGxnGh/SNJ4cnxHiM0rxE4VN41wsg8P8zWn9hv/buK00RP4WvlOyr/RBDiptyxVbkZQ==",
+      "license": "MIT",
+      "dependencies": {
+        "xtend": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
     "node_modules/prelude-ls": {
       "version": "1.2.1",
       "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz",
@@ -6320,7 +7456,6 @@
       "integrity": "sha512-ApYSOLHfMN8WftJA+vL6XwAPOh/aZ0BgUyyKPwUFgjARmG6EBI9LzDPf6SWULQMSAxydV9qn5gLj037nPNlg2w==",
       "hasInstallScript": true,
       "license": "Apache-2.0",
-      "peer": true,
       "dependencies": {
         "@prisma/config": "7.3.0",
         "@prisma/dev": "0.20.0",
@@ -6377,6 +7512,30 @@
       "integrity": "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==",
       "license": "ISC"
     },
+    "node_modules/protobufjs": {
+      "version": "7.5.4",
+      "resolved": "https://registry.npmjs.org/protobufjs/-/protobufjs-7.5.4.tgz",
+      "integrity": "sha512-CvexbZtbov6jW2eXAvLukXjXUW1TzFaivC46BpWc/3BpcCysb5Vffu+B3XHMm8lVEuy2Mm4XGex8hBSg1yapPg==",
+      "hasInstallScript": true,
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "@protobufjs/aspromise": "^1.1.2",
+        "@protobufjs/base64": "^1.1.2",
+        "@protobufjs/codegen": "^2.0.4",
+        "@protobufjs/eventemitter": "^1.1.0",
+        "@protobufjs/fetch": "^1.1.0",
+        "@protobufjs/float": "^1.0.2",
+        "@protobufjs/inquire": "^1.1.0",
+        "@protobufjs/path": "^1.1.2",
+        "@protobufjs/pool": "^1.1.0",
+        "@protobufjs/utf8": "^1.1.0",
+        "@types/node": ">=13.7.0",
+        "long": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=12.0.0"
+      }
+    },
     "node_modules/punycode": {
       "version": "2.3.1",
       "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz",
@@ -6439,7 +7598,6 @@
       "resolved": "https://registry.npmjs.org/react/-/react-19.2.3.tgz",
       "integrity": "sha512-Ku/hhYbVjOQnXDZFv2+RibmLFGwFdeeKHFcOTlrt7xplBnya5OGn/hIRDsqDiSUcfORsDC7MPxwork8jBwsIWA==",
       "license": "MIT",
-      "peer": true,
       "engines": {
         "node": ">=0.10.0"
       }
@@ -6449,7 +7607,6 @@
       "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-19.2.3.tgz",
       "integrity": "sha512-yELu4WmLPw5Mr/lmeEpox5rw3RETacE++JgHqQzd2dg+YbJuat3jH4ingc+WPZhxaoFzdv9y33G+F7Nl5O0GBg==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "scheduler": "^0.27.0"
       },
@@ -6536,6 +7693,15 @@
         "url": "https://github.com/sponsors/remeda"
       }
     },
+    "node_modules/require-directory": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz",
+      "integrity": "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
     "node_modules/resolve": {
       "version": "1.22.11",
       "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.11.tgz",
@@ -6939,6 +8105,62 @@
         "url": "https://github.com/sponsors/isaacs"
       }
     },
+    "node_modules/socket.io": {
+      "version": "4.8.3",
+      "resolved": "https://registry.npmjs.org/socket.io/-/socket.io-4.8.3.tgz",
+      "integrity": "sha512-2Dd78bqzzjE6KPkD5fHZmDAKRNe3J15q+YHDrIsy9WEkqttc7GY+kT9OBLSMaPbQaEd0x1BjcmtMtXkfpc+T5A==",
+      "license": "MIT",
+      "dependencies": {
+        "accepts": "~1.3.4",
+        "base64id": "~2.0.0",
+        "cors": "~2.8.5",
+        "debug": "~4.4.1",
+        "engine.io": "~6.6.0",
+        "socket.io-adapter": "~2.5.2",
+        "socket.io-parser": "~4.2.4"
+      },
+      "engines": {
+        "node": ">=10.2.0"
+      }
+    },
+    "node_modules/socket.io-adapter": {
+      "version": "2.5.6",
+      "resolved": "https://registry.npmjs.org/socket.io-adapter/-/socket.io-adapter-2.5.6.tgz",
+      "integrity": "sha512-DkkO/dz7MGln0dHn5bmN3pPy+JmywNICWrJqVWiVOyvXjWQFIv9c2h24JrQLLFJ2aQVQf/Cvl1vblnd4r2apLQ==",
+      "license": "MIT",
+      "dependencies": {
+        "debug": "~4.4.1",
+        "ws": "~8.18.3"
+      }
+    },
+    "node_modules/socket.io-client": {
+      "version": "4.8.3",
+      "resolved": "https://registry.npmjs.org/socket.io-client/-/socket.io-client-4.8.3.tgz",
+      "integrity": "sha512-uP0bpjWrjQmUt5DTHq9RuoCBdFJF10cdX9X+a368j/Ft0wmaVgxlrjvK3kjvgCODOMMOz9lcaRzxmso0bTWZ/g==",
+      "license": "MIT",
+      "dependencies": {
+        "@socket.io/component-emitter": "~3.1.0",
+        "debug": "~4.4.1",
+        "engine.io-client": "~6.6.1",
+        "socket.io-parser": "~4.2.4"
+      },
+      "engines": {
+        "node": ">=10.0.0"
+      }
+    },
+    "node_modules/socket.io-parser": {
+      "version": "4.2.5",
+      "resolved": "https://registry.npmjs.org/socket.io-parser/-/socket.io-parser-4.2.5.tgz",
+      "integrity": "sha512-bPMmpy/5WWKHea5Y/jYAP6k74A+hvmRCQaJuJB6I/ML5JZq/KfNieUVo/3Mh7SAqn7TyFdIo6wqYHInG1MU1bQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@socket.io/component-emitter": "~3.1.0",
+        "debug": "~4.4.1"
+      },
+      "engines": {
+        "node": ">=10.0.0"
+      }
+    },
     "node_modules/source-map-js": {
       "version": "1.2.1",
       "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
@@ -6948,6 +8170,15 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/split2": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/split2/-/split2-4.2.0.tgz",
+      "integrity": "sha512-UcjcJOWknrNkF6PLX83qcHM6KHgVKNkV62Y8a5uYDVv9ydGQVwAHMKqHdJje1VTWpljG0WYpCDhrCdAOYH4TWg==",
+      "license": "ISC",
+      "engines": {
+        "node": ">= 10.x"
+      }
+    },
     "node_modules/sqlstring": {
       "version": "2.3.3",
       "resolved": "https://registry.npmjs.org/sqlstring/-/sqlstring-2.3.3.tgz",
@@ -6964,6 +8195,12 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/state-local": {
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/state-local/-/state-local-1.0.7.tgz",
+      "integrity": "sha512-HTEHMNieakEnoe33shBYcZ7NX83ACUjCu8c40iOGEZsngj9zRnkqS9j1pqQPXwobB0ZcVTk27REb7COQ0UR59w==",
+      "license": "MIT"
+    },
     "node_modules/std-env": {
       "version": "3.10.0",
       "resolved": "https://registry.npmjs.org/std-env/-/std-env-3.10.0.tgz",
@@ -6984,6 +8221,26 @@
         "node": ">= 0.4"
       }
     },
+    "node_modules/string-width": {
+      "version": "4.2.3",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
+      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
+      "license": "MIT",
+      "dependencies": {
+        "emoji-regex": "^8.0.0",
+        "is-fullwidth-code-point": "^3.0.0",
+        "strip-ansi": "^6.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/string-width/node_modules/emoji-regex": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
+      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
+      "license": "MIT"
+    },
     "node_modules/string.prototype.includes": {
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/string.prototype.includes/-/string.prototype.includes-2.0.1.tgz",
@@ -7097,6 +8354,18 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/strip-ansi": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
+      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
+      "license": "MIT",
+      "dependencies": {
+        "ansi-regex": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/strip-bom": {
       "version": "3.0.0",
       "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz",
@@ -7183,8 +8452,7 @@
       "version": "4.1.18",
       "resolved": "https://registry.npmjs.org/tailwindcss/-/tailwindcss-4.1.18.tgz",
       "integrity": "sha512-4+Z+0yiYyEtUVCScyfHCxOYP06L5Ne+JiHhY2IjR2KWMIWhJOYZKLSGZaP5HkZ8+bY0cxfzwDE5uOmzFXyIwxw==",
-      "license": "MIT",
-      "peer": true
+      "license": "MIT"
     },
     "node_modules/tailwindcss-animate": {
       "version": "1.0.7",
@@ -7259,7 +8527,6 @@
       "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "engines": {
         "node": ">=12"
       },
@@ -7422,7 +8689,6 @@
       "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
       "devOptional": true,
       "license": "Apache-2.0",
-      "peer": true,
       "bin": {
         "tsc": "bin/tsc",
         "tsserver": "bin/tsserver"
@@ -7478,7 +8744,6 @@
       "version": "6.21.0",
       "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz",
       "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==",
-      "dev": true,
       "license": "MIT"
     },
     "node_modules/unrs-resolver": {
@@ -7571,6 +8836,15 @@
         }
       }
     },
+    "node_modules/vary": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/vary/-/vary-1.1.2.tgz",
+      "integrity": "sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
     "node_modules/web-streams-polyfill": {
       "version": "3.3.3",
       "resolved": "https://registry.npmjs.org/web-streams-polyfill/-/web-streams-polyfill-3.3.3.tgz",
@@ -7580,6 +8854,35 @@
         "node": ">= 8"
       }
     },
+    "node_modules/web-vitals": {
+      "version": "4.2.4",
+      "resolved": "https://registry.npmjs.org/web-vitals/-/web-vitals-4.2.4.tgz",
+      "integrity": "sha512-r4DIlprAGwJ7YM11VZp4R884m0Vmgr6EAKe3P+kO0PPj3Unqyvv59rczf6UiGcb9Z8QxZVcqKNwv/g0WNdWwsw==",
+      "license": "Apache-2.0"
+    },
+    "node_modules/websocket-driver": {
+      "version": "0.7.4",
+      "resolved": "https://registry.npmjs.org/websocket-driver/-/websocket-driver-0.7.4.tgz",
+      "integrity": "sha512-b17KeDIQVjvb0ssuSDF2cYXSg2iztliJ4B9WdsuB6J952qCPKmnVq4DyW5motImXHDC1cBT/1UezrJVsKw5zjg==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "http-parser-js": ">=0.5.1",
+        "safe-buffer": ">=5.1.0",
+        "websocket-extensions": ">=0.1.1"
+      },
+      "engines": {
+        "node": ">=0.8.0"
+      }
+    },
+    "node_modules/websocket-extensions": {
+      "version": "0.1.4",
+      "resolved": "https://registry.npmjs.org/websocket-extensions/-/websocket-extensions-0.1.4.tgz",
+      "integrity": "sha512-OqedPIGOfsDlo31UNwYbCFMSaO9m9G/0faIHj5/dZFDMFqPTcx6UwqyOy3COEaEOg/9VsGIpdqn62W5KhoKSpg==",
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=0.8.0"
+      }
+    },
     "node_modules/which": {
       "version": "2.0.2",
       "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
@@ -7694,6 +8997,70 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/wrap-ansi": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
+      "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==",
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^4.0.0",
+        "string-width": "^4.1.0",
+        "strip-ansi": "^6.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
+      }
+    },
+    "node_modules/ws": {
+      "version": "8.18.3",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.3.tgz",
+      "integrity": "sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=10.0.0"
+      },
+      "peerDependencies": {
+        "bufferutil": "^4.0.1",
+        "utf-8-validate": ">=5.0.2"
+      },
+      "peerDependenciesMeta": {
+        "bufferutil": {
+          "optional": true
+        },
+        "utf-8-validate": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/xmlhttprequest-ssl": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/xmlhttprequest-ssl/-/xmlhttprequest-ssl-2.1.2.tgz",
+      "integrity": "sha512-TEU+nJVUUnA4CYJFLvK5X9AOeH4KvDvhIfm0vV1GaQRtchnG0hgK5p8hw/xjv8cunWYCsiPCSDzObPyhEwq3KQ==",
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
+    "node_modules/xtend": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/xtend/-/xtend-4.0.2.tgz",
+      "integrity": "sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.4"
+      }
+    },
+    "node_modules/y18n": {
+      "version": "5.0.8",
+      "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz",
+      "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=10"
+      }
+    },
     "node_modules/yallist": {
       "version": "3.1.1",
       "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz",
@@ -7701,6 +9068,33 @@
       "dev": true,
       "license": "ISC"
     },
+    "node_modules/yargs": {
+      "version": "17.7.2",
+      "resolved": "https://registry.npmjs.org/yargs/-/yargs-17.7.2.tgz",
+      "integrity": "sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==",
+      "license": "MIT",
+      "dependencies": {
+        "cliui": "^8.0.1",
+        "escalade": "^3.1.1",
+        "get-caller-file": "^2.0.5",
+        "require-directory": "^2.1.1",
+        "string-width": "^4.2.3",
+        "y18n": "^5.0.5",
+        "yargs-parser": "^21.1.1"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/yargs-parser": {
+      "version": "21.1.1",
+      "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-21.1.1.tgz",
+      "integrity": "sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=12"
+      }
+    },
     "node_modules/yocto-queue": {
       "version": "0.1.0",
       "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz",
@@ -7730,7 +9124,6 @@
       "integrity": "sha512-rftlrkhHZOcjDwkGlnUtZZkvaPHCsDATp4pGpuOOMDaTdDDXF91wuVDJoWoPsKX/3YPQ5fHuF3STjcYyKr+Qhg==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "funding": {
         "url": "https://github.com/sponsors/colinhacks"
       }
diff --git a/package.json b/package.json
index 4626741..da68c8d 100644
--- a/package.json
+++ b/package.json
@@ -14,16 +14,22 @@
     "db:generate": "npx prisma generate"
   },
   "dependencies": {
+    "@monaco-editor/react": "^4.7.0",
+    "@prisma/adapter-pg": "^7.3.0",
     "@prisma/client": "^7.3.0",
     "backboard-sdk": "^1.4.12",
     "bcryptjs": "^3.0.3",
     "clsx": "^2.1.1",
+    "firebase": "^12.9.0",
     "jsonwebtoken": "^9.0.3",
     "lucide-react": "^0.460.0",
     "next": "16.1.6",
+    "pg": "^8.18.0",
     "prisma": "^7.3.0",
     "react": "19.2.3",
     "react-dom": "19.2.3",
+    "socket.io": "^4.8.3",
+    "socket.io-client": "^4.8.3",
     "tailwind-merge": "^2.5.4",
     "tailwindcss-animate": "^1.0.7"
   },
diff --git a/pages/api/socket.ts b/pages/api/socket.ts
new file mode 100644
index 0000000..3249445
--- /dev/null
+++ b/pages/api/socket.ts
@@ -0,0 +1,43 @@
+import type { NextApiRequest } from "next"
+import type { Server as NetServer } from "http"
+import type { Socket } from "net"
+import { Server as IOServer } from "socket.io"
+import type { NextApiResponse } from "next"
+import { setSocketServer } from "@/lib/socket"
+
+type NextApiResponseWithSocket = NextApiResponse & {
+  socket: Socket & {
+    server: NetServer & {
+      io?: IOServer
+    }
+  }
+}
+
+export default function handler(
+  _req: NextApiRequest,
+  res: NextApiResponseWithSocket,
+) {
+  if (!res.socket.server.io) {
+    const io = new IOServer(res.socket.server, {
+      path: "/api/socket",
+      addTrailingSlash: false,
+    })
+
+    res.socket.server.io = io
+    setSocketServer(io)
+
+    io.on("connection", (socket) => {
+      socket.emit("lobby:connected", { id: socket.id })
+    })
+  } else if (res.socket.server.io) {
+    setSocketServer(res.socket.server.io)
+  }
+
+  res.end()
+}
+
+export const config = {
+  api: {
+    bodyParser: false,
+  },
+}
diff --git a/prisma/generated/prisma/commonInputTypes.ts b/prisma/generated/prisma/commonInputTypes.ts
index 8aedf36..45b869b 100644
--- a/prisma/generated/prisma/commonInputTypes.ts
+++ b/prisma/generated/prisma/commonInputTypes.ts
@@ -248,6 +248,13 @@ export type FloatNullableFilter<$PrismaModel = never> = {
   not?: Prisma.NestedFloatNullableFilter<$PrismaModel> | number | null
 }
 
+export type EnumMatchOutcomeNullableFilter<$PrismaModel = never> = {
+  equals?: $Enums.MatchOutcome | Prisma.EnumMatchOutcomeFieldRefInput<$PrismaModel> | null
+  in?: $Enums.MatchOutcome[] | Prisma.ListEnumMatchOutcomeFieldRefInput<$PrismaModel> | null
+  notIn?: $Enums.MatchOutcome[] | Prisma.ListEnumMatchOutcomeFieldRefInput<$PrismaModel> | null
+  not?: Prisma.NestedEnumMatchOutcomeNullableFilter<$PrismaModel> | $Enums.MatchOutcome | null
+}
+
 export type IntNullableWithAggregatesFilter<$PrismaModel = never> = {
   equals?: number | Prisma.IntFieldRefInput<$PrismaModel> | null
   in?: number[] | Prisma.ListIntFieldRefInput<$PrismaModel> | null
@@ -280,6 +287,16 @@ export type FloatNullableWithAggregatesFilter<$PrismaModel = never> = {
   _max?: Prisma.NestedFloatNullableFilter<$PrismaModel>
 }
 
+export type EnumMatchOutcomeNullableWithAggregatesFilter<$PrismaModel = never> = {
+  equals?: $Enums.MatchOutcome | Prisma.EnumMatchOutcomeFieldRefInput<$PrismaModel> | null
+  in?: $Enums.MatchOutcome[] | Prisma.ListEnumMatchOutcomeFieldRefInput<$PrismaModel> | null
+  notIn?: $Enums.MatchOutcome[] | Prisma.ListEnumMatchOutcomeFieldRefInput<$PrismaModel> | null
+  not?: Prisma.NestedEnumMatchOutcomeNullableWithAggregatesFilter<$PrismaModel> | $Enums.MatchOutcome | null
+  _count?: Prisma.NestedIntNullableFilter<$PrismaModel>
+  _min?: Prisma.NestedEnumMatchOutcomeNullableFilter<$PrismaModel>
+  _max?: Prisma.NestedEnumMatchOutcomeNullableFilter<$PrismaModel>
+}
+
 export type EnumDifficultyFilter<$PrismaModel = never> = {
   equals?: $Enums.Difficulty | Prisma.EnumDifficultyFieldRefInput<$PrismaModel>
   in?: $Enums.Difficulty[] | Prisma.ListEnumDifficultyFieldRefInput<$PrismaModel>
@@ -584,6 +601,13 @@ export type NestedFloatNullableFilter<$PrismaModel = never> = {
   not?: Prisma.NestedFloatNullableFilter<$PrismaModel> | number | null
 }
 
+export type NestedEnumMatchOutcomeNullableFilter<$PrismaModel = never> = {
+  equals?: $Enums.MatchOutcome | Prisma.EnumMatchOutcomeFieldRefInput<$PrismaModel> | null
+  in?: $Enums.MatchOutcome[] | Prisma.ListEnumMatchOutcomeFieldRefInput<$PrismaModel> | null
+  notIn?: $Enums.MatchOutcome[] | Prisma.ListEnumMatchOutcomeFieldRefInput<$PrismaModel> | null
+  not?: Prisma.NestedEnumMatchOutcomeNullableFilter<$PrismaModel> | $Enums.MatchOutcome | null
+}
+
 export type NestedIntNullableWithAggregatesFilter<$PrismaModel = never> = {
   equals?: number | Prisma.IntFieldRefInput<$PrismaModel> | null
   in?: number[] | Prisma.ListIntFieldRefInput<$PrismaModel> | null
@@ -616,6 +640,16 @@ export type NestedFloatNullableWithAggregatesFilter<$PrismaModel = never> = {
   _max?: Prisma.NestedFloatNullableFilter<$PrismaModel>
 }
 
+export type NestedEnumMatchOutcomeNullableWithAggregatesFilter<$PrismaModel = never> = {
+  equals?: $Enums.MatchOutcome | Prisma.EnumMatchOutcomeFieldRefInput<$PrismaModel> | null
+  in?: $Enums.MatchOutcome[] | Prisma.ListEnumMatchOutcomeFieldRefInput<$PrismaModel> | null
+  notIn?: $Enums.MatchOutcome[] | Prisma.ListEnumMatchOutcomeFieldRefInput<$PrismaModel> | null
+  not?: Prisma.NestedEnumMatchOutcomeNullableWithAggregatesFilter<$PrismaModel> | $Enums.MatchOutcome | null
+  _count?: Prisma.NestedIntNullableFilter<$PrismaModel>
+  _min?: Prisma.NestedEnumMatchOutcomeNullableFilter<$PrismaModel>
+  _max?: Prisma.NestedEnumMatchOutcomeNullableFilter<$PrismaModel>
+}
+
 export type NestedEnumDifficultyFilter<$PrismaModel = never> = {
   equals?: $Enums.Difficulty | Prisma.EnumDifficultyFieldRefInput<$PrismaModel>
   in?: $Enums.Difficulty[] | Prisma.ListEnumDifficultyFieldRefInput<$PrismaModel>
diff --git a/prisma/generated/prisma/enums.ts b/prisma/generated/prisma/enums.ts
index 78585b5..71eba12 100644
--- a/prisma/generated/prisma/enums.ts
+++ b/prisma/generated/prisma/enums.ts
@@ -40,6 +40,15 @@ export const GameMode = {
 export type GameMode = (typeof GameMode)[keyof typeof GameMode]
 
 
+export const MatchOutcome = {
+  WIN: 'WIN',
+  LOSS: 'LOSS',
+  DRAW: 'DRAW'
+} as const
+
+export type MatchOutcome = (typeof MatchOutcome)[keyof typeof MatchOutcome]
+
+
 export const Difficulty = {
   EASY: 'EASY',
   MEDIUM: 'MEDIUM',
diff --git a/prisma/generated/prisma/internal/class.ts b/prisma/generated/prisma/internal/class.ts
index 7b9c193..de3bda1 100644
--- a/prisma/generated/prisma/internal/class.ts
+++ b/prisma/generated/prisma/internal/class.ts
@@ -20,7 +20,7 @@ const config: runtime.GetPrismaClientConfig = {
   "clientVersion": "7.3.0",
   "engineVersion": "9d6ad21cbbceab97458517b147a6a09ff43aa735",
   "activeProvider": "postgresql",
-  "inlineSchema": "// ============================================================\n// Compile-n-Conquer — Prisma Schema\n// ============================================================\n\ngenerator client {\n  provider = \"prisma-client\"\n  output   = \"./generated/prisma\"\n}\n\ndatasource db {\n  provider = \"postgresql\"\n}\n\n// ---- Users ----\n\nmodel User {\n  id           String    @id @default(cuid())\n  username     String    @unique\n  email        String    @unique\n  passwordHash String\n  displayName  String?\n  avatarUrl    String?\n  skillTier    SkillTier @default(BEGINNER)\n  elo          Int       @default(1000)\n  totalWins    Int       @default(0)\n  totalMatches Int       @default(0)\n  createdAt    DateTime  @default(now())\n  updatedAt    DateTime  @updatedAt\n\n  // Relations\n  submissions  Submission[]\n  matchPlayers MatchPlayer[]\n  queueEntries QueueEntry[]\n\n  @@map(\"users\")\n}\n\nenum SkillTier {\n  BEGINNER\n  INTERMEDIATE\n  ADVANCED\n  PRO\n}\n\n// ---- Matchmaking Queue ----\n\nmodel QueueEntry {\n  id       String   @id @default(cuid())\n  userId   String\n  joinedAt DateTime @default(now())\n  active   Boolean  @default(true)\n\n  user User @relation(fields: [userId], references: [id], onDelete: Cascade)\n\n  @@unique([userId, active])\n  @@map(\"queue_entries\")\n}\n\n// ---- Matches ----\n\nmodel Match {\n  id        String      @id @default(cuid())\n  status    MatchStatus @default(WAITING)\n  mode      GameMode    @default(FASTEST)\n  startedAt DateTime?\n  endedAt   DateTime?\n  createdAt DateTime    @default(now())\n\n  // Backboard thread IDs for evaluation\n  threadTimeComplexity  String?\n  threadSpaceComplexity String?\n  threadOriginality     String?\n  threadRanking         String?\n\n  // Relations\n  players     MatchPlayer[]\n  questions   MatchQuestion[]\n  submissions Submission[]\n\n  @@map(\"matches\")\n}\n\nenum MatchStatus {\n  WAITING // Waiting for all players to connect\n  IN_PROGRESS // Match is live\n  EVALUATING // Code submitted, LLM evaluation running\n  COMPLETED // Results are in\n  CANCELLED\n}\n\nenum GameMode {\n  FASTEST // First to pass all test cases\n  SHORTEST // Shortest code (by chars) that passes\n  REVERSE // Given output, write the code that produces it\n  DEBUGGING // Fix broken code\n}\n\nmodel MatchPlayer {\n  id       String   @id @default(cuid())\n  matchId  String\n  userId   String\n  rank     Int? // Final rank after evaluation\n  score    Float? // Final weighted score\n  joinedAt DateTime @default(now())\n\n  match Match @relation(fields: [matchId], references: [id], onDelete: Cascade)\n  user  User  @relation(fields: [userId], references: [id], onDelete: Cascade)\n\n  @@unique([matchId, userId])\n  @@map(\"match_players\")\n}\n\n// ---- Questions ----\n\nmodel Question {\n  id          String     @id @default(cuid())\n  title       String\n  description String\n  difficulty  Difficulty @default(MEDIUM)\n  mode        GameMode   @default(FASTEST)\n\n  // For DEBUGGING mode: the broken code to fix\n  brokenCode     String?\n  brokenLanguage String?\n\n  // For REVERSE mode: expected output\n  expectedOutput String?\n\n  // Test cases stored as JSON\n  testCases Json? // [{ input: string, expectedOutput: string }]\n\n  createdAt DateTime @default(now())\n  updatedAt DateTime @updatedAt\n\n  // Relations\n  matchQuestions MatchQuestion[]\n  submissions    Submission[]\n\n  @@map(\"questions\")\n}\n\nenum Difficulty {\n  EASY\n  MEDIUM\n  HARD\n}\n\nmodel MatchQuestion {\n  id         String @id @default(cuid())\n  matchId    String\n  questionId String\n  order      Int    @default(0) // Question order in the match\n\n  match    Match    @relation(fields: [matchId], references: [id], onDelete: Cascade)\n  question Question @relation(fields: [questionId], references: [id], onDelete: Cascade)\n\n  @@unique([matchId, questionId])\n  @@map(\"match_questions\")\n}\n\n// ---- Submissions ----\n\nmodel Submission {\n  id         String @id @default(cuid())\n  matchId    String\n  userId     String\n  questionId String\n  code       String\n  language   String\n  charCount  Int? // For SHORTEST mode\n\n  // Piston execution results\n  stdout      String?\n  stderr      String?\n  exitCode    Int?\n  execTimeMs  Int?\n  testsPassed Int     @default(0)\n  testsTotal  Int     @default(0)\n\n  // LLM evaluation scores\n  timeComplexity   String? // e.g. \"O(n)\"\n  timeScore        Float?\n  spaceComplexity  String?\n  spaceScore       Float?\n  originalityScore Float?\n  relevanceScore   Float?\n\n  submittedAt DateTime @default(now())\n\n  match    Match    @relation(fields: [matchId], references: [id], onDelete: Cascade)\n  user     User     @relation(fields: [userId], references: [id], onDelete: Cascade)\n  question Question @relation(fields: [questionId], references: [id], onDelete: Cascade)\n\n  @@map(\"submissions\")\n}\n",
+  "inlineSchema": "// ============================================================\n// Compile-n-Conquer — Prisma Schema\n// ============================================================\n\ngenerator client {\n  provider = \"prisma-client\"\n  output   = \"./generated/prisma\"\n}\n\ndatasource db {\n  provider = \"postgresql\"\n}\n\n// ---- Users ----\n\nmodel User {\n  id           String    @id @default(cuid())\n  username     String    @unique\n  email        String    @unique\n  passwordHash String\n  displayName  String?\n  avatarUrl    String?\n  title        String    @default(\"Code Warrior\")\n  skillTier    SkillTier @default(BEGINNER)\n  elo          Int       @default(1000)\n  totalWins    Int       @default(0)\n  totalMatches Int       @default(0)\n  totalXP      Int       @default(0)\n  streak       Int       @default(0)\n  createdAt    DateTime  @default(now())\n  updatedAt    DateTime  @updatedAt\n\n  // Relations\n  submissions  Submission[]\n  matchPlayers MatchPlayer[]\n  queueEntries QueueEntry[]\n\n  @@map(\"users\")\n}\n\nenum SkillTier {\n  BEGINNER\n  INTERMEDIATE\n  ADVANCED\n  PRO\n}\n\n// ---- Matchmaking Queue ----\n\nmodel QueueEntry {\n  id       String   @id @default(cuid())\n  userId   String\n  joinedAt DateTime @default(now())\n  active   Boolean  @default(true)\n\n  user User @relation(fields: [userId], references: [id], onDelete: Cascade)\n\n  @@unique([userId, active])\n  @@map(\"queue_entries\")\n}\n\n// ---- Matches ----\n\nmodel Match {\n  id         String      @id @default(cuid())\n  maxPlayers Int         @default(3)\n  status     MatchStatus @default(WAITING)\n  mode       GameMode    @default(FASTEST)\n  startedAt  DateTime?\n  endedAt    DateTime?\n  createdAt  DateTime    @default(now())\n\n  // Backboard thread IDs for evaluation\n  threadTimeComplexity  String?\n  threadSpaceComplexity String?\n  threadOriginality     String?\n  threadRanking         String?\n\n  // Relations\n  players     MatchPlayer[]\n  questions   MatchQuestion[]\n  submissions Submission[]\n\n  @@map(\"matches\")\n}\n\nenum MatchStatus {\n  WAITING // Waiting for all players to connect\n  IN_PROGRESS // Match is live\n  EVALUATING // Code submitted, LLM evaluation running\n  COMPLETED // Results are in\n  CANCELLED\n}\n\nenum GameMode {\n  FASTEST // First to pass all test cases\n  SHORTEST // Shortest code (by chars) that passes\n  REVERSE // Given output, write the code that produces it\n  DEBUGGING // Fix broken code\n}\n\nenum MatchOutcome {\n  WIN\n  LOSS\n  DRAW\n}\n\nmodel MatchPlayer {\n  id       String        @id @default(cuid())\n  matchId  String\n  userId   String\n  rank     Int? // Final rank after evaluation\n  score    Float? // Final weighted score\n  result   MatchOutcome?\n  xpDelta  Int           @default(0)\n  joinedAt DateTime      @default(now())\n\n  match Match @relation(fields: [matchId], references: [id], onDelete: Cascade)\n  user  User  @relation(fields: [userId], references: [id], onDelete: Cascade)\n\n  @@unique([matchId, userId])\n  @@map(\"match_players\")\n}\n\n// ---- Questions ----\n\nmodel Question {\n  id          String     @id @default(cuid())\n  title       String\n  description String\n  difficulty  Difficulty @default(MEDIUM)\n  mode        GameMode   @default(FASTEST)\n\n  // For DEBUGGING mode: the broken code to fix\n  brokenCode     String?\n  brokenLanguage String?\n\n  // For REVERSE mode: expected output\n  expectedOutput String?\n\n  // Test cases stored as JSON\n  testCases Json? // [{ input: string, expectedOutput: string }]\n\n  createdAt DateTime @default(now())\n  updatedAt DateTime @updatedAt\n\n  // Relations\n  matchQuestions MatchQuestion[]\n  submissions    Submission[]\n\n  @@map(\"questions\")\n}\n\nenum Difficulty {\n  EASY\n  MEDIUM\n  HARD\n}\n\nmodel MatchQuestion {\n  id         String @id @default(cuid())\n  matchId    String\n  questionId String\n  order      Int    @default(0) // Question order in the match\n\n  match    Match    @relation(fields: [matchId], references: [id], onDelete: Cascade)\n  question Question @relation(fields: [questionId], references: [id], onDelete: Cascade)\n\n  @@unique([matchId, questionId])\n  @@map(\"match_questions\")\n}\n\n// ---- Submissions ----\n\nmodel Submission {\n  id         String @id @default(cuid())\n  matchId    String\n  userId     String\n  questionId String\n  code       String\n  language   String\n  charCount  Int? // For SHORTEST mode\n\n  // Piston execution results\n  stdout      String?\n  stderr      String?\n  exitCode    Int?\n  execTimeMs  Int?\n  testsPassed Int     @default(0)\n  testsTotal  Int     @default(0)\n\n  // LLM evaluation scores\n  timeComplexity   String? // e.g. \"O(n)\"\n  timeScore        Float?\n  spaceComplexity  String?\n  spaceScore       Float?\n  originalityScore Float?\n  relevanceScore   Float?\n\n  submittedAt DateTime @default(now())\n\n  match    Match    @relation(fields: [matchId], references: [id], onDelete: Cascade)\n  user     User     @relation(fields: [userId], references: [id], onDelete: Cascade)\n  question Question @relation(fields: [questionId], references: [id], onDelete: Cascade)\n\n  @@map(\"submissions\")\n}\n",
   "runtimeDataModel": {
     "models": {},
     "enums": {},
@@ -28,7 +28,7 @@ const config: runtime.GetPrismaClientConfig = {
   }
 }
 
-config.runtimeDataModel = JSON.parse("{\"models\":{\"User\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"username\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"email\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"passwordHash\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"displayName\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"avatarUrl\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"skillTier\",\"kind\":\"enum\",\"type\":\"SkillTier\"},{\"name\":\"elo\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"totalWins\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"totalMatches\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"createdAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"updatedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"submissions\",\"kind\":\"object\",\"type\":\"Submission\",\"relationName\":\"SubmissionToUser\"},{\"name\":\"matchPlayers\",\"kind\":\"object\",\"type\":\"MatchPlayer\",\"relationName\":\"MatchPlayerToUser\"},{\"name\":\"queueEntries\",\"kind\":\"object\",\"type\":\"QueueEntry\",\"relationName\":\"QueueEntryToUser\"}],\"dbName\":\"users\"},\"QueueEntry\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"userId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"joinedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"active\",\"kind\":\"scalar\",\"type\":\"Boolean\"},{\"name\":\"user\",\"kind\":\"object\",\"type\":\"User\",\"relationName\":\"QueueEntryToUser\"}],\"dbName\":\"queue_entries\"},\"Match\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"status\",\"kind\":\"enum\",\"type\":\"MatchStatus\"},{\"name\":\"mode\",\"kind\":\"enum\",\"type\":\"GameMode\"},{\"name\":\"startedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"endedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"createdAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"threadTimeComplexity\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"threadSpaceComplexity\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"threadOriginality\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"threadRanking\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"players\",\"kind\":\"object\",\"type\":\"MatchPlayer\",\"relationName\":\"MatchToMatchPlayer\"},{\"name\":\"questions\",\"kind\":\"object\",\"type\":\"MatchQuestion\",\"relationName\":\"MatchToMatchQuestion\"},{\"name\":\"submissions\",\"kind\":\"object\",\"type\":\"Submission\",\"relationName\":\"MatchToSubmission\"}],\"dbName\":\"matches\"},\"MatchPlayer\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"matchId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"userId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"rank\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"score\",\"kind\":\"scalar\",\"type\":\"Float\"},{\"name\":\"joinedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"match\",\"kind\":\"object\",\"type\":\"Match\",\"relationName\":\"MatchToMatchPlayer\"},{\"name\":\"user\",\"kind\":\"object\",\"type\":\"User\",\"relationName\":\"MatchPlayerToUser\"}],\"dbName\":\"match_players\"},\"Question\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"title\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"description\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"difficulty\",\"kind\":\"enum\",\"type\":\"Difficulty\"},{\"name\":\"mode\",\"kind\":\"enum\",\"type\":\"GameMode\"},{\"name\":\"brokenCode\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"brokenLanguage\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"expectedOutput\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"testCases\",\"kind\":\"scalar\",\"type\":\"Json\"},{\"name\":\"createdAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"updatedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"matchQuestions\",\"kind\":\"object\",\"type\":\"MatchQuestion\",\"relationName\":\"MatchQuestionToQuestion\"},{\"name\":\"submissions\",\"kind\":\"object\",\"type\":\"Submission\",\"relationName\":\"QuestionToSubmission\"}],\"dbName\":\"questions\"},\"MatchQuestion\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"matchId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"questionId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"order\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"match\",\"kind\":\"object\",\"type\":\"Match\",\"relationName\":\"MatchToMatchQuestion\"},{\"name\":\"question\",\"kind\":\"object\",\"type\":\"Question\",\"relationName\":\"MatchQuestionToQuestion\"}],\"dbName\":\"match_questions\"},\"Submission\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"matchId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"userId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"questionId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"code\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"language\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"charCount\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"stdout\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"stderr\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"exitCode\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"execTimeMs\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"testsPassed\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"testsTotal\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"timeComplexity\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"timeScore\",\"kind\":\"scalar\",\"type\":\"Float\"},{\"name\":\"spaceComplexity\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"spaceScore\",\"kind\":\"scalar\",\"type\":\"Float\"},{\"name\":\"originalityScore\",\"kind\":\"scalar\",\"type\":\"Float\"},{\"name\":\"relevanceScore\",\"kind\":\"scalar\",\"type\":\"Float\"},{\"name\":\"submittedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"match\",\"kind\":\"object\",\"type\":\"Match\",\"relationName\":\"MatchToSubmission\"},{\"name\":\"user\",\"kind\":\"object\",\"type\":\"User\",\"relationName\":\"SubmissionToUser\"},{\"name\":\"question\",\"kind\":\"object\",\"type\":\"Question\",\"relationName\":\"QuestionToSubmission\"}],\"dbName\":\"submissions\"}},\"enums\":{},\"types\":{}}")
+config.runtimeDataModel = JSON.parse("{\"models\":{\"User\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"username\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"email\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"passwordHash\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"displayName\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"avatarUrl\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"title\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"skillTier\",\"kind\":\"enum\",\"type\":\"SkillTier\"},{\"name\":\"elo\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"totalWins\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"totalMatches\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"totalXP\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"streak\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"createdAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"updatedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"submissions\",\"kind\":\"object\",\"type\":\"Submission\",\"relationName\":\"SubmissionToUser\"},{\"name\":\"matchPlayers\",\"kind\":\"object\",\"type\":\"MatchPlayer\",\"relationName\":\"MatchPlayerToUser\"},{\"name\":\"queueEntries\",\"kind\":\"object\",\"type\":\"QueueEntry\",\"relationName\":\"QueueEntryToUser\"}],\"dbName\":\"users\"},\"QueueEntry\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"userId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"joinedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"active\",\"kind\":\"scalar\",\"type\":\"Boolean\"},{\"name\":\"user\",\"kind\":\"object\",\"type\":\"User\",\"relationName\":\"QueueEntryToUser\"}],\"dbName\":\"queue_entries\"},\"Match\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"maxPlayers\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"status\",\"kind\":\"enum\",\"type\":\"MatchStatus\"},{\"name\":\"mode\",\"kind\":\"enum\",\"type\":\"GameMode\"},{\"name\":\"startedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"endedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"createdAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"threadTimeComplexity\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"threadSpaceComplexity\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"threadOriginality\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"threadRanking\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"players\",\"kind\":\"object\",\"type\":\"MatchPlayer\",\"relationName\":\"MatchToMatchPlayer\"},{\"name\":\"questions\",\"kind\":\"object\",\"type\":\"MatchQuestion\",\"relationName\":\"MatchToMatchQuestion\"},{\"name\":\"submissions\",\"kind\":\"object\",\"type\":\"Submission\",\"relationName\":\"MatchToSubmission\"}],\"dbName\":\"matches\"},\"MatchPlayer\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"matchId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"userId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"rank\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"score\",\"kind\":\"scalar\",\"type\":\"Float\"},{\"name\":\"result\",\"kind\":\"enum\",\"type\":\"MatchOutcome\"},{\"name\":\"xpDelta\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"joinedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"match\",\"kind\":\"object\",\"type\":\"Match\",\"relationName\":\"MatchToMatchPlayer\"},{\"name\":\"user\",\"kind\":\"object\",\"type\":\"User\",\"relationName\":\"MatchPlayerToUser\"}],\"dbName\":\"match_players\"},\"Question\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"title\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"description\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"difficulty\",\"kind\":\"enum\",\"type\":\"Difficulty\"},{\"name\":\"mode\",\"kind\":\"enum\",\"type\":\"GameMode\"},{\"name\":\"brokenCode\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"brokenLanguage\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"expectedOutput\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"testCases\",\"kind\":\"scalar\",\"type\":\"Json\"},{\"name\":\"createdAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"updatedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"matchQuestions\",\"kind\":\"object\",\"type\":\"MatchQuestion\",\"relationName\":\"MatchQuestionToQuestion\"},{\"name\":\"submissions\",\"kind\":\"object\",\"type\":\"Submission\",\"relationName\":\"QuestionToSubmission\"}],\"dbName\":\"questions\"},\"MatchQuestion\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"matchId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"questionId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"order\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"match\",\"kind\":\"object\",\"type\":\"Match\",\"relationName\":\"MatchToMatchQuestion\"},{\"name\":\"question\",\"kind\":\"object\",\"type\":\"Question\",\"relationName\":\"MatchQuestionToQuestion\"}],\"dbName\":\"match_questions\"},\"Submission\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"matchId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"userId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"questionId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"code\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"language\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"charCount\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"stdout\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"stderr\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"exitCode\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"execTimeMs\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"testsPassed\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"testsTotal\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"timeComplexity\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"timeScore\",\"kind\":\"scalar\",\"type\":\"Float\"},{\"name\":\"spaceComplexity\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"spaceScore\",\"kind\":\"scalar\",\"type\":\"Float\"},{\"name\":\"originalityScore\",\"kind\":\"scalar\",\"type\":\"Float\"},{\"name\":\"relevanceScore\",\"kind\":\"scalar\",\"type\":\"Float\"},{\"name\":\"submittedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"match\",\"kind\":\"object\",\"type\":\"Match\",\"relationName\":\"MatchToSubmission\"},{\"name\":\"user\",\"kind\":\"object\",\"type\":\"User\",\"relationName\":\"SubmissionToUser\"},{\"name\":\"question\",\"kind\":\"object\",\"type\":\"Question\",\"relationName\":\"QuestionToSubmission\"}],\"dbName\":\"submissions\"}},\"enums\":{},\"types\":{}}")
 
 async function decodeBase64AsWasm(wasmBase64: string): Promise<WebAssembly.Module> {
   const { Buffer } = await import('node:buffer')
diff --git a/prisma/generated/prisma/internal/prismaNamespace.ts b/prisma/generated/prisma/internal/prismaNamespace.ts
index 5941113..c85f0da 100644
--- a/prisma/generated/prisma/internal/prismaNamespace.ts
+++ b/prisma/generated/prisma/internal/prismaNamespace.ts
@@ -974,10 +974,13 @@ export const UserScalarFieldEnum = {
   passwordHash: 'passwordHash',
   displayName: 'displayName',
   avatarUrl: 'avatarUrl',
+  title: 'title',
   skillTier: 'skillTier',
   elo: 'elo',
   totalWins: 'totalWins',
   totalMatches: 'totalMatches',
+  totalXP: 'totalXP',
+  streak: 'streak',
   createdAt: 'createdAt',
   updatedAt: 'updatedAt'
 } as const
@@ -997,6 +1000,7 @@ export type QueueEntryScalarFieldEnum = (typeof QueueEntryScalarFieldEnum)[keyof
 
 export const MatchScalarFieldEnum = {
   id: 'id',
+  maxPlayers: 'maxPlayers',
   status: 'status',
   mode: 'mode',
   startedAt: 'startedAt',
@@ -1017,6 +1021,8 @@ export const MatchPlayerScalarFieldEnum = {
   userId: 'userId',
   rank: 'rank',
   score: 'score',
+  result: 'result',
+  xpDelta: 'xpDelta',
   joinedAt: 'joinedAt'
 } as const
 
@@ -1228,6 +1234,20 @@ export type ListFloatFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaMode
     
 
 
+/**
+ * Reference to a field of type 'MatchOutcome'
+ */
+export type EnumMatchOutcomeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'MatchOutcome'>
+    
+
+
+/**
+ * Reference to a field of type 'MatchOutcome[]'
+ */
+export type ListEnumMatchOutcomeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'MatchOutcome[]'>
+    
+
+
 /**
  * Reference to a field of type 'Difficulty'
  */
diff --git a/prisma/generated/prisma/internal/prismaNamespaceBrowser.ts b/prisma/generated/prisma/internal/prismaNamespaceBrowser.ts
index f516195..355d556 100644
--- a/prisma/generated/prisma/internal/prismaNamespaceBrowser.ts
+++ b/prisma/generated/prisma/internal/prismaNamespaceBrowser.ts
@@ -83,10 +83,13 @@ export const UserScalarFieldEnum = {
   passwordHash: 'passwordHash',
   displayName: 'displayName',
   avatarUrl: 'avatarUrl',
+  title: 'title',
   skillTier: 'skillTier',
   elo: 'elo',
   totalWins: 'totalWins',
   totalMatches: 'totalMatches',
+  totalXP: 'totalXP',
+  streak: 'streak',
   createdAt: 'createdAt',
   updatedAt: 'updatedAt'
 } as const
@@ -106,6 +109,7 @@ export type QueueEntryScalarFieldEnum = (typeof QueueEntryScalarFieldEnum)[keyof
 
 export const MatchScalarFieldEnum = {
   id: 'id',
+  maxPlayers: 'maxPlayers',
   status: 'status',
   mode: 'mode',
   startedAt: 'startedAt',
@@ -126,6 +130,8 @@ export const MatchPlayerScalarFieldEnum = {
   userId: 'userId',
   rank: 'rank',
   score: 'score',
+  result: 'result',
+  xpDelta: 'xpDelta',
   joinedAt: 'joinedAt'
 } as const
 
diff --git a/prisma/generated/prisma/models/Match.ts b/prisma/generated/prisma/models/Match.ts
index b4de21a..d737e40 100644
--- a/prisma/generated/prisma/models/Match.ts
+++ b/prisma/generated/prisma/models/Match.ts
@@ -20,12 +20,23 @@ export type MatchModel = runtime.Types.Result.DefaultSelection<Prisma.$MatchPayl
 
 export type AggregateMatch = {
   _count: MatchCountAggregateOutputType | null
+  _avg: MatchAvgAggregateOutputType | null
+  _sum: MatchSumAggregateOutputType | null
   _min: MatchMinAggregateOutputType | null
   _max: MatchMaxAggregateOutputType | null
 }
 
+export type MatchAvgAggregateOutputType = {
+  maxPlayers: number | null
+}
+
+export type MatchSumAggregateOutputType = {
+  maxPlayers: number | null
+}
+
 export type MatchMinAggregateOutputType = {
   id: string | null
+  maxPlayers: number | null
   status: $Enums.MatchStatus | null
   mode: $Enums.GameMode | null
   startedAt: Date | null
@@ -39,6 +50,7 @@ export type MatchMinAggregateOutputType = {
 
 export type MatchMaxAggregateOutputType = {
   id: string | null
+  maxPlayers: number | null
   status: $Enums.MatchStatus | null
   mode: $Enums.GameMode | null
   startedAt: Date | null
@@ -52,6 +64,7 @@ export type MatchMaxAggregateOutputType = {
 
 export type MatchCountAggregateOutputType = {
   id: number
+  maxPlayers: number
   status: number
   mode: number
   startedAt: number
@@ -65,8 +78,17 @@ export type MatchCountAggregateOutputType = {
 }
 
 
+export type MatchAvgAggregateInputType = {
+  maxPlayers?: true
+}
+
+export type MatchSumAggregateInputType = {
+  maxPlayers?: true
+}
+
 export type MatchMinAggregateInputType = {
   id?: true
+  maxPlayers?: true
   status?: true
   mode?: true
   startedAt?: true
@@ -80,6 +102,7 @@ export type MatchMinAggregateInputType = {
 
 export type MatchMaxAggregateInputType = {
   id?: true
+  maxPlayers?: true
   status?: true
   mode?: true
   startedAt?: true
@@ -93,6 +116,7 @@ export type MatchMaxAggregateInputType = {
 
 export type MatchCountAggregateInputType = {
   id?: true
+  maxPlayers?: true
   status?: true
   mode?: true
   startedAt?: true
@@ -140,6 +164,18 @@ export type MatchAggregateArgs<ExtArgs extends runtime.Types.Extensions.Internal
    * Count returned Matches
   **/
   _count?: true | MatchCountAggregateInputType
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Select which fields to average
+  **/
+  _avg?: MatchAvgAggregateInputType
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Select which fields to sum
+  **/
+  _sum?: MatchSumAggregateInputType
   /**
    * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
    * 
@@ -173,12 +209,15 @@ export type MatchGroupByArgs<ExtArgs extends runtime.Types.Extensions.InternalAr
   take?: number
   skip?: number
   _count?: MatchCountAggregateInputType | true
+  _avg?: MatchAvgAggregateInputType
+  _sum?: MatchSumAggregateInputType
   _min?: MatchMinAggregateInputType
   _max?: MatchMaxAggregateInputType
 }
 
 export type MatchGroupByOutputType = {
   id: string
+  maxPlayers: number
   status: $Enums.MatchStatus
   mode: $Enums.GameMode
   startedAt: Date | null
@@ -189,6 +228,8 @@ export type MatchGroupByOutputType = {
   threadOriginality: string | null
   threadRanking: string | null
   _count: MatchCountAggregateOutputType | null
+  _avg: MatchAvgAggregateOutputType | null
+  _sum: MatchSumAggregateOutputType | null
   _min: MatchMinAggregateOutputType | null
   _max: MatchMaxAggregateOutputType | null
 }
@@ -213,6 +254,7 @@ export type MatchWhereInput = {
   OR?: Prisma.MatchWhereInput[]
   NOT?: Prisma.MatchWhereInput | Prisma.MatchWhereInput[]
   id?: Prisma.StringFilter<"Match"> | string
+  maxPlayers?: Prisma.IntFilter<"Match"> | number
   status?: Prisma.EnumMatchStatusFilter<"Match"> | $Enums.MatchStatus
   mode?: Prisma.EnumGameModeFilter<"Match"> | $Enums.GameMode
   startedAt?: Prisma.DateTimeNullableFilter<"Match"> | Date | string | null
@@ -229,6 +271,7 @@ export type MatchWhereInput = {
 
 export type MatchOrderByWithRelationInput = {
   id?: Prisma.SortOrder
+  maxPlayers?: Prisma.SortOrder
   status?: Prisma.SortOrder
   mode?: Prisma.SortOrder
   startedAt?: Prisma.SortOrderInput | Prisma.SortOrder
@@ -248,6 +291,7 @@ export type MatchWhereUniqueInput = Prisma.AtLeast<{
   AND?: Prisma.MatchWhereInput | Prisma.MatchWhereInput[]
   OR?: Prisma.MatchWhereInput[]
   NOT?: Prisma.MatchWhereInput | Prisma.MatchWhereInput[]
+  maxPlayers?: Prisma.IntFilter<"Match"> | number
   status?: Prisma.EnumMatchStatusFilter<"Match"> | $Enums.MatchStatus
   mode?: Prisma.EnumGameModeFilter<"Match"> | $Enums.GameMode
   startedAt?: Prisma.DateTimeNullableFilter<"Match"> | Date | string | null
@@ -264,6 +308,7 @@ export type MatchWhereUniqueInput = Prisma.AtLeast<{
 
 export type MatchOrderByWithAggregationInput = {
   id?: Prisma.SortOrder
+  maxPlayers?: Prisma.SortOrder
   status?: Prisma.SortOrder
   mode?: Prisma.SortOrder
   startedAt?: Prisma.SortOrderInput | Prisma.SortOrder
@@ -274,8 +319,10 @@ export type MatchOrderByWithAggregationInput = {
   threadOriginality?: Prisma.SortOrderInput | Prisma.SortOrder
   threadRanking?: Prisma.SortOrderInput | Prisma.SortOrder
   _count?: Prisma.MatchCountOrderByAggregateInput
+  _avg?: Prisma.MatchAvgOrderByAggregateInput
   _max?: Prisma.MatchMaxOrderByAggregateInput
   _min?: Prisma.MatchMinOrderByAggregateInput
+  _sum?: Prisma.MatchSumOrderByAggregateInput
 }
 
 export type MatchScalarWhereWithAggregatesInput = {
@@ -283,6 +330,7 @@ export type MatchScalarWhereWithAggregatesInput = {
   OR?: Prisma.MatchScalarWhereWithAggregatesInput[]
   NOT?: Prisma.MatchScalarWhereWithAggregatesInput | Prisma.MatchScalarWhereWithAggregatesInput[]
   id?: Prisma.StringWithAggregatesFilter<"Match"> | string
+  maxPlayers?: Prisma.IntWithAggregatesFilter<"Match"> | number
   status?: Prisma.EnumMatchStatusWithAggregatesFilter<"Match"> | $Enums.MatchStatus
   mode?: Prisma.EnumGameModeWithAggregatesFilter<"Match"> | $Enums.GameMode
   startedAt?: Prisma.DateTimeNullableWithAggregatesFilter<"Match"> | Date | string | null
@@ -296,6 +344,7 @@ export type MatchScalarWhereWithAggregatesInput = {
 
 export type MatchCreateInput = {
   id?: string
+  maxPlayers?: number
   status?: $Enums.MatchStatus
   mode?: $Enums.GameMode
   startedAt?: Date | string | null
@@ -312,6 +361,7 @@ export type MatchCreateInput = {
 
 export type MatchUncheckedCreateInput = {
   id?: string
+  maxPlayers?: number
   status?: $Enums.MatchStatus
   mode?: $Enums.GameMode
   startedAt?: Date | string | null
@@ -328,6 +378,7 @@ export type MatchUncheckedCreateInput = {
 
 export type MatchUpdateInput = {
   id?: Prisma.StringFieldUpdateOperationsInput | string
+  maxPlayers?: Prisma.IntFieldUpdateOperationsInput | number
   status?: Prisma.EnumMatchStatusFieldUpdateOperationsInput | $Enums.MatchStatus
   mode?: Prisma.EnumGameModeFieldUpdateOperationsInput | $Enums.GameMode
   startedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null
@@ -344,6 +395,7 @@ export type MatchUpdateInput = {
 
 export type MatchUncheckedUpdateInput = {
   id?: Prisma.StringFieldUpdateOperationsInput | string
+  maxPlayers?: Prisma.IntFieldUpdateOperationsInput | number
   status?: Prisma.EnumMatchStatusFieldUpdateOperationsInput | $Enums.MatchStatus
   mode?: Prisma.EnumGameModeFieldUpdateOperationsInput | $Enums.GameMode
   startedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null
@@ -360,6 +412,7 @@ export type MatchUncheckedUpdateInput = {
 
 export type MatchCreateManyInput = {
   id?: string
+  maxPlayers?: number
   status?: $Enums.MatchStatus
   mode?: $Enums.GameMode
   startedAt?: Date | string | null
@@ -373,6 +426,7 @@ export type MatchCreateManyInput = {
 
 export type MatchUpdateManyMutationInput = {
   id?: Prisma.StringFieldUpdateOperationsInput | string
+  maxPlayers?: Prisma.IntFieldUpdateOperationsInput | number
   status?: Prisma.EnumMatchStatusFieldUpdateOperationsInput | $Enums.MatchStatus
   mode?: Prisma.EnumGameModeFieldUpdateOperationsInput | $Enums.GameMode
   startedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null
@@ -386,6 +440,7 @@ export type MatchUpdateManyMutationInput = {
 
 export type MatchUncheckedUpdateManyInput = {
   id?: Prisma.StringFieldUpdateOperationsInput | string
+  maxPlayers?: Prisma.IntFieldUpdateOperationsInput | number
   status?: Prisma.EnumMatchStatusFieldUpdateOperationsInput | $Enums.MatchStatus
   mode?: Prisma.EnumGameModeFieldUpdateOperationsInput | $Enums.GameMode
   startedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null
@@ -399,6 +454,7 @@ export type MatchUncheckedUpdateManyInput = {
 
 export type MatchCountOrderByAggregateInput = {
   id?: Prisma.SortOrder
+  maxPlayers?: Prisma.SortOrder
   status?: Prisma.SortOrder
   mode?: Prisma.SortOrder
   startedAt?: Prisma.SortOrder
@@ -410,8 +466,13 @@ export type MatchCountOrderByAggregateInput = {
   threadRanking?: Prisma.SortOrder
 }
 
+export type MatchAvgOrderByAggregateInput = {
+  maxPlayers?: Prisma.SortOrder
+}
+
 export type MatchMaxOrderByAggregateInput = {
   id?: Prisma.SortOrder
+  maxPlayers?: Prisma.SortOrder
   status?: Prisma.SortOrder
   mode?: Prisma.SortOrder
   startedAt?: Prisma.SortOrder
@@ -425,6 +486,7 @@ export type MatchMaxOrderByAggregateInput = {
 
 export type MatchMinOrderByAggregateInput = {
   id?: Prisma.SortOrder
+  maxPlayers?: Prisma.SortOrder
   status?: Prisma.SortOrder
   mode?: Prisma.SortOrder
   startedAt?: Prisma.SortOrder
@@ -436,6 +498,10 @@ export type MatchMinOrderByAggregateInput = {
   threadRanking?: Prisma.SortOrder
 }
 
+export type MatchSumOrderByAggregateInput = {
+  maxPlayers?: Prisma.SortOrder
+}
+
 export type MatchScalarRelationFilter = {
   is?: Prisma.MatchWhereInput
   isNot?: Prisma.MatchWhereInput
@@ -497,6 +563,7 @@ export type MatchUpdateOneRequiredWithoutSubmissionsNestedInput = {
 
 export type MatchCreateWithoutPlayersInput = {
   id?: string
+  maxPlayers?: number
   status?: $Enums.MatchStatus
   mode?: $Enums.GameMode
   startedAt?: Date | string | null
@@ -512,6 +579,7 @@ export type MatchCreateWithoutPlayersInput = {
 
 export type MatchUncheckedCreateWithoutPlayersInput = {
   id?: string
+  maxPlayers?: number
   status?: $Enums.MatchStatus
   mode?: $Enums.GameMode
   startedAt?: Date | string | null
@@ -543,6 +611,7 @@ export type MatchUpdateToOneWithWhereWithoutPlayersInput = {
 
 export type MatchUpdateWithoutPlayersInput = {
   id?: Prisma.StringFieldUpdateOperationsInput | string
+  maxPlayers?: Prisma.IntFieldUpdateOperationsInput | number
   status?: Prisma.EnumMatchStatusFieldUpdateOperationsInput | $Enums.MatchStatus
   mode?: Prisma.EnumGameModeFieldUpdateOperationsInput | $Enums.GameMode
   startedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null
@@ -558,6 +627,7 @@ export type MatchUpdateWithoutPlayersInput = {
 
 export type MatchUncheckedUpdateWithoutPlayersInput = {
   id?: Prisma.StringFieldUpdateOperationsInput | string
+  maxPlayers?: Prisma.IntFieldUpdateOperationsInput | number
   status?: Prisma.EnumMatchStatusFieldUpdateOperationsInput | $Enums.MatchStatus
   mode?: Prisma.EnumGameModeFieldUpdateOperationsInput | $Enums.GameMode
   startedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null
@@ -573,6 +643,7 @@ export type MatchUncheckedUpdateWithoutPlayersInput = {
 
 export type MatchCreateWithoutQuestionsInput = {
   id?: string
+  maxPlayers?: number
   status?: $Enums.MatchStatus
   mode?: $Enums.GameMode
   startedAt?: Date | string | null
@@ -588,6 +659,7 @@ export type MatchCreateWithoutQuestionsInput = {
 
 export type MatchUncheckedCreateWithoutQuestionsInput = {
   id?: string
+  maxPlayers?: number
   status?: $Enums.MatchStatus
   mode?: $Enums.GameMode
   startedAt?: Date | string | null
@@ -619,6 +691,7 @@ export type MatchUpdateToOneWithWhereWithoutQuestionsInput = {
 
 export type MatchUpdateWithoutQuestionsInput = {
   id?: Prisma.StringFieldUpdateOperationsInput | string
+  maxPlayers?: Prisma.IntFieldUpdateOperationsInput | number
   status?: Prisma.EnumMatchStatusFieldUpdateOperationsInput | $Enums.MatchStatus
   mode?: Prisma.EnumGameModeFieldUpdateOperationsInput | $Enums.GameMode
   startedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null
@@ -634,6 +707,7 @@ export type MatchUpdateWithoutQuestionsInput = {
 
 export type MatchUncheckedUpdateWithoutQuestionsInput = {
   id?: Prisma.StringFieldUpdateOperationsInput | string
+  maxPlayers?: Prisma.IntFieldUpdateOperationsInput | number
   status?: Prisma.EnumMatchStatusFieldUpdateOperationsInput | $Enums.MatchStatus
   mode?: Prisma.EnumGameModeFieldUpdateOperationsInput | $Enums.GameMode
   startedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null
@@ -649,6 +723,7 @@ export type MatchUncheckedUpdateWithoutQuestionsInput = {
 
 export type MatchCreateWithoutSubmissionsInput = {
   id?: string
+  maxPlayers?: number
   status?: $Enums.MatchStatus
   mode?: $Enums.GameMode
   startedAt?: Date | string | null
@@ -664,6 +739,7 @@ export type MatchCreateWithoutSubmissionsInput = {
 
 export type MatchUncheckedCreateWithoutSubmissionsInput = {
   id?: string
+  maxPlayers?: number
   status?: $Enums.MatchStatus
   mode?: $Enums.GameMode
   startedAt?: Date | string | null
@@ -695,6 +771,7 @@ export type MatchUpdateToOneWithWhereWithoutSubmissionsInput = {
 
 export type MatchUpdateWithoutSubmissionsInput = {
   id?: Prisma.StringFieldUpdateOperationsInput | string
+  maxPlayers?: Prisma.IntFieldUpdateOperationsInput | number
   status?: Prisma.EnumMatchStatusFieldUpdateOperationsInput | $Enums.MatchStatus
   mode?: Prisma.EnumGameModeFieldUpdateOperationsInput | $Enums.GameMode
   startedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null
@@ -710,6 +787,7 @@ export type MatchUpdateWithoutSubmissionsInput = {
 
 export type MatchUncheckedUpdateWithoutSubmissionsInput = {
   id?: Prisma.StringFieldUpdateOperationsInput | string
+  maxPlayers?: Prisma.IntFieldUpdateOperationsInput | number
   status?: Prisma.EnumMatchStatusFieldUpdateOperationsInput | $Enums.MatchStatus
   mode?: Prisma.EnumGameModeFieldUpdateOperationsInput | $Enums.GameMode
   startedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null
@@ -774,6 +852,7 @@ export type MatchCountOutputTypeCountSubmissionsArgs<ExtArgs extends runtime.Typ
 
 export type MatchSelect<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
   id?: boolean
+  maxPlayers?: boolean
   status?: boolean
   mode?: boolean
   startedAt?: boolean
@@ -791,6 +870,7 @@ export type MatchSelect<ExtArgs extends runtime.Types.Extensions.InternalArgs =
 
 export type MatchSelectCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
   id?: boolean
+  maxPlayers?: boolean
   status?: boolean
   mode?: boolean
   startedAt?: boolean
@@ -804,6 +884,7 @@ export type MatchSelectCreateManyAndReturn<ExtArgs extends runtime.Types.Extensi
 
 export type MatchSelectUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
   id?: boolean
+  maxPlayers?: boolean
   status?: boolean
   mode?: boolean
   startedAt?: boolean
@@ -817,6 +898,7 @@ export type MatchSelectUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensi
 
 export type MatchSelectScalar = {
   id?: boolean
+  maxPlayers?: boolean
   status?: boolean
   mode?: boolean
   startedAt?: boolean
@@ -828,7 +910,7 @@ export type MatchSelectScalar = {
   threadRanking?: boolean
 }
 
-export type MatchOmit<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetOmit<"id" | "status" | "mode" | "startedAt" | "endedAt" | "createdAt" | "threadTimeComplexity" | "threadSpaceComplexity" | "threadOriginality" | "threadRanking", ExtArgs["result"]["match"]>
+export type MatchOmit<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetOmit<"id" | "maxPlayers" | "status" | "mode" | "startedAt" | "endedAt" | "createdAt" | "threadTimeComplexity" | "threadSpaceComplexity" | "threadOriginality" | "threadRanking", ExtArgs["result"]["match"]>
 export type MatchInclude<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
   players?: boolean | Prisma.Match$playersArgs<ExtArgs>
   questions?: boolean | Prisma.Match$questionsArgs<ExtArgs>
@@ -847,6 +929,7 @@ export type $MatchPayload<ExtArgs extends runtime.Types.Extensions.InternalArgs
   }
   scalars: runtime.Types.Extensions.GetPayloadResult<{
     id: string
+    maxPlayers: number
     status: $Enums.MatchStatus
     mode: $Enums.GameMode
     startedAt: Date | null
@@ -1283,6 +1366,7 @@ export interface Prisma__MatchClient<T, Null = never, ExtArgs extends runtime.Ty
  */
 export interface MatchFieldRefs {
   readonly id: Prisma.FieldRef<"Match", 'String'>
+  readonly maxPlayers: Prisma.FieldRef<"Match", 'Int'>
   readonly status: Prisma.FieldRef<"Match", 'MatchStatus'>
   readonly mode: Prisma.FieldRef<"Match", 'GameMode'>
   readonly startedAt: Prisma.FieldRef<"Match", 'DateTime'>
diff --git a/prisma/generated/prisma/models/MatchPlayer.ts b/prisma/generated/prisma/models/MatchPlayer.ts
index 66840d7..4493a13 100644
--- a/prisma/generated/prisma/models/MatchPlayer.ts
+++ b/prisma/generated/prisma/models/MatchPlayer.ts
@@ -29,11 +29,13 @@ export type AggregateMatchPlayer = {
 export type MatchPlayerAvgAggregateOutputType = {
   rank: number | null
   score: number | null
+  xpDelta: number | null
 }
 
 export type MatchPlayerSumAggregateOutputType = {
   rank: number | null
   score: number | null
+  xpDelta: number | null
 }
 
 export type MatchPlayerMinAggregateOutputType = {
@@ -42,6 +44,8 @@ export type MatchPlayerMinAggregateOutputType = {
   userId: string | null
   rank: number | null
   score: number | null
+  result: $Enums.MatchOutcome | null
+  xpDelta: number | null
   joinedAt: Date | null
 }
 
@@ -51,6 +55,8 @@ export type MatchPlayerMaxAggregateOutputType = {
   userId: string | null
   rank: number | null
   score: number | null
+  result: $Enums.MatchOutcome | null
+  xpDelta: number | null
   joinedAt: Date | null
 }
 
@@ -60,6 +66,8 @@ export type MatchPlayerCountAggregateOutputType = {
   userId: number
   rank: number
   score: number
+  result: number
+  xpDelta: number
   joinedAt: number
   _all: number
 }
@@ -68,11 +76,13 @@ export type MatchPlayerCountAggregateOutputType = {
 export type MatchPlayerAvgAggregateInputType = {
   rank?: true
   score?: true
+  xpDelta?: true
 }
 
 export type MatchPlayerSumAggregateInputType = {
   rank?: true
   score?: true
+  xpDelta?: true
 }
 
 export type MatchPlayerMinAggregateInputType = {
@@ -81,6 +91,8 @@ export type MatchPlayerMinAggregateInputType = {
   userId?: true
   rank?: true
   score?: true
+  result?: true
+  xpDelta?: true
   joinedAt?: true
 }
 
@@ -90,6 +102,8 @@ export type MatchPlayerMaxAggregateInputType = {
   userId?: true
   rank?: true
   score?: true
+  result?: true
+  xpDelta?: true
   joinedAt?: true
 }
 
@@ -99,6 +113,8 @@ export type MatchPlayerCountAggregateInputType = {
   userId?: true
   rank?: true
   score?: true
+  result?: true
+  xpDelta?: true
   joinedAt?: true
   _all?: true
 }
@@ -195,6 +211,8 @@ export type MatchPlayerGroupByOutputType = {
   userId: string
   rank: number | null
   score: number | null
+  result: $Enums.MatchOutcome | null
+  xpDelta: number
   joinedAt: Date
   _count: MatchPlayerCountAggregateOutputType | null
   _avg: MatchPlayerAvgAggregateOutputType | null
@@ -227,6 +245,8 @@ export type MatchPlayerWhereInput = {
   userId?: Prisma.StringFilter<"MatchPlayer"> | string
   rank?: Prisma.IntNullableFilter<"MatchPlayer"> | number | null
   score?: Prisma.FloatNullableFilter<"MatchPlayer"> | number | null
+  result?: Prisma.EnumMatchOutcomeNullableFilter<"MatchPlayer"> | $Enums.MatchOutcome | null
+  xpDelta?: Prisma.IntFilter<"MatchPlayer"> | number
   joinedAt?: Prisma.DateTimeFilter<"MatchPlayer"> | Date | string
   match?: Prisma.XOR<Prisma.MatchScalarRelationFilter, Prisma.MatchWhereInput>
   user?: Prisma.XOR<Prisma.UserScalarRelationFilter, Prisma.UserWhereInput>
@@ -238,6 +258,8 @@ export type MatchPlayerOrderByWithRelationInput = {
   userId?: Prisma.SortOrder
   rank?: Prisma.SortOrderInput | Prisma.SortOrder
   score?: Prisma.SortOrderInput | Prisma.SortOrder
+  result?: Prisma.SortOrderInput | Prisma.SortOrder
+  xpDelta?: Prisma.SortOrder
   joinedAt?: Prisma.SortOrder
   match?: Prisma.MatchOrderByWithRelationInput
   user?: Prisma.UserOrderByWithRelationInput
@@ -253,6 +275,8 @@ export type MatchPlayerWhereUniqueInput = Prisma.AtLeast<{
   userId?: Prisma.StringFilter<"MatchPlayer"> | string
   rank?: Prisma.IntNullableFilter<"MatchPlayer"> | number | null
   score?: Prisma.FloatNullableFilter<"MatchPlayer"> | number | null
+  result?: Prisma.EnumMatchOutcomeNullableFilter<"MatchPlayer"> | $Enums.MatchOutcome | null
+  xpDelta?: Prisma.IntFilter<"MatchPlayer"> | number
   joinedAt?: Prisma.DateTimeFilter<"MatchPlayer"> | Date | string
   match?: Prisma.XOR<Prisma.MatchScalarRelationFilter, Prisma.MatchWhereInput>
   user?: Prisma.XOR<Prisma.UserScalarRelationFilter, Prisma.UserWhereInput>
@@ -264,6 +288,8 @@ export type MatchPlayerOrderByWithAggregationInput = {
   userId?: Prisma.SortOrder
   rank?: Prisma.SortOrderInput | Prisma.SortOrder
   score?: Prisma.SortOrderInput | Prisma.SortOrder
+  result?: Prisma.SortOrderInput | Prisma.SortOrder
+  xpDelta?: Prisma.SortOrder
   joinedAt?: Prisma.SortOrder
   _count?: Prisma.MatchPlayerCountOrderByAggregateInput
   _avg?: Prisma.MatchPlayerAvgOrderByAggregateInput
@@ -281,6 +307,8 @@ export type MatchPlayerScalarWhereWithAggregatesInput = {
   userId?: Prisma.StringWithAggregatesFilter<"MatchPlayer"> | string
   rank?: Prisma.IntNullableWithAggregatesFilter<"MatchPlayer"> | number | null
   score?: Prisma.FloatNullableWithAggregatesFilter<"MatchPlayer"> | number | null
+  result?: Prisma.EnumMatchOutcomeNullableWithAggregatesFilter<"MatchPlayer"> | $Enums.MatchOutcome | null
+  xpDelta?: Prisma.IntWithAggregatesFilter<"MatchPlayer"> | number
   joinedAt?: Prisma.DateTimeWithAggregatesFilter<"MatchPlayer"> | Date | string
 }
 
@@ -288,6 +316,8 @@ export type MatchPlayerCreateInput = {
   id?: string
   rank?: number | null
   score?: number | null
+  result?: $Enums.MatchOutcome | null
+  xpDelta?: number
   joinedAt?: Date | string
   match: Prisma.MatchCreateNestedOneWithoutPlayersInput
   user: Prisma.UserCreateNestedOneWithoutMatchPlayersInput
@@ -299,6 +329,8 @@ export type MatchPlayerUncheckedCreateInput = {
   userId: string
   rank?: number | null
   score?: number | null
+  result?: $Enums.MatchOutcome | null
+  xpDelta?: number
   joinedAt?: Date | string
 }
 
@@ -306,6 +338,8 @@ export type MatchPlayerUpdateInput = {
   id?: Prisma.StringFieldUpdateOperationsInput | string
   rank?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
   score?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  result?: Prisma.NullableEnumMatchOutcomeFieldUpdateOperationsInput | $Enums.MatchOutcome | null
+  xpDelta?: Prisma.IntFieldUpdateOperationsInput | number
   joinedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
   match?: Prisma.MatchUpdateOneRequiredWithoutPlayersNestedInput
   user?: Prisma.UserUpdateOneRequiredWithoutMatchPlayersNestedInput
@@ -317,6 +351,8 @@ export type MatchPlayerUncheckedUpdateInput = {
   userId?: Prisma.StringFieldUpdateOperationsInput | string
   rank?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
   score?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  result?: Prisma.NullableEnumMatchOutcomeFieldUpdateOperationsInput | $Enums.MatchOutcome | null
+  xpDelta?: Prisma.IntFieldUpdateOperationsInput | number
   joinedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
 }
 
@@ -326,6 +362,8 @@ export type MatchPlayerCreateManyInput = {
   userId: string
   rank?: number | null
   score?: number | null
+  result?: $Enums.MatchOutcome | null
+  xpDelta?: number
   joinedAt?: Date | string
 }
 
@@ -333,6 +371,8 @@ export type MatchPlayerUpdateManyMutationInput = {
   id?: Prisma.StringFieldUpdateOperationsInput | string
   rank?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
   score?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  result?: Prisma.NullableEnumMatchOutcomeFieldUpdateOperationsInput | $Enums.MatchOutcome | null
+  xpDelta?: Prisma.IntFieldUpdateOperationsInput | number
   joinedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
 }
 
@@ -342,6 +382,8 @@ export type MatchPlayerUncheckedUpdateManyInput = {
   userId?: Prisma.StringFieldUpdateOperationsInput | string
   rank?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
   score?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  result?: Prisma.NullableEnumMatchOutcomeFieldUpdateOperationsInput | $Enums.MatchOutcome | null
+  xpDelta?: Prisma.IntFieldUpdateOperationsInput | number
   joinedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
 }
 
@@ -366,12 +408,15 @@ export type MatchPlayerCountOrderByAggregateInput = {
   userId?: Prisma.SortOrder
   rank?: Prisma.SortOrder
   score?: Prisma.SortOrder
+  result?: Prisma.SortOrder
+  xpDelta?: Prisma.SortOrder
   joinedAt?: Prisma.SortOrder
 }
 
 export type MatchPlayerAvgOrderByAggregateInput = {
   rank?: Prisma.SortOrder
   score?: Prisma.SortOrder
+  xpDelta?: Prisma.SortOrder
 }
 
 export type MatchPlayerMaxOrderByAggregateInput = {
@@ -380,6 +425,8 @@ export type MatchPlayerMaxOrderByAggregateInput = {
   userId?: Prisma.SortOrder
   rank?: Prisma.SortOrder
   score?: Prisma.SortOrder
+  result?: Prisma.SortOrder
+  xpDelta?: Prisma.SortOrder
   joinedAt?: Prisma.SortOrder
 }
 
@@ -389,12 +436,15 @@ export type MatchPlayerMinOrderByAggregateInput = {
   userId?: Prisma.SortOrder
   rank?: Prisma.SortOrder
   score?: Prisma.SortOrder
+  result?: Prisma.SortOrder
+  xpDelta?: Prisma.SortOrder
   joinedAt?: Prisma.SortOrder
 }
 
 export type MatchPlayerSumOrderByAggregateInput = {
   rank?: Prisma.SortOrder
   score?: Prisma.SortOrder
+  xpDelta?: Prisma.SortOrder
 }
 
 export type MatchPlayerCreateNestedManyWithoutUserInput = {
@@ -497,10 +547,16 @@ export type NullableFloatFieldUpdateOperationsInput = {
   divide?: number
 }
 
+export type NullableEnumMatchOutcomeFieldUpdateOperationsInput = {
+  set?: $Enums.MatchOutcome | null
+}
+
 export type MatchPlayerCreateWithoutUserInput = {
   id?: string
   rank?: number | null
   score?: number | null
+  result?: $Enums.MatchOutcome | null
+  xpDelta?: number
   joinedAt?: Date | string
   match: Prisma.MatchCreateNestedOneWithoutPlayersInput
 }
@@ -510,6 +566,8 @@ export type MatchPlayerUncheckedCreateWithoutUserInput = {
   matchId: string
   rank?: number | null
   score?: number | null
+  result?: $Enums.MatchOutcome | null
+  xpDelta?: number
   joinedAt?: Date | string
 }
 
@@ -548,6 +606,8 @@ export type MatchPlayerScalarWhereInput = {
   userId?: Prisma.StringFilter<"MatchPlayer"> | string
   rank?: Prisma.IntNullableFilter<"MatchPlayer"> | number | null
   score?: Prisma.FloatNullableFilter<"MatchPlayer"> | number | null
+  result?: Prisma.EnumMatchOutcomeNullableFilter<"MatchPlayer"> | $Enums.MatchOutcome | null
+  xpDelta?: Prisma.IntFilter<"MatchPlayer"> | number
   joinedAt?: Prisma.DateTimeFilter<"MatchPlayer"> | Date | string
 }
 
@@ -555,6 +615,8 @@ export type MatchPlayerCreateWithoutMatchInput = {
   id?: string
   rank?: number | null
   score?: number | null
+  result?: $Enums.MatchOutcome | null
+  xpDelta?: number
   joinedAt?: Date | string
   user: Prisma.UserCreateNestedOneWithoutMatchPlayersInput
 }
@@ -564,6 +626,8 @@ export type MatchPlayerUncheckedCreateWithoutMatchInput = {
   userId: string
   rank?: number | null
   score?: number | null
+  result?: $Enums.MatchOutcome | null
+  xpDelta?: number
   joinedAt?: Date | string
 }
 
@@ -598,6 +662,8 @@ export type MatchPlayerCreateManyUserInput = {
   matchId: string
   rank?: number | null
   score?: number | null
+  result?: $Enums.MatchOutcome | null
+  xpDelta?: number
   joinedAt?: Date | string
 }
 
@@ -605,6 +671,8 @@ export type MatchPlayerUpdateWithoutUserInput = {
   id?: Prisma.StringFieldUpdateOperationsInput | string
   rank?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
   score?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  result?: Prisma.NullableEnumMatchOutcomeFieldUpdateOperationsInput | $Enums.MatchOutcome | null
+  xpDelta?: Prisma.IntFieldUpdateOperationsInput | number
   joinedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
   match?: Prisma.MatchUpdateOneRequiredWithoutPlayersNestedInput
 }
@@ -614,6 +682,8 @@ export type MatchPlayerUncheckedUpdateWithoutUserInput = {
   matchId?: Prisma.StringFieldUpdateOperationsInput | string
   rank?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
   score?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  result?: Prisma.NullableEnumMatchOutcomeFieldUpdateOperationsInput | $Enums.MatchOutcome | null
+  xpDelta?: Prisma.IntFieldUpdateOperationsInput | number
   joinedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
 }
 
@@ -622,6 +692,8 @@ export type MatchPlayerUncheckedUpdateManyWithoutUserInput = {
   matchId?: Prisma.StringFieldUpdateOperationsInput | string
   rank?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
   score?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  result?: Prisma.NullableEnumMatchOutcomeFieldUpdateOperationsInput | $Enums.MatchOutcome | null
+  xpDelta?: Prisma.IntFieldUpdateOperationsInput | number
   joinedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
 }
 
@@ -630,6 +702,8 @@ export type MatchPlayerCreateManyMatchInput = {
   userId: string
   rank?: number | null
   score?: number | null
+  result?: $Enums.MatchOutcome | null
+  xpDelta?: number
   joinedAt?: Date | string
 }
 
@@ -637,6 +711,8 @@ export type MatchPlayerUpdateWithoutMatchInput = {
   id?: Prisma.StringFieldUpdateOperationsInput | string
   rank?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
   score?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  result?: Prisma.NullableEnumMatchOutcomeFieldUpdateOperationsInput | $Enums.MatchOutcome | null
+  xpDelta?: Prisma.IntFieldUpdateOperationsInput | number
   joinedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
   user?: Prisma.UserUpdateOneRequiredWithoutMatchPlayersNestedInput
 }
@@ -646,6 +722,8 @@ export type MatchPlayerUncheckedUpdateWithoutMatchInput = {
   userId?: Prisma.StringFieldUpdateOperationsInput | string
   rank?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
   score?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  result?: Prisma.NullableEnumMatchOutcomeFieldUpdateOperationsInput | $Enums.MatchOutcome | null
+  xpDelta?: Prisma.IntFieldUpdateOperationsInput | number
   joinedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
 }
 
@@ -654,6 +732,8 @@ export type MatchPlayerUncheckedUpdateManyWithoutMatchInput = {
   userId?: Prisma.StringFieldUpdateOperationsInput | string
   rank?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
   score?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
+  result?: Prisma.NullableEnumMatchOutcomeFieldUpdateOperationsInput | $Enums.MatchOutcome | null
+  xpDelta?: Prisma.IntFieldUpdateOperationsInput | number
   joinedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
 }
 
@@ -665,6 +745,8 @@ export type MatchPlayerSelect<ExtArgs extends runtime.Types.Extensions.InternalA
   userId?: boolean
   rank?: boolean
   score?: boolean
+  result?: boolean
+  xpDelta?: boolean
   joinedAt?: boolean
   match?: boolean | Prisma.MatchDefaultArgs<ExtArgs>
   user?: boolean | Prisma.UserDefaultArgs<ExtArgs>
@@ -676,6 +758,8 @@ export type MatchPlayerSelectCreateManyAndReturn<ExtArgs extends runtime.Types.E
   userId?: boolean
   rank?: boolean
   score?: boolean
+  result?: boolean
+  xpDelta?: boolean
   joinedAt?: boolean
   match?: boolean | Prisma.MatchDefaultArgs<ExtArgs>
   user?: boolean | Prisma.UserDefaultArgs<ExtArgs>
@@ -687,6 +771,8 @@ export type MatchPlayerSelectUpdateManyAndReturn<ExtArgs extends runtime.Types.E
   userId?: boolean
   rank?: boolean
   score?: boolean
+  result?: boolean
+  xpDelta?: boolean
   joinedAt?: boolean
   match?: boolean | Prisma.MatchDefaultArgs<ExtArgs>
   user?: boolean | Prisma.UserDefaultArgs<ExtArgs>
@@ -698,10 +784,12 @@ export type MatchPlayerSelectScalar = {
   userId?: boolean
   rank?: boolean
   score?: boolean
+  result?: boolean
+  xpDelta?: boolean
   joinedAt?: boolean
 }
 
-export type MatchPlayerOmit<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetOmit<"id" | "matchId" | "userId" | "rank" | "score" | "joinedAt", ExtArgs["result"]["matchPlayer"]>
+export type MatchPlayerOmit<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetOmit<"id" | "matchId" | "userId" | "rank" | "score" | "result" | "xpDelta" | "joinedAt", ExtArgs["result"]["matchPlayer"]>
 export type MatchPlayerInclude<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
   match?: boolean | Prisma.MatchDefaultArgs<ExtArgs>
   user?: boolean | Prisma.UserDefaultArgs<ExtArgs>
@@ -727,6 +815,8 @@ export type $MatchPlayerPayload<ExtArgs extends runtime.Types.Extensions.Interna
     userId: string
     rank: number | null
     score: number | null
+    result: $Enums.MatchOutcome | null
+    xpDelta: number
     joinedAt: Date
   }, ExtArgs["result"]["matchPlayer"]>
   composites: {}
@@ -1158,6 +1248,8 @@ export interface MatchPlayerFieldRefs {
   readonly userId: Prisma.FieldRef<"MatchPlayer", 'String'>
   readonly rank: Prisma.FieldRef<"MatchPlayer", 'Int'>
   readonly score: Prisma.FieldRef<"MatchPlayer", 'Float'>
+  readonly result: Prisma.FieldRef<"MatchPlayer", 'MatchOutcome'>
+  readonly xpDelta: Prisma.FieldRef<"MatchPlayer", 'Int'>
   readonly joinedAt: Prisma.FieldRef<"MatchPlayer", 'DateTime'>
 }
     
diff --git a/prisma/generated/prisma/models/User.ts b/prisma/generated/prisma/models/User.ts
index c3826ea..db33538 100644
--- a/prisma/generated/prisma/models/User.ts
+++ b/prisma/generated/prisma/models/User.ts
@@ -30,12 +30,16 @@ export type UserAvgAggregateOutputType = {
   elo: number | null
   totalWins: number | null
   totalMatches: number | null
+  totalXP: number | null
+  streak: number | null
 }
 
 export type UserSumAggregateOutputType = {
   elo: number | null
   totalWins: number | null
   totalMatches: number | null
+  totalXP: number | null
+  streak: number | null
 }
 
 export type UserMinAggregateOutputType = {
@@ -45,10 +49,13 @@ export type UserMinAggregateOutputType = {
   passwordHash: string | null
   displayName: string | null
   avatarUrl: string | null
+  title: string | null
   skillTier: $Enums.SkillTier | null
   elo: number | null
   totalWins: number | null
   totalMatches: number | null
+  totalXP: number | null
+  streak: number | null
   createdAt: Date | null
   updatedAt: Date | null
 }
@@ -60,10 +67,13 @@ export type UserMaxAggregateOutputType = {
   passwordHash: string | null
   displayName: string | null
   avatarUrl: string | null
+  title: string | null
   skillTier: $Enums.SkillTier | null
   elo: number | null
   totalWins: number | null
   totalMatches: number | null
+  totalXP: number | null
+  streak: number | null
   createdAt: Date | null
   updatedAt: Date | null
 }
@@ -75,10 +85,13 @@ export type UserCountAggregateOutputType = {
   passwordHash: number
   displayName: number
   avatarUrl: number
+  title: number
   skillTier: number
   elo: number
   totalWins: number
   totalMatches: number
+  totalXP: number
+  streak: number
   createdAt: number
   updatedAt: number
   _all: number
@@ -89,12 +102,16 @@ export type UserAvgAggregateInputType = {
   elo?: true
   totalWins?: true
   totalMatches?: true
+  totalXP?: true
+  streak?: true
 }
 
 export type UserSumAggregateInputType = {
   elo?: true
   totalWins?: true
   totalMatches?: true
+  totalXP?: true
+  streak?: true
 }
 
 export type UserMinAggregateInputType = {
@@ -104,10 +121,13 @@ export type UserMinAggregateInputType = {
   passwordHash?: true
   displayName?: true
   avatarUrl?: true
+  title?: true
   skillTier?: true
   elo?: true
   totalWins?: true
   totalMatches?: true
+  totalXP?: true
+  streak?: true
   createdAt?: true
   updatedAt?: true
 }
@@ -119,10 +139,13 @@ export type UserMaxAggregateInputType = {
   passwordHash?: true
   displayName?: true
   avatarUrl?: true
+  title?: true
   skillTier?: true
   elo?: true
   totalWins?: true
   totalMatches?: true
+  totalXP?: true
+  streak?: true
   createdAt?: true
   updatedAt?: true
 }
@@ -134,10 +157,13 @@ export type UserCountAggregateInputType = {
   passwordHash?: true
   displayName?: true
   avatarUrl?: true
+  title?: true
   skillTier?: true
   elo?: true
   totalWins?: true
   totalMatches?: true
+  totalXP?: true
+  streak?: true
   createdAt?: true
   updatedAt?: true
   _all?: true
@@ -236,10 +262,13 @@ export type UserGroupByOutputType = {
   passwordHash: string
   displayName: string | null
   avatarUrl: string | null
+  title: string
   skillTier: $Enums.SkillTier
   elo: number
   totalWins: number
   totalMatches: number
+  totalXP: number
+  streak: number
   createdAt: Date
   updatedAt: Date
   _count: UserCountAggregateOutputType | null
@@ -274,10 +303,13 @@ export type UserWhereInput = {
   passwordHash?: Prisma.StringFilter<"User"> | string
   displayName?: Prisma.StringNullableFilter<"User"> | string | null
   avatarUrl?: Prisma.StringNullableFilter<"User"> | string | null
+  title?: Prisma.StringFilter<"User"> | string
   skillTier?: Prisma.EnumSkillTierFilter<"User"> | $Enums.SkillTier
   elo?: Prisma.IntFilter<"User"> | number
   totalWins?: Prisma.IntFilter<"User"> | number
   totalMatches?: Prisma.IntFilter<"User"> | number
+  totalXP?: Prisma.IntFilter<"User"> | number
+  streak?: Prisma.IntFilter<"User"> | number
   createdAt?: Prisma.DateTimeFilter<"User"> | Date | string
   updatedAt?: Prisma.DateTimeFilter<"User"> | Date | string
   submissions?: Prisma.SubmissionListRelationFilter
@@ -292,10 +324,13 @@ export type UserOrderByWithRelationInput = {
   passwordHash?: Prisma.SortOrder
   displayName?: Prisma.SortOrderInput | Prisma.SortOrder
   avatarUrl?: Prisma.SortOrderInput | Prisma.SortOrder
+  title?: Prisma.SortOrder
   skillTier?: Prisma.SortOrder
   elo?: Prisma.SortOrder
   totalWins?: Prisma.SortOrder
   totalMatches?: Prisma.SortOrder
+  totalXP?: Prisma.SortOrder
+  streak?: Prisma.SortOrder
   createdAt?: Prisma.SortOrder
   updatedAt?: Prisma.SortOrder
   submissions?: Prisma.SubmissionOrderByRelationAggregateInput
@@ -313,10 +348,13 @@ export type UserWhereUniqueInput = Prisma.AtLeast<{
   passwordHash?: Prisma.StringFilter<"User"> | string
   displayName?: Prisma.StringNullableFilter<"User"> | string | null
   avatarUrl?: Prisma.StringNullableFilter<"User"> | string | null
+  title?: Prisma.StringFilter<"User"> | string
   skillTier?: Prisma.EnumSkillTierFilter<"User"> | $Enums.SkillTier
   elo?: Prisma.IntFilter<"User"> | number
   totalWins?: Prisma.IntFilter<"User"> | number
   totalMatches?: Prisma.IntFilter<"User"> | number
+  totalXP?: Prisma.IntFilter<"User"> | number
+  streak?: Prisma.IntFilter<"User"> | number
   createdAt?: Prisma.DateTimeFilter<"User"> | Date | string
   updatedAt?: Prisma.DateTimeFilter<"User"> | Date | string
   submissions?: Prisma.SubmissionListRelationFilter
@@ -331,10 +369,13 @@ export type UserOrderByWithAggregationInput = {
   passwordHash?: Prisma.SortOrder
   displayName?: Prisma.SortOrderInput | Prisma.SortOrder
   avatarUrl?: Prisma.SortOrderInput | Prisma.SortOrder
+  title?: Prisma.SortOrder
   skillTier?: Prisma.SortOrder
   elo?: Prisma.SortOrder
   totalWins?: Prisma.SortOrder
   totalMatches?: Prisma.SortOrder
+  totalXP?: Prisma.SortOrder
+  streak?: Prisma.SortOrder
   createdAt?: Prisma.SortOrder
   updatedAt?: Prisma.SortOrder
   _count?: Prisma.UserCountOrderByAggregateInput
@@ -354,10 +395,13 @@ export type UserScalarWhereWithAggregatesInput = {
   passwordHash?: Prisma.StringWithAggregatesFilter<"User"> | string
   displayName?: Prisma.StringNullableWithAggregatesFilter<"User"> | string | null
   avatarUrl?: Prisma.StringNullableWithAggregatesFilter<"User"> | string | null
+  title?: Prisma.StringWithAggregatesFilter<"User"> | string
   skillTier?: Prisma.EnumSkillTierWithAggregatesFilter<"User"> | $Enums.SkillTier
   elo?: Prisma.IntWithAggregatesFilter<"User"> | number
   totalWins?: Prisma.IntWithAggregatesFilter<"User"> | number
   totalMatches?: Prisma.IntWithAggregatesFilter<"User"> | number
+  totalXP?: Prisma.IntWithAggregatesFilter<"User"> | number
+  streak?: Prisma.IntWithAggregatesFilter<"User"> | number
   createdAt?: Prisma.DateTimeWithAggregatesFilter<"User"> | Date | string
   updatedAt?: Prisma.DateTimeWithAggregatesFilter<"User"> | Date | string
 }
@@ -369,10 +413,13 @@ export type UserCreateInput = {
   passwordHash: string
   displayName?: string | null
   avatarUrl?: string | null
+  title?: string
   skillTier?: $Enums.SkillTier
   elo?: number
   totalWins?: number
   totalMatches?: number
+  totalXP?: number
+  streak?: number
   createdAt?: Date | string
   updatedAt?: Date | string
   submissions?: Prisma.SubmissionCreateNestedManyWithoutUserInput
@@ -387,10 +434,13 @@ export type UserUncheckedCreateInput = {
   passwordHash: string
   displayName?: string | null
   avatarUrl?: string | null
+  title?: string
   skillTier?: $Enums.SkillTier
   elo?: number
   totalWins?: number
   totalMatches?: number
+  totalXP?: number
+  streak?: number
   createdAt?: Date | string
   updatedAt?: Date | string
   submissions?: Prisma.SubmissionUncheckedCreateNestedManyWithoutUserInput
@@ -405,10 +455,13 @@ export type UserUpdateInput = {
   passwordHash?: Prisma.StringFieldUpdateOperationsInput | string
   displayName?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
   avatarUrl?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  title?: Prisma.StringFieldUpdateOperationsInput | string
   skillTier?: Prisma.EnumSkillTierFieldUpdateOperationsInput | $Enums.SkillTier
   elo?: Prisma.IntFieldUpdateOperationsInput | number
   totalWins?: Prisma.IntFieldUpdateOperationsInput | number
   totalMatches?: Prisma.IntFieldUpdateOperationsInput | number
+  totalXP?: Prisma.IntFieldUpdateOperationsInput | number
+  streak?: Prisma.IntFieldUpdateOperationsInput | number
   createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
   updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
   submissions?: Prisma.SubmissionUpdateManyWithoutUserNestedInput
@@ -423,10 +476,13 @@ export type UserUncheckedUpdateInput = {
   passwordHash?: Prisma.StringFieldUpdateOperationsInput | string
   displayName?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
   avatarUrl?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  title?: Prisma.StringFieldUpdateOperationsInput | string
   skillTier?: Prisma.EnumSkillTierFieldUpdateOperationsInput | $Enums.SkillTier
   elo?: Prisma.IntFieldUpdateOperationsInput | number
   totalWins?: Prisma.IntFieldUpdateOperationsInput | number
   totalMatches?: Prisma.IntFieldUpdateOperationsInput | number
+  totalXP?: Prisma.IntFieldUpdateOperationsInput | number
+  streak?: Prisma.IntFieldUpdateOperationsInput | number
   createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
   updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
   submissions?: Prisma.SubmissionUncheckedUpdateManyWithoutUserNestedInput
@@ -441,10 +497,13 @@ export type UserCreateManyInput = {
   passwordHash: string
   displayName?: string | null
   avatarUrl?: string | null
+  title?: string
   skillTier?: $Enums.SkillTier
   elo?: number
   totalWins?: number
   totalMatches?: number
+  totalXP?: number
+  streak?: number
   createdAt?: Date | string
   updatedAt?: Date | string
 }
@@ -456,10 +515,13 @@ export type UserUpdateManyMutationInput = {
   passwordHash?: Prisma.StringFieldUpdateOperationsInput | string
   displayName?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
   avatarUrl?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  title?: Prisma.StringFieldUpdateOperationsInput | string
   skillTier?: Prisma.EnumSkillTierFieldUpdateOperationsInput | $Enums.SkillTier
   elo?: Prisma.IntFieldUpdateOperationsInput | number
   totalWins?: Prisma.IntFieldUpdateOperationsInput | number
   totalMatches?: Prisma.IntFieldUpdateOperationsInput | number
+  totalXP?: Prisma.IntFieldUpdateOperationsInput | number
+  streak?: Prisma.IntFieldUpdateOperationsInput | number
   createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
   updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
 }
@@ -471,10 +533,13 @@ export type UserUncheckedUpdateManyInput = {
   passwordHash?: Prisma.StringFieldUpdateOperationsInput | string
   displayName?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
   avatarUrl?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  title?: Prisma.StringFieldUpdateOperationsInput | string
   skillTier?: Prisma.EnumSkillTierFieldUpdateOperationsInput | $Enums.SkillTier
   elo?: Prisma.IntFieldUpdateOperationsInput | number
   totalWins?: Prisma.IntFieldUpdateOperationsInput | number
   totalMatches?: Prisma.IntFieldUpdateOperationsInput | number
+  totalXP?: Prisma.IntFieldUpdateOperationsInput | number
+  streak?: Prisma.IntFieldUpdateOperationsInput | number
   createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
   updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
 }
@@ -486,10 +551,13 @@ export type UserCountOrderByAggregateInput = {
   passwordHash?: Prisma.SortOrder
   displayName?: Prisma.SortOrder
   avatarUrl?: Prisma.SortOrder
+  title?: Prisma.SortOrder
   skillTier?: Prisma.SortOrder
   elo?: Prisma.SortOrder
   totalWins?: Prisma.SortOrder
   totalMatches?: Prisma.SortOrder
+  totalXP?: Prisma.SortOrder
+  streak?: Prisma.SortOrder
   createdAt?: Prisma.SortOrder
   updatedAt?: Prisma.SortOrder
 }
@@ -498,6 +566,8 @@ export type UserAvgOrderByAggregateInput = {
   elo?: Prisma.SortOrder
   totalWins?: Prisma.SortOrder
   totalMatches?: Prisma.SortOrder
+  totalXP?: Prisma.SortOrder
+  streak?: Prisma.SortOrder
 }
 
 export type UserMaxOrderByAggregateInput = {
@@ -507,10 +577,13 @@ export type UserMaxOrderByAggregateInput = {
   passwordHash?: Prisma.SortOrder
   displayName?: Prisma.SortOrder
   avatarUrl?: Prisma.SortOrder
+  title?: Prisma.SortOrder
   skillTier?: Prisma.SortOrder
   elo?: Prisma.SortOrder
   totalWins?: Prisma.SortOrder
   totalMatches?: Prisma.SortOrder
+  totalXP?: Prisma.SortOrder
+  streak?: Prisma.SortOrder
   createdAt?: Prisma.SortOrder
   updatedAt?: Prisma.SortOrder
 }
@@ -522,10 +595,13 @@ export type UserMinOrderByAggregateInput = {
   passwordHash?: Prisma.SortOrder
   displayName?: Prisma.SortOrder
   avatarUrl?: Prisma.SortOrder
+  title?: Prisma.SortOrder
   skillTier?: Prisma.SortOrder
   elo?: Prisma.SortOrder
   totalWins?: Prisma.SortOrder
   totalMatches?: Prisma.SortOrder
+  totalXP?: Prisma.SortOrder
+  streak?: Prisma.SortOrder
   createdAt?: Prisma.SortOrder
   updatedAt?: Prisma.SortOrder
 }
@@ -534,6 +610,8 @@ export type UserSumOrderByAggregateInput = {
   elo?: Prisma.SortOrder
   totalWins?: Prisma.SortOrder
   totalMatches?: Prisma.SortOrder
+  totalXP?: Prisma.SortOrder
+  streak?: Prisma.SortOrder
 }
 
 export type UserScalarRelationFilter = {
@@ -614,10 +692,13 @@ export type UserCreateWithoutQueueEntriesInput = {
   passwordHash: string
   displayName?: string | null
   avatarUrl?: string | null
+  title?: string
   skillTier?: $Enums.SkillTier
   elo?: number
   totalWins?: number
   totalMatches?: number
+  totalXP?: number
+  streak?: number
   createdAt?: Date | string
   updatedAt?: Date | string
   submissions?: Prisma.SubmissionCreateNestedManyWithoutUserInput
@@ -631,10 +712,13 @@ export type UserUncheckedCreateWithoutQueueEntriesInput = {
   passwordHash: string
   displayName?: string | null
   avatarUrl?: string | null
+  title?: string
   skillTier?: $Enums.SkillTier
   elo?: number
   totalWins?: number
   totalMatches?: number
+  totalXP?: number
+  streak?: number
   createdAt?: Date | string
   updatedAt?: Date | string
   submissions?: Prisma.SubmissionUncheckedCreateNestedManyWithoutUserInput
@@ -664,10 +748,13 @@ export type UserUpdateWithoutQueueEntriesInput = {
   passwordHash?: Prisma.StringFieldUpdateOperationsInput | string
   displayName?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
   avatarUrl?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  title?: Prisma.StringFieldUpdateOperationsInput | string
   skillTier?: Prisma.EnumSkillTierFieldUpdateOperationsInput | $Enums.SkillTier
   elo?: Prisma.IntFieldUpdateOperationsInput | number
   totalWins?: Prisma.IntFieldUpdateOperationsInput | number
   totalMatches?: Prisma.IntFieldUpdateOperationsInput | number
+  totalXP?: Prisma.IntFieldUpdateOperationsInput | number
+  streak?: Prisma.IntFieldUpdateOperationsInput | number
   createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
   updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
   submissions?: Prisma.SubmissionUpdateManyWithoutUserNestedInput
@@ -681,10 +768,13 @@ export type UserUncheckedUpdateWithoutQueueEntriesInput = {
   passwordHash?: Prisma.StringFieldUpdateOperationsInput | string
   displayName?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
   avatarUrl?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  title?: Prisma.StringFieldUpdateOperationsInput | string
   skillTier?: Prisma.EnumSkillTierFieldUpdateOperationsInput | $Enums.SkillTier
   elo?: Prisma.IntFieldUpdateOperationsInput | number
   totalWins?: Prisma.IntFieldUpdateOperationsInput | number
   totalMatches?: Prisma.IntFieldUpdateOperationsInput | number
+  totalXP?: Prisma.IntFieldUpdateOperationsInput | number
+  streak?: Prisma.IntFieldUpdateOperationsInput | number
   createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
   updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
   submissions?: Prisma.SubmissionUncheckedUpdateManyWithoutUserNestedInput
@@ -698,10 +788,13 @@ export type UserCreateWithoutMatchPlayersInput = {
   passwordHash: string
   displayName?: string | null
   avatarUrl?: string | null
+  title?: string
   skillTier?: $Enums.SkillTier
   elo?: number
   totalWins?: number
   totalMatches?: number
+  totalXP?: number
+  streak?: number
   createdAt?: Date | string
   updatedAt?: Date | string
   submissions?: Prisma.SubmissionCreateNestedManyWithoutUserInput
@@ -715,10 +808,13 @@ export type UserUncheckedCreateWithoutMatchPlayersInput = {
   passwordHash: string
   displayName?: string | null
   avatarUrl?: string | null
+  title?: string
   skillTier?: $Enums.SkillTier
   elo?: number
   totalWins?: number
   totalMatches?: number
+  totalXP?: number
+  streak?: number
   createdAt?: Date | string
   updatedAt?: Date | string
   submissions?: Prisma.SubmissionUncheckedCreateNestedManyWithoutUserInput
@@ -748,10 +844,13 @@ export type UserUpdateWithoutMatchPlayersInput = {
   passwordHash?: Prisma.StringFieldUpdateOperationsInput | string
   displayName?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
   avatarUrl?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  title?: Prisma.StringFieldUpdateOperationsInput | string
   skillTier?: Prisma.EnumSkillTierFieldUpdateOperationsInput | $Enums.SkillTier
   elo?: Prisma.IntFieldUpdateOperationsInput | number
   totalWins?: Prisma.IntFieldUpdateOperationsInput | number
   totalMatches?: Prisma.IntFieldUpdateOperationsInput | number
+  totalXP?: Prisma.IntFieldUpdateOperationsInput | number
+  streak?: Prisma.IntFieldUpdateOperationsInput | number
   createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
   updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
   submissions?: Prisma.SubmissionUpdateManyWithoutUserNestedInput
@@ -765,10 +864,13 @@ export type UserUncheckedUpdateWithoutMatchPlayersInput = {
   passwordHash?: Prisma.StringFieldUpdateOperationsInput | string
   displayName?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
   avatarUrl?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  title?: Prisma.StringFieldUpdateOperationsInput | string
   skillTier?: Prisma.EnumSkillTierFieldUpdateOperationsInput | $Enums.SkillTier
   elo?: Prisma.IntFieldUpdateOperationsInput | number
   totalWins?: Prisma.IntFieldUpdateOperationsInput | number
   totalMatches?: Prisma.IntFieldUpdateOperationsInput | number
+  totalXP?: Prisma.IntFieldUpdateOperationsInput | number
+  streak?: Prisma.IntFieldUpdateOperationsInput | number
   createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
   updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
   submissions?: Prisma.SubmissionUncheckedUpdateManyWithoutUserNestedInput
@@ -782,10 +884,13 @@ export type UserCreateWithoutSubmissionsInput = {
   passwordHash: string
   displayName?: string | null
   avatarUrl?: string | null
+  title?: string
   skillTier?: $Enums.SkillTier
   elo?: number
   totalWins?: number
   totalMatches?: number
+  totalXP?: number
+  streak?: number
   createdAt?: Date | string
   updatedAt?: Date | string
   matchPlayers?: Prisma.MatchPlayerCreateNestedManyWithoutUserInput
@@ -799,10 +904,13 @@ export type UserUncheckedCreateWithoutSubmissionsInput = {
   passwordHash: string
   displayName?: string | null
   avatarUrl?: string | null
+  title?: string
   skillTier?: $Enums.SkillTier
   elo?: number
   totalWins?: number
   totalMatches?: number
+  totalXP?: number
+  streak?: number
   createdAt?: Date | string
   updatedAt?: Date | string
   matchPlayers?: Prisma.MatchPlayerUncheckedCreateNestedManyWithoutUserInput
@@ -832,10 +940,13 @@ export type UserUpdateWithoutSubmissionsInput = {
   passwordHash?: Prisma.StringFieldUpdateOperationsInput | string
   displayName?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
   avatarUrl?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  title?: Prisma.StringFieldUpdateOperationsInput | string
   skillTier?: Prisma.EnumSkillTierFieldUpdateOperationsInput | $Enums.SkillTier
   elo?: Prisma.IntFieldUpdateOperationsInput | number
   totalWins?: Prisma.IntFieldUpdateOperationsInput | number
   totalMatches?: Prisma.IntFieldUpdateOperationsInput | number
+  totalXP?: Prisma.IntFieldUpdateOperationsInput | number
+  streak?: Prisma.IntFieldUpdateOperationsInput | number
   createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
   updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
   matchPlayers?: Prisma.MatchPlayerUpdateManyWithoutUserNestedInput
@@ -849,10 +960,13 @@ export type UserUncheckedUpdateWithoutSubmissionsInput = {
   passwordHash?: Prisma.StringFieldUpdateOperationsInput | string
   displayName?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
   avatarUrl?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  title?: Prisma.StringFieldUpdateOperationsInput | string
   skillTier?: Prisma.EnumSkillTierFieldUpdateOperationsInput | $Enums.SkillTier
   elo?: Prisma.IntFieldUpdateOperationsInput | number
   totalWins?: Prisma.IntFieldUpdateOperationsInput | number
   totalMatches?: Prisma.IntFieldUpdateOperationsInput | number
+  totalXP?: Prisma.IntFieldUpdateOperationsInput | number
+  streak?: Prisma.IntFieldUpdateOperationsInput | number
   createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
   updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
   matchPlayers?: Prisma.MatchPlayerUncheckedUpdateManyWithoutUserNestedInput
@@ -915,10 +1029,13 @@ export type UserSelect<ExtArgs extends runtime.Types.Extensions.InternalArgs = r
   passwordHash?: boolean
   displayName?: boolean
   avatarUrl?: boolean
+  title?: boolean
   skillTier?: boolean
   elo?: boolean
   totalWins?: boolean
   totalMatches?: boolean
+  totalXP?: boolean
+  streak?: boolean
   createdAt?: boolean
   updatedAt?: boolean
   submissions?: boolean | Prisma.User$submissionsArgs<ExtArgs>
@@ -934,10 +1051,13 @@ export type UserSelectCreateManyAndReturn<ExtArgs extends runtime.Types.Extensio
   passwordHash?: boolean
   displayName?: boolean
   avatarUrl?: boolean
+  title?: boolean
   skillTier?: boolean
   elo?: boolean
   totalWins?: boolean
   totalMatches?: boolean
+  totalXP?: boolean
+  streak?: boolean
   createdAt?: boolean
   updatedAt?: boolean
 }, ExtArgs["result"]["user"]>
@@ -949,10 +1069,13 @@ export type UserSelectUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensio
   passwordHash?: boolean
   displayName?: boolean
   avatarUrl?: boolean
+  title?: boolean
   skillTier?: boolean
   elo?: boolean
   totalWins?: boolean
   totalMatches?: boolean
+  totalXP?: boolean
+  streak?: boolean
   createdAt?: boolean
   updatedAt?: boolean
 }, ExtArgs["result"]["user"]>
@@ -964,15 +1087,18 @@ export type UserSelectScalar = {
   passwordHash?: boolean
   displayName?: boolean
   avatarUrl?: boolean
+  title?: boolean
   skillTier?: boolean
   elo?: boolean
   totalWins?: boolean
   totalMatches?: boolean
+  totalXP?: boolean
+  streak?: boolean
   createdAt?: boolean
   updatedAt?: boolean
 }
 
-export type UserOmit<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetOmit<"id" | "username" | "email" | "passwordHash" | "displayName" | "avatarUrl" | "skillTier" | "elo" | "totalWins" | "totalMatches" | "createdAt" | "updatedAt", ExtArgs["result"]["user"]>
+export type UserOmit<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetOmit<"id" | "username" | "email" | "passwordHash" | "displayName" | "avatarUrl" | "title" | "skillTier" | "elo" | "totalWins" | "totalMatches" | "totalXP" | "streak" | "createdAt" | "updatedAt", ExtArgs["result"]["user"]>
 export type UserInclude<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
   submissions?: boolean | Prisma.User$submissionsArgs<ExtArgs>
   matchPlayers?: boolean | Prisma.User$matchPlayersArgs<ExtArgs>
@@ -996,10 +1122,13 @@ export type $UserPayload<ExtArgs extends runtime.Types.Extensions.InternalArgs =
     passwordHash: string
     displayName: string | null
     avatarUrl: string | null
+    title: string
     skillTier: $Enums.SkillTier
     elo: number
     totalWins: number
     totalMatches: number
+    totalXP: number
+    streak: number
     createdAt: Date
     updatedAt: Date
   }, ExtArgs["result"]["user"]>
@@ -1434,10 +1563,13 @@ export interface UserFieldRefs {
   readonly passwordHash: Prisma.FieldRef<"User", 'String'>
   readonly displayName: Prisma.FieldRef<"User", 'String'>
   readonly avatarUrl: Prisma.FieldRef<"User", 'String'>
+  readonly title: Prisma.FieldRef<"User", 'String'>
   readonly skillTier: Prisma.FieldRef<"User", 'SkillTier'>
   readonly elo: Prisma.FieldRef<"User", 'Int'>
   readonly totalWins: Prisma.FieldRef<"User", 'Int'>
   readonly totalMatches: Prisma.FieldRef<"User", 'Int'>
+  readonly totalXP: Prisma.FieldRef<"User", 'Int'>
+  readonly streak: Prisma.FieldRef<"User", 'Int'>
   readonly createdAt: Prisma.FieldRef<"User", 'DateTime'>
   readonly updatedAt: Prisma.FieldRef<"User", 'DateTime'>
 }
diff --git a/prisma/migrations/20260209192655_intial_migration/migration.sql b/prisma/migrations/20260209192655_intial_migration/migration.sql
new file mode 100644
index 0000000..4ac6b75
--- /dev/null
+++ b/prisma/migrations/20260209192655_intial_migration/migration.sql
@@ -0,0 +1,159 @@
+-- CreateEnum
+CREATE TYPE "SkillTier" AS ENUM ('BEGINNER', 'INTERMEDIATE', 'ADVANCED', 'PRO');
+
+-- CreateEnum
+CREATE TYPE "MatchStatus" AS ENUM ('WAITING', 'IN_PROGRESS', 'EVALUATING', 'COMPLETED', 'CANCELLED');
+
+-- CreateEnum
+CREATE TYPE "GameMode" AS ENUM ('FASTEST', 'SHORTEST', 'REVERSE', 'DEBUGGING');
+
+-- CreateEnum
+CREATE TYPE "Difficulty" AS ENUM ('EASY', 'MEDIUM', 'HARD');
+
+-- CreateTable
+CREATE TABLE "users" (
+    "id" TEXT NOT NULL,
+    "username" TEXT NOT NULL,
+    "email" TEXT NOT NULL,
+    "passwordHash" TEXT NOT NULL,
+    "displayName" TEXT,
+    "avatarUrl" TEXT,
+    "skillTier" "SkillTier" NOT NULL DEFAULT 'BEGINNER',
+    "elo" INTEGER NOT NULL DEFAULT 1000,
+    "totalWins" INTEGER NOT NULL DEFAULT 0,
+    "totalMatches" INTEGER NOT NULL DEFAULT 0,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+
+    CONSTRAINT "users_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "queue_entries" (
+    "id" TEXT NOT NULL,
+    "userId" TEXT NOT NULL,
+    "joinedAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "active" BOOLEAN NOT NULL DEFAULT true,
+
+    CONSTRAINT "queue_entries_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "matches" (
+    "id" TEXT NOT NULL,
+    "status" "MatchStatus" NOT NULL DEFAULT 'WAITING',
+    "mode" "GameMode" NOT NULL DEFAULT 'FASTEST',
+    "startedAt" TIMESTAMP(3),
+    "endedAt" TIMESTAMP(3),
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "threadTimeComplexity" TEXT,
+    "threadSpaceComplexity" TEXT,
+    "threadOriginality" TEXT,
+    "threadRanking" TEXT,
+
+    CONSTRAINT "matches_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "match_players" (
+    "id" TEXT NOT NULL,
+    "matchId" TEXT NOT NULL,
+    "userId" TEXT NOT NULL,
+    "rank" INTEGER,
+    "score" DOUBLE PRECISION,
+    "joinedAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "match_players_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "questions" (
+    "id" TEXT NOT NULL,
+    "title" TEXT NOT NULL,
+    "description" TEXT NOT NULL,
+    "difficulty" "Difficulty" NOT NULL DEFAULT 'MEDIUM',
+    "mode" "GameMode" NOT NULL DEFAULT 'FASTEST',
+    "brokenCode" TEXT,
+    "brokenLanguage" TEXT,
+    "expectedOutput" TEXT,
+    "testCases" JSONB,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+
+    CONSTRAINT "questions_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "match_questions" (
+    "id" TEXT NOT NULL,
+    "matchId" TEXT NOT NULL,
+    "questionId" TEXT NOT NULL,
+    "order" INTEGER NOT NULL DEFAULT 0,
+
+    CONSTRAINT "match_questions_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "submissions" (
+    "id" TEXT NOT NULL,
+    "matchId" TEXT NOT NULL,
+    "userId" TEXT NOT NULL,
+    "questionId" TEXT NOT NULL,
+    "code" TEXT NOT NULL,
+    "language" TEXT NOT NULL,
+    "charCount" INTEGER,
+    "stdout" TEXT,
+    "stderr" TEXT,
+    "exitCode" INTEGER,
+    "execTimeMs" INTEGER,
+    "testsPassed" INTEGER NOT NULL DEFAULT 0,
+    "testsTotal" INTEGER NOT NULL DEFAULT 0,
+    "timeComplexity" TEXT,
+    "timeScore" DOUBLE PRECISION,
+    "spaceComplexity" TEXT,
+    "spaceScore" DOUBLE PRECISION,
+    "originalityScore" DOUBLE PRECISION,
+    "relevanceScore" DOUBLE PRECISION,
+    "submittedAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "submissions_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE UNIQUE INDEX "users_username_key" ON "users"("username");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "users_email_key" ON "users"("email");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "queue_entries_userId_active_key" ON "queue_entries"("userId", "active");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "match_players_matchId_userId_key" ON "match_players"("matchId", "userId");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "match_questions_matchId_questionId_key" ON "match_questions"("matchId", "questionId");
+
+-- AddForeignKey
+ALTER TABLE "queue_entries" ADD CONSTRAINT "queue_entries_userId_fkey" FOREIGN KEY ("userId") REFERENCES "users"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "match_players" ADD CONSTRAINT "match_players_matchId_fkey" FOREIGN KEY ("matchId") REFERENCES "matches"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "match_players" ADD CONSTRAINT "match_players_userId_fkey" FOREIGN KEY ("userId") REFERENCES "users"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "match_questions" ADD CONSTRAINT "match_questions_matchId_fkey" FOREIGN KEY ("matchId") REFERENCES "matches"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "match_questions" ADD CONSTRAINT "match_questions_questionId_fkey" FOREIGN KEY ("questionId") REFERENCES "questions"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "submissions" ADD CONSTRAINT "submissions_matchId_fkey" FOREIGN KEY ("matchId") REFERENCES "matches"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "submissions" ADD CONSTRAINT "submissions_userId_fkey" FOREIGN KEY ("userId") REFERENCES "users"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "submissions" ADD CONSTRAINT "submissions_questionId_fkey" FOREIGN KEY ("questionId") REFERENCES "questions"("id") ON DELETE CASCADE ON UPDATE CASCADE;
diff --git a/prisma/migrations/20260209194024_sign_up_changes/migration.sql b/prisma/migrations/20260209194024_sign_up_changes/migration.sql
new file mode 100644
index 0000000..535afad
--- /dev/null
+++ b/prisma/migrations/20260209194024_sign_up_changes/migration.sql
@@ -0,0 +1,4 @@
+-- AlterTable
+ALTER TABLE "users" ADD COLUMN     "streak" INTEGER NOT NULL DEFAULT 0,
+ADD COLUMN     "title" TEXT NOT NULL DEFAULT 'Code Warrior',
+ADD COLUMN     "totalXP" INTEGER NOT NULL DEFAULT 0;
diff --git a/prisma/migrations/migration_lock.toml b/prisma/migrations/migration_lock.toml
new file mode 100644
index 0000000..044d57c
--- /dev/null
+++ b/prisma/migrations/migration_lock.toml
@@ -0,0 +1,3 @@
+# Please do not edit this file manually
+# It should be added in your version-control system (e.g., Git)
+provider = "postgresql"
diff --git a/prisma/schema.prisma b/prisma/schema.prisma
index 4f0df54..ecd8116 100644
--- a/prisma/schema.prisma
+++ b/prisma/schema.prisma
@@ -20,10 +20,13 @@ model User {
   passwordHash String
   displayName  String?
   avatarUrl    String?
+  title        String    @default("Code Warrior")
   skillTier    SkillTier @default(BEGINNER)
   elo          Int       @default(1000)
   totalWins    Int       @default(0)
   totalMatches Int       @default(0)
+  totalXP      Int       @default(0)
+  streak       Int       @default(0)
   createdAt    DateTime  @default(now())
   updatedAt    DateTime  @updatedAt
 
@@ -60,6 +63,7 @@ model QueueEntry {
 
 model Match {
   id          String      @id @default(cuid())
+  maxPlayers  Int         @default(3)
   status      MatchStatus @default(WAITING)
   mode        GameMode    @default(FASTEST)
   startedAt   DateTime?
@@ -95,12 +99,20 @@ enum GameMode {
   DEBUGGING      // Fix broken code
 }
 
+enum MatchOutcome {
+  WIN
+  LOSS
+  DRAW
+}
+
 model MatchPlayer {
   id        String   @id @default(cuid())
   matchId   String
   userId    String
   rank      Int?     // Final rank after evaluation
   score     Float?   // Final weighted score
+  result    MatchOutcome?
+  xpDelta   Int      @default(0)
   joinedAt  DateTime @default(now())
 
   match Match @relation(fields: [matchId], references: [id], onDelete: Cascade)

From 8ba9b3ef1ef30db6bfe823564e77b972b48f0033 Mon Sep 17 00:00:00 2001
From: POSTI-25 <jahnavisingh512@gmail.com>
Date: Tue, 10 Feb 2026 12:06:33 +0530
Subject: [PATCH 6/9] merge backend branch with backboard-main branch

---
 backbaord/evaluation.ts     | 583 ------------------------
 backbaord/index.ts          |   9 -
 backbaord/live-test.ts      | 657 ---------------------------
 backbaord/match.js          | 313 +++++++++++++
 backbaord/memory.ts         | 204 ---------
 backbaord/mock-test.ts      | 869 ------------------------------------
 backbaord/package.json      |   3 +
 backbaord/test/config.js    |   5 +
 backbaord/test/data.js      |  75 ++++
 backbaord/test/index.js     |  92 ++++
 backbaord/test/package.json |   3 +
 backbaord/testing.ts        |  39 --
 backbaord/tools.ts          | 223 ---------
 backbaord/types.ts          | 174 --------
 package-lock.json           | 527 +++-------------------
 package.json                |   2 +-
 16 files changed, 545 insertions(+), 3233 deletions(-)
 delete mode 100644 backbaord/evaluation.ts
 delete mode 100644 backbaord/index.ts
 delete mode 100644 backbaord/live-test.ts
 create mode 100644 backbaord/match.js
 delete mode 100644 backbaord/memory.ts
 delete mode 100644 backbaord/mock-test.ts
 create mode 100644 backbaord/package.json
 create mode 100644 backbaord/test/config.js
 create mode 100644 backbaord/test/data.js
 create mode 100644 backbaord/test/index.js
 create mode 100644 backbaord/test/package.json
 delete mode 100644 backbaord/testing.ts
 delete mode 100644 backbaord/tools.ts
 delete mode 100644 backbaord/types.ts

diff --git a/backbaord/evaluation.ts b/backbaord/evaluation.ts
deleted file mode 100644
index 8ecff07..0000000
--- a/backbaord/evaluation.ts
+++ /dev/null
@@ -1,583 +0,0 @@
-// ============================================================
-// Compile-n-Conquer — Evaluation Pipeline Engine
-// ============================================================
-// Orchestrates the 4-thread LLM evaluation pipeline via Backboard.io
-
-import { BackboardClient } from "backboard-sdk";
-import {
-  RoundSubmissions,
-  TimeComplexityResults,
-  SpaceComplexityResults,
-  OriginalityResults,
-  ComplexityResult,
-  OriginalityResult,
-  TestCaseResults,
-  ScoringWeights,
-  TiebreakerData,
-  RankedUser,
-  RoundEvaluation,
-  ScoreBreakdown,
-  EvaluationConfig,
-  DEFAULT_EVAL_CONFIG,
-} from "./types";
-import {
-  TIME_COMPLEXITY_TOOL,
-  SPACE_COMPLEXITY_TOOL,
-  ORIGINALITY_TOOL,
-  RANKING_TOOL,
-  SYSTEM_PROMPTS,
-} from "./tools";
-
-// Type for Backboard message responses
-type BBMessageResponse = {
-  content: string;
-  status: string;
-  toolCalls: Array<{
-    id: string;
-    function: { name: string; parsedArguments: any };
-  }> | null;
-  runId?: string;
-  threadId: string;
-};
-
-// ---- Helper: Build the batch prompt for a metric thread ----
-
-function buildBatchPrompt(
-  round: RoundSubmissions,
-  metricLabel: string
-): string {
-  let prompt = `## Round: ${round.roundId} — ${metricLabel} Analysis\n\n`;
-  prompt += `### Questions in this round:\n`;
-  for (const q of round.questions) {
-    prompt += `- **${q.id}** (${q.difficulty}): ${q.title}\n  ${q.description}\n\n`;
-  }
-
-  prompt += `### Submissions:\n\n`;
-  for (const sub of round.submissions) {
-    prompt += `#### User: ${sub.userId}\n`;
-    for (const resp of sub.responses) {
-      const question = round.questions.find((q) => q.id === resp.questionId);
-      prompt += `**Question ${resp.questionId}** (${resp.language}):\n`;
-      prompt += "```\n" + resp.code + "\n```\n\n";
-      prompt += `Call the tool for this submission with questionContext: "${question?.description || question?.title || resp.questionId}"\n\n`;
-    }
-  }
-
-  prompt += `\nAnalyze ALL submissions above. Call the tool once per submission.\n`;
-  return prompt;
-}
-
-// ---- Thread 1: Time Complexity ----
-
-export async function evaluateTimeComplexity(
-  client: BackboardClient,
-  round: RoundSubmissions,
-  config: EvaluationConfig = DEFAULT_EVAL_CONFIG
-): Promise<{ results: TimeComplexityResults; threadId: string }> {
-  const assistant = await client.createAssistant({
-    name: "CnC Time Complexity Analyzer",
-    system_prompt: SYSTEM_PROMPTS.timeComplexity,
-    tools: [TIME_COMPLEXITY_TOOL],
-  });
-
-  const thread = await client.createThread(assistant.assistantId);
-  const prompt = buildBatchPrompt(round, "Time Complexity");
-
-  let response = (await client.addMessage(thread.threadId, {
-    content: prompt,
-    llm_provider: config.llmProvider,
-    model_name: config.modelName,
-    stream: false,
-  })) as BBMessageResponse;
-
-  // Handle tool calls — collect all TC results
-  const results: Record<string, ComplexityResult[]> = {};
-  for (const sub of round.submissions) {
-    results[sub.userId] = [];
-  }
-
-  while (response.status === "REQUIRES_ACTION" && response.toolCalls) {
-    const toolOutputs = [];
-
-    for (const tc of response.toolCalls) {
-      if (tc.function.name === "analyze_time_complexity") {
-        const args = tc.function.parsedArguments;
-
-        // The LLM analyzed it — we acknowledge and capture
-        // In production, we could run our own static analysis here too
-        const analysisResult: ComplexityResult = {
-          questionId: args.questionContext || "unknown",
-          complexity: args.complexity || "unknown",
-          score: args.score || 50,
-          reasoning: args.reasoning || "No reasoning provided",
-        };
-
-        toolOutputs.push({
-          tool_call_id: tc.id,
-          output: JSON.stringify({
-            status: "recorded",
-            ...analysisResult,
-          }),
-        });
-      }
-    }
-
-    response = (await client.submitToolOutputs(
-      thread.threadId,
-      response.runId!,
-      toolOutputs,
-      false
-    )) as BBMessageResponse;
-  }
-
-  // Parse the final response content for structured results
-  const parsedResults = parseComplexityFromContent(
-    response.content,
-    round,
-    results
-  );
-
-  return {
-    results: {
-      roundId: round.roundId,
-      metric: "time_complexity",
-      results: parsedResults,
-    },
-    threadId: thread.threadId,
-  };
-}
-
-// ---- Thread 2: Space Complexity ----
-
-export async function evaluateSpaceComplexity(
-  client: BackboardClient,
-  round: RoundSubmissions,
-  config: EvaluationConfig = DEFAULT_EVAL_CONFIG
-): Promise<{ results: SpaceComplexityResults; threadId: string }> {
-  const assistant = await client.createAssistant({
-    name: "CnC Space Complexity Analyzer",
-    system_prompt: SYSTEM_PROMPTS.spaceComplexity,
-    tools: [SPACE_COMPLEXITY_TOOL],
-  });
-
-  const thread = await client.createThread(assistant.assistantId);
-  const prompt = buildBatchPrompt(round, "Space Complexity");
-
-  let response = (await client.addMessage(thread.threadId, {
-    content: prompt,
-    llm_provider: config.llmProvider,
-    model_name: config.modelName,
-    stream: false,
-  })) as BBMessageResponse;
-
-  const results: Record<string, ComplexityResult[]> = {};
-  for (const sub of round.submissions) {
-    results[sub.userId] = [];
-  }
-
-  while (response.status === "REQUIRES_ACTION" && response.toolCalls) {
-    const toolOutputs = [];
-
-    for (const tc of response.toolCalls) {
-      if (tc.function.name === "analyze_space_complexity") {
-        const args = tc.function.parsedArguments;
-        const analysisResult: ComplexityResult = {
-          questionId: args.questionContext || "unknown",
-          complexity: args.complexity || "unknown",
-          score: args.score || 50,
-          reasoning: args.reasoning || "No reasoning provided",
-        };
-
-        toolOutputs.push({
-          tool_call_id: tc.id,
-          output: JSON.stringify({ status: "recorded", ...analysisResult }),
-        });
-      }
-    }
-
-    response = (await client.submitToolOutputs(
-      thread.threadId,
-      response.runId!,
-      toolOutputs,
-      false
-    )) as BBMessageResponse;
-  }
-
-  const parsedResults = parseComplexityFromContent(
-    response.content,
-    round,
-    results
-  );
-
-  return {
-    results: {
-      roundId: round.roundId,
-      metric: "space_complexity",
-      results: parsedResults,
-    },
-    threadId: thread.threadId,
-  };
-}
-
-// ---- Thread 3: Originality & Relevance ----
-
-export async function evaluateOriginality(
-  client: BackboardClient,
-  round: RoundSubmissions,
-  config: EvaluationConfig = DEFAULT_EVAL_CONFIG
-): Promise<{ results: OriginalityResults; threadId: string }> {
-  const assistant = await client.createAssistant({
-    name: "CnC Originality Analyzer",
-    system_prompt: SYSTEM_PROMPTS.originality,
-    tools: [ORIGINALITY_TOOL],
-  });
-
-  const thread = await client.createThread(assistant.assistantId);
-  const prompt = buildBatchPrompt(round, "Originality & Relevance");
-
-  let response = (await client.addMessage(thread.threadId, {
-    content: prompt,
-    llm_provider: config.llmProvider,
-    model_name: config.modelName,
-    stream: false,
-  })) as BBMessageResponse;
-
-  const results: Record<string, OriginalityResult[]> = {};
-  for (const sub of round.submissions) {
-    results[sub.userId] = [];
-  }
-
-  while (response.status === "REQUIRES_ACTION" && response.toolCalls) {
-    const toolOutputs = [];
-
-    for (const tc of response.toolCalls) {
-      if (tc.function.name === "analyze_originality") {
-        const args = tc.function.parsedArguments;
-        const analysisResult: OriginalityResult = {
-          questionId: args.questionContext || "unknown",
-          originalityScore: args.originalityScore || 5,
-          relevanceScore: args.relevanceScore || 5,
-          commentDensity: args.commentDensity || 0,
-          flags: args.flags || [],
-          reasoning: args.reasoning || "No reasoning provided",
-        };
-
-        toolOutputs.push({
-          tool_call_id: tc.id,
-          output: JSON.stringify({ status: "recorded", ...analysisResult }),
-        });
-      }
-    }
-
-    response = (await client.submitToolOutputs(
-      thread.threadId,
-      response.runId!,
-      toolOutputs,
-      false
-    )) as BBMessageResponse;
-  }
-
-  const parsedResults = parseOriginalityFromContent(
-    response.content,
-    round,
-    results
-  );
-
-  return {
-    results: {
-      roundId: round.roundId,
-      metric: "originality",
-      results: parsedResults,
-    },
-    threadId: thread.threadId,
-  };
-}
-
-// ---- Thread 4: Final Ranking ----
-
-export async function computeRanking(
-  client: BackboardClient,
-  tcResults: TimeComplexityResults,
-  scResults: SpaceComplexityResults,
-  origResults: OriginalityResults,
-  testCaseResults: TestCaseResults,
-  weights: ScoringWeights,
-  tiebreakerData: TiebreakerData,
-  config: EvaluationConfig = DEFAULT_EVAL_CONFIG
-): Promise<{ rankings: RankedUser[]; threadId: string }> {
-  const assistant = await client.createAssistant({
-    name: "CnC Ranking Engine",
-    system_prompt: SYSTEM_PROMPTS.ranking,
-    tools: [RANKING_TOOL],
-  });
-
-  const thread = await client.createThread(assistant.assistantId);
-
-  const prompt = `Compute the final ranking for round ${tcResults.roundId}.
-
-Use the compute_final_ranking tool with the following data:
-- timeComplexityResults: ${JSON.stringify(tcResults)}
-- spaceComplexityResults: ${JSON.stringify(scResults)}
-- originalityResults: ${JSON.stringify(origResults)}
-- testCaseResults: ${JSON.stringify(testCaseResults)}
-- weights: ${JSON.stringify(weights)}
-- tiebreakerData: ${JSON.stringify(tiebreakerData)}
-
-Produce a final ranking with full score breakdowns for each user.`;
-
-  let response = (await client.addMessage(thread.threadId, {
-    content: prompt,
-    llm_provider: config.llmProvider,
-    model_name: config.modelName,
-    stream: false,
-  })) as BBMessageResponse;
-
-  while (response.status === "REQUIRES_ACTION" && response.toolCalls) {
-    const toolOutputs = [];
-
-    for (const tc of response.toolCalls) {
-      if (tc.function.name === "compute_final_ranking") {
-        // Let the LLM compute the ranking via tool — we can also verify locally
-        const localRanking = computeRankingLocally(
-          tcResults,
-          scResults,
-          origResults,
-          testCaseResults,
-          weights,
-          tiebreakerData
-        );
-
-        toolOutputs.push({
-          tool_call_id: tc.id,
-          output: JSON.stringify({ rankings: localRanking }),
-        });
-      }
-    }
-
-    response = (await client.submitToolOutputs(
-      thread.threadId,
-      response.runId!,
-      toolOutputs,
-      false
-    )) as BBMessageResponse;
-  }
-
-  // Use local computation as source of truth (LLM is for validation)
-  const rankings = computeRankingLocally(
-    tcResults,
-    scResults,
-    origResults,
-    testCaseResults,
-    weights,
-    tiebreakerData
-  );
-
-  return { rankings, threadId: thread.threadId };
-}
-
-// ---- Local Scoring Engine (deterministic, no LLM needed) ----
-
-export function computeRankingLocally(
-  tcResults: TimeComplexityResults,
-  scResults: SpaceComplexityResults,
-  origResults: OriginalityResults,
-  testCaseResults: TestCaseResults,
-  weights: ScoringWeights,
-  tiebreakerData: TiebreakerData
-): RankedUser[] {
-  const userIds = Object.keys(tcResults.results);
-  const scored: Array<{
-    userId: string;
-    finalScore: number;
-    breakdown: ScoreBreakdown;
-    timeTakenMs: number;
-  }> = [];
-
-  for (const userId of userIds) {
-    const tcScores = tcResults.results[userId] || [];
-    const scScores = scResults.results[userId] || [];
-    const origScores = origResults.results[userId] || [];
-    const testCase = testCaseResults[userId] || { passed: 0, total: 1 };
-
-    // Average TC score (out of 100)
-    const avgTcScore =
-      tcScores.length > 0
-        ? tcScores.reduce((sum, r) => sum + r.score, 0) / tcScores.length
-        : 0;
-
-    // Average SC score (out of 100)
-    const avgScScore =
-      scScores.length > 0
-        ? scScores.reduce((sum, r) => sum + r.score, 0) / scScores.length
-        : 0;
-
-    // Average originality score: combine originality (1-10) and relevance (1-10) → normalize to 100
-    const avgOrigScore =
-      origScores.length > 0
-        ? origScores.reduce(
-            (sum, r) =>
-              sum + ((r.originalityScore + r.relevanceScore) / 2) * 10,
-            0
-          ) / origScores.length
-        : 0;
-
-    // Test case pass rate → scale to 100
-    const testCaseScore =
-      testCase.total > 0 ? (testCase.passed / testCase.total) * 100 : 0;
-
-    // Weighted final score
-    const finalScore =
-      avgTcScore * weights.timeComplexity +
-      avgScScore * weights.spaceComplexity +
-      avgOrigScore * weights.originality +
-      testCaseScore * weights.testCases;
-
-    scored.push({
-      userId,
-      finalScore: Math.round(finalScore * 100) / 100,
-      breakdown: {
-        timeComplexity: {
-          avgScore: Math.round(avgTcScore * 100) / 100,
-          weighted:
-            Math.round(avgTcScore * weights.timeComplexity * 100) / 100,
-        },
-        spaceComplexity: {
-          avgScore: Math.round(avgScScore * 100) / 100,
-          weighted:
-            Math.round(avgScScore * weights.spaceComplexity * 100) / 100,
-        },
-        originality: {
-          avgScore: Math.round(avgOrigScore * 100) / 100,
-          weighted:
-            Math.round(avgOrigScore * weights.originality * 100) / 100,
-        },
-        testCases: {
-          passRate: testCase.total > 0 ? testCase.passed / testCase.total : 0,
-          weighted:
-            Math.round(testCaseScore * weights.testCases * 100) / 100,
-        },
-      },
-      timeTakenMs: tiebreakerData[userId] || Infinity,
-    });
-  }
-
-  // Sort: highest score first, then lowest time (tiebreaker)
-  scored.sort((a, b) => {
-    if (b.finalScore !== a.finalScore) return b.finalScore - a.finalScore;
-    return a.timeTakenMs - b.timeTakenMs; // lower time wins
-  });
-
-  return scored.map((s, i) => ({
-    rank: i + 1,
-    ...s,
-  }));
-}
-
-// ---- Full Pipeline Orchestrator ----
-
-export async function runEvaluationPipeline(
-  round: RoundSubmissions,
-  testCaseResults: TestCaseResults,
-  tiebreakerData: TiebreakerData,
-  weights: ScoringWeights,
-  config: EvaluationConfig = DEFAULT_EVAL_CONFIG
-): Promise<RoundEvaluation> {
-  const client = new BackboardClient({
-    apiKey: process.env.BACKBOARD_API_KEY!,
-  });
-
-  // Threads 1-3 run in parallel
-  const [tcResult, scResult, origResult] = await Promise.all([
-    evaluateTimeComplexity(client, round, config),
-    evaluateSpaceComplexity(client, round, config),
-    evaluateOriginality(client, round, config),
-  ]);
-
-  // Thread 4: aggregation (depends on 1-3)
-  const rankingResult = await computeRanking(
-    client,
-    tcResult.results,
-    scResult.results,
-    origResult.results,
-    testCaseResults,
-    weights,
-    tiebreakerData,
-    config
-  );
-
-  return {
-    roundId: round.roundId,
-    evaluationId: `eval_${round.roundId}_${Date.now()}`,
-    rankings: rankingResult.rankings,
-    threadIds: {
-      timeComplexity: tcResult.threadId,
-      spaceComplexity: scResult.threadId,
-      originality: origResult.threadId,
-      ranking: rankingResult.threadId,
-    },
-    evaluatedAt: new Date().toISOString(),
-  };
-}
-
-// ---- Content Parsers (extract structured data from LLM final response) ----
-
-function parseComplexityFromContent(
-  content: string,
-  round: RoundSubmissions,
-  fallback: Record<string, ComplexityResult[]>
-): Record<string, ComplexityResult[]> {
-  // Try to parse JSON from LLM response
-  try {
-    const jsonMatch = content.match(/\{[\s\S]*\}/);
-    if (jsonMatch) {
-      const parsed = JSON.parse(jsonMatch[0]);
-      if (parsed.results) return parsed.results;
-    }
-  } catch {
-    // Fall through to fallback
-  }
-
-  // If parsing fails, return whatever was collected from tool calls
-  // or generate defaults
-  for (const sub of round.submissions) {
-    if (!fallback[sub.userId] || fallback[sub.userId].length === 0) {
-      fallback[sub.userId] = sub.responses.map((r) => ({
-        questionId: r.questionId,
-        complexity: "unknown",
-        score: 50,
-        reasoning: "Could not extract from LLM response",
-      }));
-    }
-  }
-  return fallback;
-}
-
-function parseOriginalityFromContent(
-  content: string,
-  round: RoundSubmissions,
-  fallback: Record<string, OriginalityResult[]>
-): Record<string, OriginalityResult[]> {
-  try {
-    const jsonMatch = content.match(/\{[\s\S]*\}/);
-    if (jsonMatch) {
-      const parsed = JSON.parse(jsonMatch[0]);
-      if (parsed.results) return parsed.results;
-    }
-  } catch {
-    // Fall through
-  }
-
-  for (const sub of round.submissions) {
-    if (!fallback[sub.userId] || fallback[sub.userId].length === 0) {
-      fallback[sub.userId] = sub.responses.map((r) => ({
-        questionId: r.questionId,
-        originalityScore: 5,
-        relevanceScore: 5,
-        commentDensity: 0,
-        flags: [],
-        reasoning: "Could not extract from LLM response",
-      }));
-    }
-  }
-  return fallback;
-}
diff --git a/backbaord/index.ts b/backbaord/index.ts
deleted file mode 100644
index 3656907..0000000
--- a/backbaord/index.ts
+++ /dev/null
@@ -1,9 +0,0 @@
-// ============================================================
-// Compile-n-Conquer — Backboard Evaluation Pipeline
-// ============================================================
-// Barrel export for all modules
-
-export * from "./types";
-export * from "./tools";
-export * from "./evaluation";
-export * from "./memory";
diff --git a/backbaord/live-test.ts b/backbaord/live-test.ts
deleted file mode 100644
index fc951bf..0000000
--- a/backbaord/live-test.ts
+++ /dev/null
@@ -1,657 +0,0 @@
-// ============================================================
-// Compile-n-Conquer — Live Backboard Integration Test
-// ============================================================
-// Tests the actual Backboard.io API with real LLM calls.
-//
-// Usage:
-//   set BACKBOARD_API_KEY=your_key_here
-//   npx tsx backbaord/live-test.ts
-//
-// Or create a .env.local file with BACKBOARD_API_KEY=...
-// and run: npx tsx backbaord/live-test.ts
-//
-// Flags:
-//   --thread=tc     Run only Time Complexity thread
-//   --thread=sc     Run only Space Complexity thread
-//   --thread=orig   Run only Originality thread
-//   --thread=rank   Run only Ranking thread (uses mock metric data)
-//   --thread=memory Run only Memory store/retrieve
-//   --all           Run full pipeline (default)
-// ============================================================
-
-// Use direct path import to avoid CJS/ESM export resolution issue with tsx
-import { BackboardClient } from "../node_modules/backboard-sdk/dist/index.js";
-import {
-  RoundSubmissions,
-  TimeComplexityResults,
-  SpaceComplexityResults,
-  OriginalityResults,
-  ComplexityResult,
-  OriginalityResult,
-  TestCaseResults,
-  ScoringWeights,
-  TiebreakerData,
-  DEFAULT_WEIGHTS,
-  DEFAULT_EVAL_CONFIG,
-  EvaluationConfig,
-} from "./types";
-import {
-  TIME_COMPLEXITY_TOOL,
-  SPACE_COMPLEXITY_TOOL,
-  ORIGINALITY_TOOL,
-  RANKING_TOOL,
-  SYSTEM_PROMPTS,
-} from "./tools";
-
-// ---- Load .env.local if present ----
-import { readFileSync } from "fs";
-import { resolve } from "path";
-try {
-  const envPath = resolve(__dirname, "..", ".env.local");
-  const envContent = readFileSync(envPath, "utf-8");
-  for (const line of envContent.split("\n")) {
-    const trimmed = line.trim();
-    if (trimmed && !trimmed.startsWith("#")) {
-      const eqIdx = trimmed.indexOf("=");
-      if (eqIdx > 0) {
-        const key = trimmed.slice(0, eqIdx).trim();
-        const val = trimmed.slice(eqIdx + 1).trim();
-        if (!process.env[key]) process.env[key] = val;
-      }
-    }
-  }
-} catch {
-  // No .env.local — that's fine, check process.env directly
-}
-
-// ---- Validate API Key ----
-const API_KEY = process.env.BACKBOARD_API_KEY;
-if (!API_KEY) {
-  console.error("❌ BACKBOARD_API_KEY not set.");
-  console.error("   Set it via: $env:BACKBOARD_API_KEY='your_key'");
-  console.error("   Or create .env.local with: BACKBOARD_API_KEY=your_key");
-  process.exit(1);
-}
-
-const client = new BackboardClient({ apiKey: API_KEY });
-const config: EvaluationConfig = DEFAULT_EVAL_CONFIG;
-
-// ---- Minimal test data (1 user, 1 question — fast & cheap) ----
-
-const MINI_ROUND: RoundSubmissions = {
-  roundId: "test_round_1",
-  questions: [
-    {
-      id: "q1",
-      title: "Two Sum",
-      description:
-        "Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target.",
-      difficulty: "easy",
-    },
-  ],
-  submissions: [
-    {
-      userId: "test_user_1",
-      responses: [
-        {
-          questionId: "q1",
-          language: "python",
-          submittedAt: new Date().toISOString(),
-          code: `def two_sum(nums, target):
-    seen = {}
-    for i, num in enumerate(nums):
-        comp = target - num
-        if comp in seen:
-            return [seen[comp], i]
-        seen[num] = i
-    return []`,
-        },
-      ],
-    },
-    {
-      userId: "test_user_2",
-      responses: [
-        {
-          questionId: "q1",
-          language: "python",
-          submittedAt: new Date().toISOString(),
-          code: `# This function solves the Two Sum problem
-# It takes an array of numbers and a target value
-# It returns the indices of two numbers that sum to target
-def two_sum(nums, target):
-    # Iterate through each element in the array
-    for i in range(len(nums)):
-        # Check every other element
-        for j in range(i + 1, len(nums)):
-            # If the two elements sum to target
-            if nums[i] + nums[j] == target:
-                # Return their indices
-                return [i, j]
-    # Return empty list if no solution found
-    return []`,
-        },
-      ],
-    },
-  ],
-};
-
-// ---- Type for Backboard responses ----
-type BBMessageResponse = {
-  content: string;
-  status: string;
-  toolCalls: Array<{
-    id: string;
-    function: { name: string; parsedArguments: any };
-  }> | null;
-  runId?: string;
-  threadId: string;
-  memoryOperationId?: string;
-};
-
-// ---- Helpers ----
-function hr(title: string) {
-  console.log(`\n${"=".repeat(60)}`);
-  console.log(`  ${title}`);
-  console.log("=".repeat(60));
-}
-
-function elapsed(start: number): string {
-  return `${((Date.now() - start) / 1000).toFixed(1)}s`;
-}
-
-// ============================================================
-// Thread 1: Time Complexity (Live)
-// ============================================================
-async function testTimeComplexity(): Promise<TimeComplexityResults | null> {
-  hr("Thread 1: Time Complexity Analysis (LIVE)");
-  const start = Date.now();
-
-  try {
-    console.log("  Creating assistant...");
-    const assistant = await client.createAssistant({
-      name: "CnC TC Test",
-      system_prompt: SYSTEM_PROMPTS.timeComplexity,
-      tools: [TIME_COMPLEXITY_TOOL],
-    });
-    console.log(`  ✅ Assistant created: ${assistant.assistantId}`);
-
-    console.log("  Creating thread...");
-    const thread = await client.createThread(assistant.assistantId);
-    console.log(`  ✅ Thread created: ${thread.threadId}`);
-
-    const prompt = buildPrompt(MINI_ROUND, "Time Complexity");
-    console.log("  Sending message to LLM...");
-
-    let response = (await client.addMessage(thread.threadId, {
-      content: prompt,
-      llm_provider: config.llmProvider,
-      model_name: config.modelName,
-      stream: false,
-    })) as BBMessageResponse;
-
-    console.log(`  Response status: ${response.status}`);
-
-    const collected: Record<string, ComplexityResult[]> = {};
-    for (const sub of MINI_ROUND.submissions) collected[sub.userId] = [];
-
-    let toolCallCount = 0;
-    while (response.status === "REQUIRES_ACTION" && response.toolCalls) {
-      console.log(`  Tool calls received: ${response.toolCalls.length}`);
-      const toolOutputs = [];
-
-      for (const tc of response.toolCalls) {
-        toolCallCount++;
-        const args = tc.function.parsedArguments;
-        console.log(
-          `    📞 Tool call #${toolCallCount}: ${tc.function.name}`
-        );
-        console.log(`       Args: ${JSON.stringify(args).slice(0, 200)}`);
-
-        toolOutputs.push({
-          tool_call_id: tc.id,
-          output: JSON.stringify({ status: "recorded", ...args }),
-        });
-      }
-
-      response = (await client.submitToolOutputs(
-        thread.threadId,
-        response.runId!,
-        toolOutputs,
-        false
-      )) as BBMessageResponse;
-      console.log(`  After submit — status: ${response.status}`);
-    }
-
-    console.log(`\n  📝 Final LLM response (first 500 chars):`);
-    console.log(`  ${response.content?.slice(0, 500) || "(empty)"}`);
-    console.log(`\n  ⏱️  Completed in ${elapsed(start)} | Tool calls: ${toolCallCount}`);
-
-    const results: TimeComplexityResults = {
-      roundId: MINI_ROUND.roundId,
-      metric: "time_complexity",
-      results: collected,
-    };
-    console.log("  ✅ Time Complexity thread PASSED");
-    return results;
-  } catch (err: any) {
-    console.error(`  ❌ FAILED: ${err.message}`);
-    return null;
-  }
-}
-
-// ============================================================
-// Thread 2: Space Complexity (Live)
-// ============================================================
-async function testSpaceComplexity(): Promise<SpaceComplexityResults | null> {
-  hr("Thread 2: Space Complexity Analysis (LIVE)");
-  const start = Date.now();
-
-  try {
-    const assistant = await client.createAssistant({
-      name: "CnC SC Test",
-      system_prompt: SYSTEM_PROMPTS.spaceComplexity,
-      tools: [SPACE_COMPLEXITY_TOOL],
-    });
-    console.log(`  ✅ Assistant: ${assistant.assistantId}`);
-
-    const thread = await client.createThread(assistant.assistantId);
-    console.log(`  ✅ Thread: ${thread.threadId}`);
-
-    const prompt = buildPrompt(MINI_ROUND, "Space Complexity");
-    console.log("  Sending message to LLM...");
-
-    let response = (await client.addMessage(thread.threadId, {
-      content: prompt,
-      llm_provider: config.llmProvider,
-      model_name: config.modelName,
-      stream: false,
-    })) as BBMessageResponse;
-
-    let toolCallCount = 0;
-    while (response.status === "REQUIRES_ACTION" && response.toolCalls) {
-      console.log(`  Tool calls received: ${response.toolCalls.length}`);
-      const toolOutputs = response.toolCalls.map((tc) => {
-        toolCallCount++;
-        console.log(`    📞 #${toolCallCount}: ${tc.function.name} — ${JSON.stringify(tc.function.parsedArguments).slice(0, 150)}`);
-        return {
-          tool_call_id: tc.id,
-          output: JSON.stringify({ status: "recorded", ...tc.function.parsedArguments }),
-        };
-      });
-
-      response = (await client.submitToolOutputs(
-        thread.threadId,
-        response.runId!,
-        toolOutputs,
-        false
-      )) as BBMessageResponse;
-    }
-
-    console.log(`\n  📝 Final response (first 500 chars):`);
-    console.log(`  ${response.content?.slice(0, 500) || "(empty)"}`);
-    console.log(`\n  ⏱️  ${elapsed(start)} | Tool calls: ${toolCallCount}`);
-    console.log("  ✅ Space Complexity thread PASSED");
-
-    return {
-      roundId: MINI_ROUND.roundId,
-      metric: "space_complexity",
-      results: {},
-    };
-  } catch (err: any) {
-    console.error(`  ❌ FAILED: ${err.message}`);
-    return null;
-  }
-}
-
-// ============================================================
-// Thread 3: Originality (Live)
-// ============================================================
-async function testOriginality(): Promise<OriginalityResults | null> {
-  hr("Thread 3: Originality & Relevance (LIVE)");
-  const start = Date.now();
-
-  try {
-    const assistant = await client.createAssistant({
-      name: "CnC Originality Test",
-      system_prompt: SYSTEM_PROMPTS.originality,
-      tools: [ORIGINALITY_TOOL],
-    });
-    console.log(`  ✅ Assistant: ${assistant.assistantId}`);
-
-    const thread = await client.createThread(assistant.assistantId);
-    console.log(`  ✅ Thread: ${thread.threadId}`);
-
-    const prompt = buildPrompt(MINI_ROUND, "Originality & Relevance");
-    console.log("  Sending message to LLM...");
-
-    let response = (await client.addMessage(thread.threadId, {
-      content: prompt,
-      llm_provider: config.llmProvider,
-      model_name: config.modelName,
-      stream: false,
-    })) as BBMessageResponse;
-
-    let toolCallCount = 0;
-    while (response.status === "REQUIRES_ACTION" && response.toolCalls) {
-      console.log(`  Tool calls received: ${response.toolCalls.length}`);
-      const toolOutputs = response.toolCalls.map((tc) => {
-        toolCallCount++;
-        const args = tc.function.parsedArguments;
-        console.log(`    📞 #${toolCallCount}: ${tc.function.name}`);
-        if (args.originalityScore !== undefined) {
-          console.log(
-            `       Originality: ${args.originalityScore}/10 | Relevance: ${args.relevanceScore}/10 | Comments: ${args.commentDensity}%`
-          );
-        }
-        if (args.flags?.length) {
-          console.log(`       🚩 Flags: ${args.flags.join(", ")}`);
-        }
-        return {
-          tool_call_id: tc.id,
-          output: JSON.stringify({ status: "recorded", ...args }),
-        };
-      });
-
-      response = (await client.submitToolOutputs(
-        thread.threadId,
-        response.runId!,
-        toolOutputs,
-        false
-      )) as BBMessageResponse;
-    }
-
-    console.log(`\n  📝 Final response (first 500 chars):`);
-    console.log(`  ${response.content?.slice(0, 500) || "(empty)"}`);
-    console.log(`\n  ⏱️  ${elapsed(start)} | Tool calls: ${toolCallCount}`);
-    console.log("  ✅ Originality thread PASSED");
-
-    return {
-      roundId: MINI_ROUND.roundId,
-      metric: "originality",
-      results: {},
-    };
-  } catch (err: any) {
-    console.error(`  ❌ FAILED: ${err.message}`);
-    return null;
-  }
-}
-
-// ============================================================
-// Thread 4: Ranking (Live — uses mock metric data)
-// ============================================================
-async function testRanking() {
-  hr("Thread 4: Final Ranking Aggregation (LIVE)");
-  const start = Date.now();
-
-  // Use mock metric data so this thread can run independently
-  const mockTC: TimeComplexityResults = {
-    roundId: "test_round_1",
-    metric: "time_complexity",
-    results: {
-      test_user_1: [{ questionId: "q1", complexity: "O(n)", score: 95, reasoning: "Hash map single pass" }],
-      test_user_2: [{ questionId: "q1", complexity: "O(n²)", score: 40, reasoning: "Brute force nested loops" }],
-    },
-  };
-  const mockSC: SpaceComplexityResults = {
-    roundId: "test_round_1",
-    metric: "space_complexity",
-    results: {
-      test_user_1: [{ questionId: "q1", complexity: "O(n)", score: 80, reasoning: "Hash map" }],
-      test_user_2: [{ questionId: "q1", complexity: "O(1)", score: 100, reasoning: "No extra space" }],
-    },
-  };
-  const mockOrig: OriginalityResults = {
-    roundId: "test_round_1",
-    metric: "originality",
-    results: {
-      test_user_1: [{ questionId: "q1", originalityScore: 9, relevanceScore: 10, commentDensity: 0, flags: [], reasoning: "Clean code" }],
-      test_user_2: [{ questionId: "q1", originalityScore: 3, relevanceScore: 9, commentDensity: 55, flags: ["excessive_comments"], reasoning: "AI-generated" }],
-    },
-  };
-  const testCases: TestCaseResults = {
-    test_user_1: { passed: 9, total: 10 },
-    test_user_2: { passed: 7, total: 10 },
-  };
-  const tiebreaker: TiebreakerData = {
-    test_user_1: 120000,
-    test_user_2: 180000,
-  };
-
-  try {
-    const assistant = await client.createAssistant({
-      name: "CnC Ranking Test",
-      system_prompt: SYSTEM_PROMPTS.ranking,
-      tools: [RANKING_TOOL],
-    });
-    console.log(`  ✅ Assistant: ${assistant.assistantId}`);
-
-    const thread = await client.createThread(assistant.assistantId);
-    console.log(`  ✅ Thread: ${thread.threadId}`);
-
-    const prompt = `Compute the final ranking for round test_round_1.
-
-Use the compute_final_ranking tool with:
-- timeComplexityResults: ${JSON.stringify(mockTC)}
-- spaceComplexityResults: ${JSON.stringify(mockSC)}
-- originalityResults: ${JSON.stringify(mockOrig)}
-- testCaseResults: ${JSON.stringify(testCases)}
-- weights: ${JSON.stringify(DEFAULT_WEIGHTS)}
-- tiebreakerData: ${JSON.stringify(tiebreaker)}
-
-Produce a final ranking with full score breakdowns.`;
-
-    console.log("  Sending message to LLM...");
-    let response = (await client.addMessage(thread.threadId, {
-      content: prompt,
-      llm_provider: config.llmProvider,
-      model_name: config.modelName,
-      stream: false,
-    })) as BBMessageResponse;
-
-    let toolCallCount = 0;
-    while (response.status === "REQUIRES_ACTION" && response.toolCalls) {
-      console.log(`  Tool calls received: ${response.toolCalls.length}`);
-      const toolOutputs = response.toolCalls.map((tc) => {
-        toolCallCount++;
-        console.log(`    📞 #${toolCallCount}: ${tc.function.name}`);
-        return {
-          tool_call_id: tc.id,
-          output: JSON.stringify({ status: "computed", message: "Rankings computed successfully" }),
-        };
-      });
-
-      response = (await client.submitToolOutputs(
-        thread.threadId,
-        response.runId!,
-        toolOutputs,
-        false
-      )) as BBMessageResponse;
-    }
-
-    console.log(`\n  📝 Final response (first 800 chars):`);
-    console.log(`  ${response.content?.slice(0, 800) || "(empty)"}`);
-    console.log(`\n  ⏱️  ${elapsed(start)} | Tool calls: ${toolCallCount}`);
-    console.log("  ✅ Ranking thread PASSED");
-  } catch (err: any) {
-    console.error(`  ❌ FAILED: ${err.message}`);
-  }
-}
-
-// ============================================================
-// Memory: Store & Retrieve (Live)
-// ============================================================
-async function testMemory() {
-  hr("Memory: Store & Retrieve Player Profile (LIVE)");
-  const start = Date.now();
-
-  try {
-    // Store
-    console.log("  Creating memory assistant...");
-    const assistant = await client.createAssistant({
-      name: "CnC Memory Test",
-      system_prompt: SYSTEM_PROMPTS.memory,
-    });
-    console.log(`  ✅ Assistant: ${assistant.assistantId}`);
-
-    const storeThread = await client.createThread(assistant.assistantId);
-    console.log(`  ✅ Store thread: ${storeThread.threadId}`);
-
-    const storeMsg = `
-Player Profile Update:
-
-User: test_user_live
-Current Tier: intermediate
-Average Score: 58.5
-
-Round History (last 3):
-- Round r1: Score 52, Rank #3
-- Round r2: Score 61, Rank #2
-- Round r3: Score 63, Rank #1
-
-Common Errors: Off-by-one errors, forgetting edge cases
-Preferred Algorithms: Binary Search, Hash Maps
-
-Remember this profile for personalized coaching.
-`;
-
-    console.log("  Storing player memory...");
-    const storeResponse = (await client.addMessage(storeThread.threadId, {
-      content: storeMsg,
-      memory: "Auto",
-      stream: false,
-    })) as BBMessageResponse;
-
-    console.log(`  Store response (first 300 chars): ${storeResponse.content?.slice(0, 300)}`);
-    console.log(`  Memory operation ID: ${storeResponse.memoryOperationId || "N/A"}`);
-
-    // Retrieve
-    const retrieveThread = await client.createThread(assistant.assistantId);
-    console.log(`\n  ✅ Retrieve thread: ${retrieveThread.threadId}`);
-    console.log("  Querying memory for test_user_live...");
-
-    const retrieveResponse = (await client.addMessage(retrieveThread.threadId, {
-      content:
-        "What do you remember about user test_user_live? What is their skill tier, common errors, and what coaching would you recommend?",
-      memory: "Auto",
-      stream: false,
-    })) as BBMessageResponse;
-
-    console.log(`\n  📝 Memory recall (first 600 chars):`);
-    console.log(`  ${retrieveResponse.content?.slice(0, 600) || "(empty)"}`);
-    console.log(`\n  ⏱️  ${elapsed(start)}`);
-    console.log("  ✅ Memory store/retrieve PASSED");
-  } catch (err: any) {
-    console.error(`  ❌ FAILED: ${err.message}`);
-  }
-}
-
-// ============================================================
-// Connectivity Check
-// ============================================================
-async function testConnection() {
-  hr("Connection Test");
-  try {
-    console.log("  Testing Backboard API connectivity...");
-    const assistant = await client.createAssistant({
-      name: "CnC Ping",
-      system_prompt: "Reply with 'pong'",
-    });
-    console.log(`  ✅ Connected! Assistant ID: ${assistant.assistantId}`);
-
-    const thread = await client.createThread(assistant.assistantId);
-    console.log(`  ✅ Thread created: ${thread.threadId}`);
-
-    const response = (await client.addMessage(thread.threadId, {
-      content: "ping",
-      llm_provider: config.llmProvider,
-      model_name: config.modelName,
-      stream: false,
-    })) as BBMessageResponse;
-
-    console.log(`  ✅ LLM responded: "${response.content?.slice(0, 100)}"`);
-    return true;
-  } catch (err: any) {
-    console.error(`  ❌ Connection failed: ${err.message}`);
-    return false;
-  }
-}
-
-// ---- Prompt builder (same logic as evaluation.ts) ----
-function buildPrompt(round: RoundSubmissions, label: string): string {
-  let p = `## Round: ${round.roundId} — ${label} Analysis\n\n`;
-  p += `### Questions:\n`;
-  for (const q of round.questions) {
-    p += `- **${q.id}** (${q.difficulty}): ${q.title}\n  ${q.description}\n\n`;
-  }
-  p += `### Submissions:\n\n`;
-  for (const sub of round.submissions) {
-    p += `#### User: ${sub.userId}\n`;
-    for (const resp of sub.responses) {
-      const q = round.questions.find((q) => q.id === resp.questionId);
-      p += `**Question ${resp.questionId}** (${resp.language}):\n`;
-      p += "```\n" + resp.code + "\n```\n\n";
-      p += `Call the tool for this submission with questionContext: "${q?.description || q?.title || resp.questionId}"\n\n`;
-    }
-  }
-  p += `\nAnalyze ALL submissions above. Call the tool once per submission.\n`;
-  return p;
-}
-
-// ============================================================
-// Main Runner
-// ============================================================
-async function main() {
-  const args = process.argv.slice(2);
-  const threadFlag = args.find((a) => a.startsWith("--thread="))?.split("=")[1];
-
-  console.log("\n🏟️  Compile-n-Conquer — Live Backboard Integration Test");
-  console.log(`   API Key: ${API_KEY!.slice(0, 8)}...${API_KEY!.slice(-4)}`);
-  console.log(`   Provider: ${config.llmProvider} / ${config.modelName}`);
-  console.log(`   Test scope: ${threadFlag || "all"}\n`);
-
-  // Always test connection first
-  const connected = await testConnection();
-  if (!connected) {
-    console.error("\n❌ Cannot reach Backboard API. Check your API key.");
-    process.exit(1);
-  }
-
-  const results: Record<string, boolean> = {};
-
-  if (!threadFlag || threadFlag === "all" || threadFlag === "tc") {
-    const r = await testTimeComplexity();
-    results["Time Complexity"] = r !== null;
-  }
-
-  if (!threadFlag || threadFlag === "all" || threadFlag === "sc") {
-    const r = await testSpaceComplexity();
-    results["Space Complexity"] = r !== null;
-  }
-
-  if (!threadFlag || threadFlag === "all" || threadFlag === "orig") {
-    const r = await testOriginality();
-    results["Originality"] = r !== null;
-  }
-
-  if (!threadFlag || threadFlag === "all" || threadFlag === "rank") {
-    await testRanking();
-    results["Ranking"] = true; // if it throws, catch sets it
-  }
-
-  if (!threadFlag || threadFlag === "all" || threadFlag === "memory") {
-    await testMemory();
-    results["Memory"] = true;
-  }
-
-  // Summary
-  hr("SUMMARY");
-  for (const [name, pass] of Object.entries(results)) {
-    console.log(`  ${pass ? "✅" : "❌"} ${name}`);
-  }
-  console.log("");
-}
-
-main().catch((err) => {
-  console.error("Fatal error:", err);
-  process.exit(1);
-});
diff --git a/backbaord/match.js b/backbaord/match.js
new file mode 100644
index 0000000..fd6d54e
--- /dev/null
+++ b/backbaord/match.js
@@ -0,0 +1,313 @@
+import { BackboardClient } from 'backboard-sdk';
+
+let _client = null;
+function getClient() {
+  if (!_client) {
+    _client = new BackboardClient({
+      apiKey: process.env.BACKBOARD_API_KEY,
+    });
+  }
+  return _client;
+}
+
+// ─── HELPERS ────────────────────────────────────────────────────
+
+function stripMarkdownFences(text) {
+  // Remove ```json ... ``` or ``` ... ``` wrappers
+  return text.replace(/^```(?:json)?\s*/i, '').replace(/\s*```\s*$/i, '').trim();
+}
+
+// ─── SYSTEM PROMPTS ─────────────────────────────────────────────
+
+const PLAYER_THREAD_SYSTEM_PROMPT = `You are a code analysis engine. You receive exactly 3 question-answer pairs.
+
+For each pair, return ONLY a JSON array of 3 objects with this exact schema:
+[
+  { "TC": "<Big-O string>", "SC": "<Big-O string>", "Context": <1 or 0> },
+  { "TC": "<Big-O string>", "SC": "<Big-O string>", "Context": <1 or 0> },
+  { "TC": "<Big-O string>", "SC": "<Big-O string>", "Context": <1 or 0> }
+]
+
+Rules:
+- TC = time complexity as Big-O string (e.g. "O(n)", "O(n log n)", "O(1)")
+- SC = space complexity as Big-O string
+- Context = 1 if the solution logically solves the given question
+- Context = 0 if incorrect or unrelated
+- If Context = 0, set TC = "O(inf)" and SC = "O(inf)"
+- Return ONLY the JSON array. No explanations, no markdown, no extra text.`;
+
+const COMPARISON_THREAD_SYSTEM_PROMPT = `You are a deterministic grading engine. You receive a JSON object with N players, each having 3 {TC, SC} pairs.
+
+For each question index (0, 1, 2), independently rank players on TC, then on SC.
+
+Ranking rules per metric (TC or SC) per question:
+- Parse complexities and rank from best (lowest) to worst (highest).
+- Assign points based on rank position: best gets N points, next gets N-1, ..., worst gets 1.
+- If players are tied on a metric, all tied players receive the same score: the average of the positions they span, floored. If ALL players are equal, each gets floor((N+1)/2) points.
+- Any player with "O(inf)" gets 0 points for that metric and is excluded from ranking.
+
+GrQx = TC_points + SC_points for question x.
+
+Output ONLY a JSON object:
+{
+  "Player1": [GrQ1, GrQ2, GrQ3],
+  "Player2": [GrQ1, GrQ2, GrQ3],
+  ...
+}
+
+No explanations, no markdown, no extra text. ONLY the JSON object.`;
+
+// ─── COMPLEXITY RANKING ─────────────────────────────────────────
+
+const COMPLEXITY_ORDER = [
+  'O(1)',
+  'O(log n)',
+  'O(sqrt(n))',
+  'O(n)',
+  'O(n log n)',
+  'O(n^2)',
+  'O(n^3)',
+  'O(2^n)',
+  'O(n!)',
+  'O(inf)',
+];
+
+function complexityRank(bigO) {
+  const normalized = bigO.replace(/\s+/g, '').toLowerCase();
+  const idx = COMPLEXITY_ORDER.findIndex(
+    (c) => c.replace(/\s+/g, '').toLowerCase() === normalized
+  );
+  return idx === -1 ? COMPLEXITY_ORDER.length - 1 : idx;
+}
+
+// ─── DETERMINISTIC COMPARISON (APP-SIDE FALLBACK) ───────────────
+
+function deterministicCompare(playersData) {
+  // playersData: { Player1: [{TC,SC},{TC,SC},{TC,SC}], ... }
+  const playerNames = Object.keys(playersData);
+  const N = playerNames.length;
+  const numQuestions = 3;
+
+  const result = {};
+  playerNames.forEach((p) => (result[p] = []));
+
+  for (let q = 0; q < numQuestions; q++) {
+    // Rank TC
+    const tcPoints = rankMetric(playerNames, playersData, q, 'TC', N);
+    // Rank SC
+    const scPoints = rankMetric(playerNames, playersData, q, 'SC', N);
+
+    playerNames.forEach((p) => {
+      result[p].push(tcPoints[p] + scPoints[p]);
+    });
+  }
+
+  return result;
+}
+
+function rankMetric(playerNames, playersData, questionIdx, metric, N) {
+  const points = {};
+  playerNames.forEach((p) => (points[p] = 0));
+
+  // Separate O(inf) players (0 points) from valid players
+  const validPlayers = [];
+  playerNames.forEach((p) => {
+    const val = playersData[p][questionIdx][metric];
+    if (val === 'O(inf)') {
+      points[p] = 0;
+    } else {
+      validPlayers.push({ name: p, value: val, rank: complexityRank(val) });
+    }
+  });
+
+  if (validPlayers.length === 0) return points;
+
+  // Sort by rank ascending (best first)
+  validPlayers.sort((a, b) => a.rank - b.rank);
+
+  // Assign points: best gets validPlayers.length points down to 1
+  // Handle ties: tied players share the average of their positions
+  let i = 0;
+  while (i < validPlayers.length) {
+    let j = i;
+    // Find all players tied with the same rank
+    while (j < validPlayers.length && validPlayers[j].rank === validPlayers[i].rank) {
+      j++;
+    }
+    // Positions i..j-1 are tied
+    // Points for position k (0-indexed) = N_valid - k  (so best=N_valid, worst=1)
+    // But we use validPlayers.length instead of N so excluded O(inf) don't take slots
+    const N_valid = validPlayers.length;
+    let sumPoints = 0;
+    for (let k = i; k < j; k++) {
+      sumPoints += N_valid - k;
+    }
+    const sharedPoints = Math.floor(sumPoints / (j - i));
+
+    for (let k = i; k < j; k++) {
+      points[validPlayers[k].name] = sharedPoints;
+    }
+    i = j;
+  }
+
+  return points;
+}
+
+// ─── MATCH ENGINE ───────────────────────────────────────────────
+
+/**
+ * Creates a match assistant and returns its ID.
+ */
+async function createMatchAssistant(matchId) {
+  const assistant = await getClient().createAssistant({
+    name: `Match-${matchId}`,
+    system_prompt: 'Match coordinator assistant',
+  });
+  return assistant.assistantId;
+}
+
+/**
+ * Creates a player thread within the match assistant.
+ * Returns { threadId, playerName }.
+ */
+async function createPlayerThread(assistantId, playerName) {
+  const thread = await getClient().createThread(assistantId);
+  return { threadId: thread.threadId, playerName };
+}
+
+/**
+ * Creates the comparison thread within the match assistant.
+ */
+async function createComparisonThread(assistantId) {
+  const thread = await getClient().createThread(assistantId);
+  return thread.threadId;
+}
+
+/**
+ * Sends a player's 3 Q&A pairs to their thread and returns parsed verdict.
+ * Input: answers = [ {question, answer}, {question, answer}, {question, answer} ]
+ * Output: [ {TC, SC, Context}, {TC, SC, Context}, {TC, SC, Context} ]
+ */
+async function evaluatePlayer(threadId, answers) {
+  const messageContent = JSON.stringify({
+    submissions: answers.map((a, i) => ({
+      [`Question${i + 1}`]: a.question,
+      [`Answer${i + 1}`]: a.answer,
+    })),
+  });
+
+  const response = await getClient().addMessage(threadId, {
+    content: `${PLAYER_THREAD_SYSTEM_PROMPT}\n\nInput:\n${messageContent}`,
+    llm_provider: 'openai',
+    model_name: 'gpt-4o',
+    stream: false,
+  });
+
+  const parsed = JSON.parse(stripMarkdownFences(response.content));
+
+  // Enforce Context=0 → O(inf) rule
+  return parsed.map((entry) => {
+    if (entry.Context === 0) {
+      return { TC: 'O(inf)', SC: 'O(inf)', Context: 0 };
+    }
+    return { TC: entry.TC, SC: entry.SC, Context: entry.Context };
+  });
+}
+
+/**
+ * Sends aggregated results to comparison thread and returns grades.
+ * Also runs app-side deterministic comparison as the canonical result.
+ *
+ * Input: playerResults = { Player1: [{TC,SC,Context},...], ... }
+ * Output: { Player1: [GrQ1, GrQ2, GrQ3], ... }
+ */
+async function compareAndGrade(comparisonThreadId, playerResults) {
+  // Strip Context field — comparison only needs TC and SC
+  const comparisonPayload = {};
+  for (const [player, results] of Object.entries(playerResults)) {
+    comparisonPayload[player] = results.map((r) => ({ TC: r.TC, SC: r.SC }));
+  }
+
+  // App-side deterministic comparison (canonical source of truth)
+  const deterministicResult = deterministicCompare(comparisonPayload);
+
+  // Also send to comparison thread for cross-validation (optional)
+  const messageContent = JSON.stringify(comparisonPayload);
+
+  await getClient().addMessage(comparisonThreadId, {
+    content: `${COMPARISON_THREAD_SYSTEM_PROMPT}\n\nInput:\n${messageContent}`,
+    llm_provider: 'openai',
+    model_name: 'gpt-4o',
+    stream: false,
+  });
+
+  // Use deterministic app-side result as the canonical output
+  return deterministicResult;
+}
+
+// ─── FULL MATCH FLOW ────────────────────────────────────────────
+
+/**
+ * Runs a complete match.
+ *
+ * Input:
+ *   matchId: string
+ *   players: [
+ *     {
+ *       name: "Player1",
+ *       answers: [
+ *         { question: "...", answer: "..." },
+ *         { question: "...", answer: "..." },
+ *         { question: "...", answer: "..." }
+ *       ]
+ *     },
+ *     ...
+ *   ]
+ *
+ * Output:
+ *   {
+ *     assistantId: string,
+ *     playerResults: { Player1: [{TC,SC,Context},...], ... },
+ *     grades: { Player1: [GrQ1, GrQ2, GrQ3], ... }
+ *   }
+ */
+async function runMatch(matchId, players) {
+  // 1. Create match assistant
+  const assistantId = await createMatchAssistant(matchId);
+
+  // 2. Create player threads + comparison thread in parallel
+  const playerThreadPromises = players.map((p) =>
+    createPlayerThread(assistantId, p.name)
+  );
+  const comparisonThreadPromise = createComparisonThread(assistantId);
+
+  const playerThreads = await Promise.all(playerThreadPromises);
+  const comparisonThreadId = await comparisonThreadPromise;
+
+  // 3. Evaluate all players in parallel
+  const evaluationPromises = players.map((p, i) =>
+    evaluatePlayer(playerThreads[i].threadId, p.answers)
+  );
+  const evaluations = await Promise.all(evaluationPromises);
+
+  // 4. Aggregate results
+  const playerResults = {};
+  players.forEach((p, i) => {
+    playerResults[p.name] = evaluations[i];
+  });
+
+  // 5. Run comparison
+  const grades = await compareAndGrade(comparisonThreadId, playerResults);
+
+  return { assistantId, playerResults, grades };
+}
+
+export {
+  createMatchAssistant,
+  createPlayerThread,
+  createComparisonThread,
+  evaluatePlayer,
+  compareAndGrade,
+  deterministicCompare,
+  runMatch,
+};
diff --git a/backbaord/memory.ts b/backbaord/memory.ts
deleted file mode 100644
index 60b8b4c..0000000
--- a/backbaord/memory.ts
+++ /dev/null
@@ -1,204 +0,0 @@
-// ============================================================
-// Compile-n-Conquer — Memory / Skill Tier Engine
-// ============================================================
-
-import { BackboardClient } from "backboard-sdk";
-import {
-  PlayerProfile,
-  SkillTier,
-  RoundScore,
-  TierChange,
-  EvaluationConfig,
-  DEFAULT_EVAL_CONFIG,
-} from "./types";
-import { SYSTEM_PROMPTS } from "./tools";
-
-// ---- Skill Tier Thresholds ----
-
-const TIER_THRESHOLDS: Record<SkillTier, { min: number; max: number }> = {
-  beginner: { min: 0, max: 30 },
-  intermediate: { min: 30, max: 60 },
-  advanced: { min: 60, max: 85 },
-  pro: { min: 85, max: 100 },
-};
-
-const PROMOTION_STREAK = 3; // consecutive rounds needed to promote
-const DEMOTION_STREAK = 2;  // consecutive rounds needed to demote
-
-// ---- Classify Tier from Score ----
-
-export function classifyTier(avgScore: number): SkillTier {
-  if (avgScore >= TIER_THRESHOLDS.pro.min) return "pro";
-  if (avgScore >= TIER_THRESHOLDS.advanced.min) return "advanced";
-  if (avgScore >= TIER_THRESHOLDS.intermediate.min) return "intermediate";
-  return "beginner";
-}
-
-// ---- Check Promotion / Demotion ----
-
-export function evaluateTierChange(
-  currentTier: SkillTier,
-  roundHistory: RoundScore[]
-): { newTier: SkillTier; changed: boolean; reason: string } {
-  if (roundHistory.length === 0) {
-    return { newTier: currentTier, changed: false, reason: "No round history" };
-  }
-
-  const tierOrder: SkillTier[] = ["beginner", "intermediate", "advanced", "pro"];
-  const currentIdx = tierOrder.indexOf(currentTier);
-
-  // Check promotion (last N rounds all qualify for next tier)
-  if (currentIdx < tierOrder.length - 1) {
-    const nextTier = tierOrder[currentIdx + 1];
-    const nextThreshold = TIER_THRESHOLDS[nextTier].min;
-    const recentForPromotion = roundHistory.slice(-PROMOTION_STREAK);
-
-    if (
-      recentForPromotion.length >= PROMOTION_STREAK &&
-      recentForPromotion.every((r) => r.finalScore >= nextThreshold)
-    ) {
-      return {
-        newTier: nextTier,
-        changed: true,
-        reason: `${PROMOTION_STREAK} consecutive rounds with avg score ≥ ${nextThreshold} → promoted to ${nextTier}`,
-      };
-    }
-  }
-
-  // Check demotion (last N rounds all fall below current tier)
-  if (currentIdx > 0) {
-    const currentThreshold = TIER_THRESHOLDS[currentTier].min;
-    const recentForDemotion = roundHistory.slice(-DEMOTION_STREAK);
-
-    if (
-      recentForDemotion.length >= DEMOTION_STREAK &&
-      recentForDemotion.every((r) => r.finalScore < currentThreshold)
-    ) {
-      const prevTier = tierOrder[currentIdx - 1];
-      return {
-        newTier: prevTier,
-        changed: true,
-        reason: `${DEMOTION_STREAK} consecutive rounds with avg score < ${currentThreshold} → demoted to ${prevTier}`,
-      };
-    }
-  }
-
-  return { newTier: currentTier, changed: false, reason: "No tier change" };
-}
-
-// ---- Update Player Profile After a Round ----
-
-export function updatePlayerProfile(
-  profile: PlayerProfile,
-  roundScore: RoundScore
-): PlayerProfile {
-  const updatedHistory = [...profile.roundHistory, roundScore];
-
-  // Recalculate avg score from last 5 rounds
-  const recentRounds = updatedHistory.slice(-5);
-  const avgScore =
-    recentRounds.reduce((sum, r) => sum + r.finalScore, 0) /
-    recentRounds.length;
-
-  // Check tier change
-  const tierResult = evaluateTierChange(profile.skillTier, updatedHistory);
-
-  const promotionHistory = [...profile.promotionHistory];
-  if (tierResult.changed) {
-    promotionHistory.push({
-      from: profile.skillTier,
-      to: tierResult.newTier,
-      reason: tierResult.reason,
-      changedAt: new Date().toISOString(),
-    });
-  }
-
-  return {
-    ...profile,
-    skillTier: tierResult.newTier,
-    avgScore: Math.round(avgScore * 100) / 100,
-    roundHistory: updatedHistory,
-    promotionHistory,
-  };
-}
-
-// ---- Store Memory via Backboard ----
-
-export async function storePlayerMemory(
-  client: BackboardClient,
-  profile: PlayerProfile,
-  config: EvaluationConfig = DEFAULT_EVAL_CONFIG
-): Promise<{ threadId: string; memoryOperationId?: string }> {
-  const assistant = await client.createAssistant({
-    name: "CnC Player Memory Manager",
-    system_prompt: SYSTEM_PROMPTS.memory,
-  });
-
-  const thread = await client.createThread(assistant.assistantId);
-
-  const memoryMessage = `
-Player Profile Update:
-
-User: ${profile.userId}
-Current Tier: ${profile.skillTier}
-Average Score: ${profile.avgScore}
-
-Round History (last 5):
-${profile.roundHistory
-  .slice(-5)
-  .map((r) => `- Round ${r.roundId}: Score ${r.finalScore}, Rank #${r.rank}`)
-  .join("\n")}
-
-Common Errors: ${profile.commonErrors.join(", ") || "None recorded"}
-Preferred Algorithms: ${profile.preferredAlgorithms.join(", ") || "None recorded"}
-
-Tier Changes:
-${
-  profile.promotionHistory.length > 0
-    ? profile.promotionHistory
-        .slice(-3)
-        .map((tc) => `- ${tc.from} → ${tc.to}: ${tc.reason}`)
-        .join("\n")
-    : "No tier changes yet"
-}
-
-Remember this profile for personalized coaching and adaptive difficulty.
-`;
-
-  const response = (await client.addMessage(thread.threadId, {
-    content: memoryMessage,
-    memory: "Auto",
-    stream: false,
-  })) as any;
-
-  return {
-    threadId: thread.threadId,
-    memoryOperationId: response.memoryOperationId,
-  };
-}
-
-// ---- Retrieve Player Context from Memory ----
-
-export async function retrievePlayerMemory(
-  client: BackboardClient,
-  userId: string,
-  config: EvaluationConfig = DEFAULT_EVAL_CONFIG
-): Promise<{ content: string; threadId: string }> {
-  const assistant = await client.createAssistant({
-    name: "CnC Player Memory Manager",
-    system_prompt: SYSTEM_PROMPTS.memory,
-  });
-
-  const thread = await client.createThread(assistant.assistantId);
-
-  const response = (await client.addMessage(thread.threadId, {
-    content: `Retrieve everything you remember about user ${userId}. Provide their current skill tier, recent performance trends, areas for improvement, and personalized coaching recommendations.`,
-    memory: "Auto",
-    stream: false,
-  })) as any;
-
-  return {
-    content: response.content,
-    threadId: thread.threadId,
-  };
-}
diff --git a/backbaord/mock-test.ts b/backbaord/mock-test.ts
deleted file mode 100644
index 5c92d59..0000000
--- a/backbaord/mock-test.ts
+++ /dev/null
@@ -1,869 +0,0 @@
-// ============================================================
-// Compile-n-Conquer — Mock Test Suite
-// ============================================================
-// Run: npx tsx backbaord/mock-test.ts
-
-// NOTE: We import types directly and scoring/memory functions inline
-// to avoid pulling in backboard-sdk (which has ESM export issues in tsx).
-// In production, use the barrel export from ./index.ts
-
-import {
-  RoundSubmissions,
-  TimeComplexityResults,
-  SpaceComplexityResults,
-  OriginalityResults,
-  TestCaseResults,
-  ScoringWeights,
-  TiebreakerData,
-  DEFAULT_WEIGHTS,
-  PlayerProfile,
-  RoundScore,
-  RankedUser,
-  ScoreBreakdown,
-  SkillTier,
-} from "./types";
-
-// ---- Inline: computeRankingLocally (from evaluation.ts) ----
-
-function computeRankingLocally(
-  tcResults: TimeComplexityResults,
-  scResults: SpaceComplexityResults,
-  origResults: OriginalityResults,
-  testCaseResults: TestCaseResults,
-  weights: ScoringWeights,
-  tiebreakerData: TiebreakerData
-): RankedUser[] {
-  const userIds = Object.keys(tcResults.results);
-  const scored: Array<{
-    userId: string;
-    finalScore: number;
-    breakdown: ScoreBreakdown;
-    timeTakenMs: number;
-  }> = [];
-
-  for (const userId of userIds) {
-    const tcScores = tcResults.results[userId] || [];
-    const scScores = scResults.results[userId] || [];
-    const origScores = origResults.results[userId] || [];
-    const testCase = testCaseResults[userId] || { passed: 0, total: 1 };
-
-    const avgTcScore =
-      tcScores.length > 0
-        ? tcScores.reduce((sum, r) => sum + r.score, 0) / tcScores.length
-        : 0;
-    const avgScScore =
-      scScores.length > 0
-        ? scScores.reduce((sum, r) => sum + r.score, 0) / scScores.length
-        : 0;
-    const avgOrigScore =
-      origScores.length > 0
-        ? origScores.reduce(
-            (sum, r) =>
-              sum + ((r.originalityScore + r.relevanceScore) / 2) * 10,
-            0
-          ) / origScores.length
-        : 0;
-    const testCaseScore =
-      testCase.total > 0 ? (testCase.passed / testCase.total) * 100 : 0;
-
-    const finalScore =
-      avgTcScore * weights.timeComplexity +
-      avgScScore * weights.spaceComplexity +
-      avgOrigScore * weights.originality +
-      testCaseScore * weights.testCases;
-
-    scored.push({
-      userId,
-      finalScore: Math.round(finalScore * 100) / 100,
-      breakdown: {
-        timeComplexity: {
-          avgScore: Math.round(avgTcScore * 100) / 100,
-          weighted: Math.round(avgTcScore * weights.timeComplexity * 100) / 100,
-        },
-        spaceComplexity: {
-          avgScore: Math.round(avgScScore * 100) / 100,
-          weighted: Math.round(avgScScore * weights.spaceComplexity * 100) / 100,
-        },
-        originality: {
-          avgScore: Math.round(avgOrigScore * 100) / 100,
-          weighted: Math.round(avgOrigScore * weights.originality * 100) / 100,
-        },
-        testCases: {
-          passRate: testCase.total > 0 ? testCase.passed / testCase.total : 0,
-          weighted: Math.round(testCaseScore * weights.testCases * 100) / 100,
-        },
-      },
-      timeTakenMs: tiebreakerData[userId] || Infinity,
-    });
-  }
-
-  scored.sort((a, b) => {
-    if (b.finalScore !== a.finalScore) return b.finalScore - a.finalScore;
-    return a.timeTakenMs - b.timeTakenMs;
-  });
-
-  return scored.map((s, i) => ({ rank: i + 1, ...s }));
-}
-
-// ---- Inline: Tier functions (from memory.ts) ----
-
-const TIER_THRESHOLDS: Record<SkillTier, { min: number; max: number }> = {
-  beginner: { min: 0, max: 30 },
-  intermediate: { min: 30, max: 60 },
-  advanced: { min: 60, max: 85 },
-  pro: { min: 85, max: 100 },
-};
-
-function classifyTier(avgScore: number): SkillTier {
-  if (avgScore >= TIER_THRESHOLDS.pro.min) return "pro";
-  if (avgScore >= TIER_THRESHOLDS.advanced.min) return "advanced";
-  if (avgScore >= TIER_THRESHOLDS.intermediate.min) return "intermediate";
-  return "beginner";
-}
-
-function evaluateTierChange(
-  currentTier: SkillTier,
-  roundHistory: RoundScore[]
-): { newTier: SkillTier; changed: boolean; reason: string } {
-  if (roundHistory.length === 0) {
-    return { newTier: currentTier, changed: false, reason: "No round history" };
-  }
-  const tierOrder: SkillTier[] = ["beginner", "intermediate", "advanced", "pro"];
-  const currentIdx = tierOrder.indexOf(currentTier);
-
-  if (currentIdx < tierOrder.length - 1) {
-    const nextTier = tierOrder[currentIdx + 1];
-    const nextThreshold = TIER_THRESHOLDS[nextTier].min;
-    const recentForPromotion = roundHistory.slice(-3);
-    if (
-      recentForPromotion.length >= 3 &&
-      recentForPromotion.every((r) => r.finalScore >= nextThreshold)
-    ) {
-      return {
-        newTier: nextTier,
-        changed: true,
-        reason: `3 consecutive rounds with avg score ≥ ${nextThreshold} → promoted to ${nextTier}`,
-      };
-    }
-  }
-
-  if (currentIdx > 0) {
-    const currentThreshold = TIER_THRESHOLDS[currentTier].min;
-    const recentForDemotion = roundHistory.slice(-2);
-    if (
-      recentForDemotion.length >= 2 &&
-      recentForDemotion.every((r) => r.finalScore < currentThreshold)
-    ) {
-      const prevTier = tierOrder[currentIdx - 1];
-      return {
-        newTier: prevTier,
-        changed: true,
-        reason: `2 consecutive rounds with avg score < ${currentThreshold} → demoted to ${prevTier}`,
-      };
-    }
-  }
-
-  return { newTier: currentTier, changed: false, reason: "No tier change" };
-}
-
-function updatePlayerProfile(
-  profile: PlayerProfile,
-  roundScore: RoundScore
-): PlayerProfile {
-  const updatedHistory = [...profile.roundHistory, roundScore];
-  const recentRounds = updatedHistory.slice(-5);
-  const avgScore =
-    recentRounds.reduce((sum, r) => sum + r.finalScore, 0) / recentRounds.length;
-  const tierResult = evaluateTierChange(profile.skillTier, updatedHistory);
-  const promotionHistory = [...profile.promotionHistory];
-  if (tierResult.changed) {
-    promotionHistory.push({
-      from: profile.skillTier,
-      to: tierResult.newTier,
-      reason: tierResult.reason,
-      changedAt: new Date().toISOString(),
-    });
-  }
-  return {
-    ...profile,
-    skillTier: tierResult.newTier,
-    avgScore: Math.round(avgScore * 100) / 100,
-    roundHistory: updatedHistory,
-    promotionHistory,
-  };
-}
-
-// ============================================================
-// TEST DATA — 3 users, 3 questions, 1 round
-// ============================================================
-
-const MOCK_ROUND: RoundSubmissions = {
-  roundId: "round_1",
-  questions: [
-    {
-      id: "q1",
-      title: "Two Sum",
-      description: "Given an array of integers and a target, return indices of two numbers that add up to the target.",
-      difficulty: "easy",
-    },
-    {
-      id: "q2",
-      title: "Longest Substring Without Repeating Characters",
-      description: "Find the length of the longest substring without repeating characters.",
-      difficulty: "medium",
-    },
-    {
-      id: "q3",
-      title: "Merge K Sorted Lists",
-      description: "Merge k sorted linked lists into one sorted linked list.",
-      difficulty: "hard",
-    },
-  ],
-  submissions: [
-    {
-      userId: "user_1",
-      responses: [
-        {
-          questionId: "q1",
-          language: "python",
-          submittedAt: "2026-02-09T10:05:00Z",
-          code: `def two_sum(nums, target):
-    seen = {}
-    for i, num in enumerate(nums):
-        comp = target - num
-        if comp in seen:
-            return [seen[comp], i]
-        seen[num] = i
-    return []`,
-        },
-        {
-          questionId: "q2",
-          language: "python",
-          submittedAt: "2026-02-09T10:15:00Z",
-          code: `def length_of_longest_substring(s):
-    char_set = set()
-    l = 0
-    result = 0
-    for r in range(len(s)):
-        while s[r] in char_set:
-            char_set.remove(s[l])
-            l += 1
-        char_set.add(s[r])
-        result = max(result, r - l + 1)
-    return result`,
-        },
-        {
-          questionId: "q3",
-          language: "python",
-          submittedAt: "2026-02-09T10:30:00Z",
-          code: `import heapq
-def merge_k_lists(lists):
-    heap = []
-    for i, l in enumerate(lists):
-        if l:
-            heapq.heappush(heap, (l.val, i, l))
-    dummy = ListNode(0)
-    curr = dummy
-    while heap:
-        val, i, node = heapq.heappop(heap)
-        curr.next = node
-        curr = curr.next
-        if node.next:
-            heapq.heappush(heap, (node.next.val, i, node.next))
-    return dummy.next`,
-        },
-      ],
-    },
-    {
-      userId: "user_2",
-      responses: [
-        {
-          questionId: "q1",
-          language: "cpp",
-          submittedAt: "2026-02-09T10:03:00Z",
-          code: `vector<int> twoSum(vector<int>& nums, int target) {
-    // This function finds two numbers that sum to target
-    // It uses a brute force approach to check all pairs
-    // Time complexity: O(n^2)
-    // Space complexity: O(1)
-    for (int i = 0; i < nums.size(); i++) {
-        // Iterate through each element
-        for (int j = i + 1; j < nums.size(); j++) {
-            // Check if the pair sums to target
-            if (nums[i] + nums[j] == target) {
-                // Return the indices
-                return {i, j};
-            }
-        }
-    }
-    // Return empty if no pair found
-    return {};
-}`,
-        },
-        {
-          questionId: "q2",
-          language: "cpp",
-          submittedAt: "2026-02-09T10:18:00Z",
-          code: `int lengthOfLongestSubstring(string s) {
-    unordered_set<char> chars;
-    int l = 0, res = 0;
-    for (int r = 0; r < s.size(); r++) {
-        while (chars.count(s[r])) {
-            chars.erase(s[l]);
-            l++;
-        }
-        chars.insert(s[r]);
-        res = max(res, r - l + 1);
-    }
-    return res;
-}`,
-        },
-        {
-          questionId: "q3",
-          language: "cpp",
-          submittedAt: "2026-02-09T10:28:00Z",
-          code: `ListNode* mergeKLists(vector<ListNode*>& lists) {
-    auto cmp = [](ListNode* a, ListNode* b) { return a->val > b->val; };
-    priority_queue<ListNode*, vector<ListNode*>, decltype(cmp)> pq(cmp);
-    for (auto l : lists) if (l) pq.push(l);
-    ListNode dummy(0);
-    ListNode* curr = &dummy;
-    while (!pq.empty()) {
-        curr->next = pq.top(); pq.pop();
-        curr = curr->next;
-        if (curr->next) pq.push(curr->next);
-    }
-    return dummy.next;
-}`,
-        },
-      ],
-    },
-    {
-      userId: "user_3",
-      responses: [
-        {
-          questionId: "q1",
-          language: "javascript",
-          submittedAt: "2026-02-09T10:08:00Z",
-          code: `/**
- * @param {number[]} nums - Array of integers
- * @param {number} target - Target sum
- * @returns {number[]} - Indices of two numbers
- * @description This function implements the Two Sum algorithm
- * using a hash map for O(n) time complexity
- */
-function twoSum(nums, target) {
-    // Create a hash map to store values and their indices
-    const map = new Map();
-    // Iterate through each number in the array
-    for (let i = 0; i < nums.length; i++) {
-        // Calculate the complement
-        const complement = target - nums[i];
-        // Check if complement exists in our map
-        if (map.has(complement)) {
-            // Return the pair of indices
-            return [map.get(complement), i];
-        }
-        // Store current number and its index
-        map.set(nums[i], i);
-    }
-    // Return empty array if no solution found
-    return [];
-}`,
-        },
-        {
-          questionId: "q2",
-          language: "javascript",
-          submittedAt: "2026-02-09T10:22:00Z",
-          code: `function lengthOfLongestSubstring(s) {
-    let max = 0;
-    for (let i = 0; i < s.length; i++) {
-        let seen = new Set();
-        for (let j = i; j < s.length; j++) {
-            if (seen.has(s[j])) break;
-            seen.add(s[j]);
-            max = Math.max(max, j - i + 1);
-        }
-    }
-    return max;
-}`,
-        },
-        {
-          questionId: "q3",
-          language: "javascript",
-          submittedAt: "2026-02-09T10:40:00Z",
-          code: `// didnt finish this one
-function mergeKLists(lists) {
-    if (!lists.length) return null;
-    return lists[0]; // just returning first list lol
-}`,
-        },
-      ],
-    },
-  ],
-};
-
-// ---- Mock LLM Outputs (what Threads 1-3 would return) ----
-
-const MOCK_TC_RESULTS: TimeComplexityResults = {
-  roundId: "round_1",
-  metric: "time_complexity",
-  results: {
-    user_1: [
-      { questionId: "q1", complexity: "O(n)", score: 95, reasoning: "Single-pass hash map approach" },
-      { questionId: "q2", complexity: "O(n)", score: 92, reasoning: "Sliding window, each char processed at most twice" },
-      { questionId: "q3", complexity: "O(N log k)", score: 90, reasoning: "Min-heap with k elements" },
-    ],
-    user_2: [
-      { questionId: "q1", complexity: "O(n²)", score: 40, reasoning: "Brute force nested loops" },
-      { questionId: "q2", complexity: "O(n)", score: 92, reasoning: "Sliding window technique" },
-      { questionId: "q3", complexity: "O(N log k)", score: 90, reasoning: "Priority queue approach" },
-    ],
-    user_3: [
-      { questionId: "q1", complexity: "O(n)", score: 95, reasoning: "Hash map single pass" },
-      { questionId: "q2", complexity: "O(n²)", score: 35, reasoning: "Brute force nested loop approach" },
-      { questionId: "q3", complexity: "O(1)", score: 5, reasoning: "No real solution, just returns first list" },
-    ],
-  },
-};
-
-const MOCK_SC_RESULTS: SpaceComplexityResults = {
-  roundId: "round_1",
-  metric: "space_complexity",
-  results: {
-    user_1: [
-      { questionId: "q1", complexity: "O(n)", score: 80, reasoning: "Hash map stores up to n elements" },
-      { questionId: "q2", complexity: "O(min(n,m))", score: 85, reasoning: "Set bounded by alphabet size" },
-      { questionId: "q3", complexity: "O(k)", score: 90, reasoning: "Heap of size k" },
-    ],
-    user_2: [
-      { questionId: "q1", complexity: "O(1)", score: 100, reasoning: "No extra space" },
-      { questionId: "q2", complexity: "O(min(n,m))", score: 85, reasoning: "Set for window chars" },
-      { questionId: "q3", complexity: "O(k)", score: 90, reasoning: "Priority queue of size k" },
-    ],
-    user_3: [
-      { questionId: "q1", complexity: "O(n)", score: 80, reasoning: "Map stores values" },
-      { questionId: "q2", complexity: "O(n)", score: 70, reasoning: "New set per iteration, up to n" },
-      { questionId: "q3", complexity: "O(1)", score: 100, reasoning: "No extra space (but no real solution)" },
-    ],
-  },
-};
-
-const MOCK_ORIG_RESULTS: OriginalityResults = {
-  roundId: "round_1",
-  metric: "originality",
-  results: {
-    user_1: [
-      { questionId: "q1", originalityScore: 9, relevanceScore: 10, commentDensity: 0, flags: [], reasoning: "Clean, human-style competitive code" },
-      { questionId: "q2", originalityScore: 9, relevanceScore: 10, commentDensity: 0, flags: [], reasoning: "Idiomatic sliding window" },
-      { questionId: "q3", originalityScore: 8, relevanceScore: 10, commentDensity: 0, flags: [], reasoning: "Standard heap approach, well-written" },
-    ],
-    user_2: [
-      { questionId: "q1", originalityScore: 3, relevanceScore: 9, commentDensity: 55, flags: ["excessive_comments", "boilerplate_docstrings"], reasoning: "Every line has an explanatory comment — strong GPT signal" },
-      { questionId: "q2", originalityScore: 8, relevanceScore: 10, commentDensity: 0, flags: [], reasoning: "Clean competitive code" },
-      { questionId: "q3", originalityScore: 8, relevanceScore: 10, commentDensity: 0, flags: [], reasoning: "Concise and idiomatic" },
-    ],
-    user_3: [
-      { questionId: "q1", originalityScore: 2, relevanceScore: 10, commentDensity: 62, flags: ["excessive_comments", "boilerplate_docstrings", "generic_variable_names"], reasoning: "JSDoc + line-by-line comments strongly suggest AI generation" },
-      { questionId: "q2", originalityScore: 7, relevanceScore: 8, commentDensity: 0, flags: [], reasoning: "Human-style brute force" },
-      { questionId: "q3", originalityScore: 6, relevanceScore: 1, commentDensity: 10, flags: [], reasoning: "Honest comment about not finishing, but doesn't solve the problem" },
-    ],
-  },
-};
-
-const MOCK_TEST_CASES: TestCaseResults = {
-  user_1: { passed: 28, total: 30 },
-  user_2: { passed: 25, total: 30 },
-  user_3: { passed: 15, total: 30 },
-};
-
-const MOCK_TIEBREAKER: TiebreakerData = {
-  user_1: 1500000, // 25 min
-  user_2: 1500000, // 25 min (same as user_1 to test tiebreaker)
-  user_3: 1920000, // 32 min
-};
-
-// ============================================================
-// TEST RUNNER
-// ============================================================
-
-function assert(condition: boolean, message: string) {
-  if (condition) {
-    console.log(`  ✅ PASS: ${message}`);
-  } else {
-    console.error(`  ❌ FAIL: ${message}`);
-    process.exitCode = 1;
-  }
-}
-
-function section(title: string) {
-  console.log(`\n${"=".repeat(60)}`);
-  console.log(`  ${title}`);
-  console.log("=".repeat(60));
-}
-
-// ---- Test 1: Local Ranking Computation ----
-
-function testRankingComputation() {
-  section("Test 1: Ranking Computation with Default Weights");
-
-  const rankings = computeRankingLocally(
-    MOCK_TC_RESULTS,
-    MOCK_SC_RESULTS,
-    MOCK_ORIG_RESULTS,
-    MOCK_TEST_CASES,
-    DEFAULT_WEIGHTS,
-    MOCK_TIEBREAKER
-  );
-
-  console.log("\n  Rankings:");
-  for (const r of rankings) {
-    console.log(
-      `  #${r.rank} ${r.userId} — Score: ${r.finalScore} | TC: ${r.breakdown.timeComplexity.weighted} | SC: ${r.breakdown.spaceComplexity.weighted} | Orig: ${r.breakdown.originality.weighted} | Tests: ${r.breakdown.testCases.weighted}`
-    );
-  }
-
-  assert(rankings.length === 3, "3 users ranked");
-  assert(rankings[0].rank === 1, "Rank 1 assigned");
-  assert(rankings[1].rank === 2, "Rank 2 assigned");
-  assert(rankings[2].rank === 3, "Rank 3 assigned");
-  assert(rankings[0].finalScore >= rankings[1].finalScore, "Rank 1 score ≥ Rank 2 score");
-  assert(rankings[1].finalScore >= rankings[2].finalScore, "Rank 2 score ≥ Rank 3 score");
-  assert(rankings[0].userId === "user_1", "User 1 should be ranked first (best overall)");
-  assert(rankings[2].userId === "user_3", "User 3 should be ranked last (incomplete submission)");
-
-  return rankings;
-}
-
-// ---- Test 2: Tiebreaker Logic ----
-
-function testTiebreaker() {
-  section("Test 2: Tiebreaker — Same Scores, Different Times");
-
-  // Create identical scores for two users
-  const identicalTC: TimeComplexityResults = {
-    roundId: "round_tie",
-    metric: "time_complexity",
-    results: {
-      user_a: [{ questionId: "q1", complexity: "O(n)", score: 80, reasoning: "" }],
-      user_b: [{ questionId: "q1", complexity: "O(n)", score: 80, reasoning: "" }],
-    },
-  };
-  const identicalSC: SpaceComplexityResults = {
-    roundId: "round_tie",
-    metric: "space_complexity",
-    results: {
-      user_a: [{ questionId: "q1", complexity: "O(1)", score: 90, reasoning: "" }],
-      user_b: [{ questionId: "q1", complexity: "O(1)", score: 90, reasoning: "" }],
-    },
-  };
-  const identicalOrig: OriginalityResults = {
-    roundId: "round_tie",
-    metric: "originality",
-    results: {
-      user_a: [{ questionId: "q1", originalityScore: 8, relevanceScore: 9, commentDensity: 5, flags: [], reasoning: "" }],
-      user_b: [{ questionId: "q1", originalityScore: 8, relevanceScore: 9, commentDensity: 5, flags: [], reasoning: "" }],
-    },
-  };
-  const identicalTests: TestCaseResults = {
-    user_a: { passed: 9, total: 10 },
-    user_b: { passed: 9, total: 10 },
-  };
-
-  // user_b was faster
-  const tiebreaker: TiebreakerData = {
-    user_a: 300000, // 5 min
-    user_b: 180000, // 3 min — faster
-  };
-
-  const rankings = computeRankingLocally(
-    identicalTC,
-    identicalSC,
-    identicalOrig,
-    identicalTests,
-    DEFAULT_WEIGHTS,
-    tiebreaker
-  );
-
-  console.log("\n  Tied Rankings:");
-  for (const r of rankings) {
-    console.log(`  #${r.rank} ${r.userId} — Score: ${r.finalScore} | Time: ${r.timeTakenMs}ms`);
-  }
-
-  assert(rankings[0].finalScore === rankings[1].finalScore, "Scores are identical");
-  assert(rankings[0].userId === "user_b", "Faster user (user_b) wins tiebreaker");
-  assert(rankings[1].userId === "user_a", "Slower user (user_a) ranks second");
-}
-
-// ---- Test 3: Weight Sensitivity ----
-
-function testWeightSensitivity() {
-  section("Test 3: Weight Sensitivity — Test Cases Dominate");
-
-  const heavyTestWeights: ScoringWeights = {
-    timeComplexity: 0.05,
-    spaceComplexity: 0.05,
-    originality: 0.05,
-    testCases: 0.85, // test cases heavily weighted
-  };
-
-  const rankings = computeRankingLocally(
-    MOCK_TC_RESULTS,
-    MOCK_SC_RESULTS,
-    MOCK_ORIG_RESULTS,
-    MOCK_TEST_CASES,
-    heavyTestWeights,
-    MOCK_TIEBREAKER
-  );
-
-  console.log("\n  With heavy test-case weight (85%):");
-  for (const r of rankings) {
-    console.log(
-      `  #${r.rank} ${r.userId} — Score: ${r.finalScore} | Tests: ${r.breakdown.testCases.weighted} (${(r.breakdown.testCases.passRate * 100).toFixed(0)}%)`
-    );
-  }
-
-  assert(rankings[0].userId === "user_1", "User 1 still first (highest test pass rate)");
-  assert(
-    rankings[0].breakdown.testCases.weighted > rankings[0].breakdown.timeComplexity.weighted,
-    "Test case contribution dominates TC contribution"
-  );
-}
-
-// ---- Test 4: Edge Case — Single User ----
-
-function testSingleUser() {
-  section("Test 4: Edge Case — Single User Round");
-
-  const singleTC: TimeComplexityResults = {
-    roundId: "round_solo",
-    metric: "time_complexity",
-    results: {
-      solo_user: [{ questionId: "q1", complexity: "O(n)", score: 70, reasoning: "" }],
-    },
-  };
-  const singleSC: SpaceComplexityResults = {
-    roundId: "round_solo",
-    metric: "space_complexity",
-    results: {
-      solo_user: [{ questionId: "q1", complexity: "O(1)", score: 100, reasoning: "" }],
-    },
-  };
-  const singleOrig: OriginalityResults = {
-    roundId: "round_solo",
-    metric: "originality",
-    results: {
-      solo_user: [{ questionId: "q1", originalityScore: 7, relevanceScore: 8, commentDensity: 8, flags: [], reasoning: "" }],
-    },
-  };
-
-  const rankings = computeRankingLocally(
-    singleTC,
-    singleSC,
-    singleOrig,
-    { solo_user: { passed: 10, total: 10 } },
-    DEFAULT_WEIGHTS,
-    { solo_user: 120000 }
-  );
-
-  assert(rankings.length === 1, "Single user in rankings");
-  assert(rankings[0].rank === 1, "Solo user is rank 1");
-  assert(rankings[0].finalScore > 0, "Score is positive");
-  console.log(`  Solo user score: ${rankings[0].finalScore}`);
-}
-
-// ---- Test 5: Edge Case — Empty/Zero Submissions ----
-
-function testZeroScores() {
-  section("Test 5: Edge Case — All Zero Scores");
-
-  const zeroTC: TimeComplexityResults = {
-    roundId: "round_zero",
-    metric: "time_complexity",
-    results: {
-      user_x: [{ questionId: "q1", complexity: "unknown", score: 0, reasoning: "No code" }],
-    },
-  };
-  const zeroSC: SpaceComplexityResults = {
-    roundId: "round_zero",
-    metric: "space_complexity",
-    results: {
-      user_x: [{ questionId: "q1", complexity: "unknown", score: 0, reasoning: "No code" }],
-    },
-  };
-  const zeroOrig: OriginalityResults = {
-    roundId: "round_zero",
-    metric: "originality",
-    results: {
-      user_x: [{ questionId: "q1", originalityScore: 0, relevanceScore: 0, commentDensity: 0, flags: [], reasoning: "Empty" }],
-    },
-  };
-
-  const rankings = computeRankingLocally(
-    zeroTC,
-    zeroSC,
-    zeroOrig,
-    { user_x: { passed: 0, total: 10 } },
-    DEFAULT_WEIGHTS,
-    { user_x: 600000 }
-  );
-
-  assert(rankings.length === 1, "User still ranked");
-  assert(rankings[0].finalScore === 0, "Score is zero");
-}
-
-// ---- Test 6: Tier Classification ----
-
-function testTierClassification() {
-  section("Test 6: Skill Tier Classification");
-
-  assert(classifyTier(15) === "beginner", "Score 15 → beginner");
-  assert(classifyTier(29) === "beginner", "Score 29 → beginner");
-  assert(classifyTier(30) === "intermediate", "Score 30 → intermediate");
-  assert(classifyTier(59) === "intermediate", "Score 59 → intermediate");
-  assert(classifyTier(60) === "advanced", "Score 60 → advanced");
-  assert(classifyTier(84) === "advanced", "Score 84 → advanced");
-  assert(classifyTier(85) === "pro", "Score 85 → pro");
-  assert(classifyTier(100) === "pro", "Score 100 → pro");
-}
-
-// ---- Test 7: Tier Promotion ----
-
-function testTierPromotion() {
-  section("Test 7: Tier Promotion Logic");
-
-  const history: RoundScore[] = [
-    { roundId: "r1", finalScore: 65, rank: 1, evaluatedAt: "" },
-    { roundId: "r2", finalScore: 70, rank: 1, evaluatedAt: "" },
-    { roundId: "r3", finalScore: 72, rank: 2, evaluatedAt: "" },
-  ];
-
-  const result = evaluateTierChange("intermediate", history);
-  assert(result.changed === true, "Should be promoted");
-  assert(result.newTier === "advanced", "Promoted to advanced");
-  console.log(`  Reason: ${result.reason}`);
-}
-
-// ---- Test 8: Tier Demotion ----
-
-function testTierDemotion() {
-  section("Test 8: Tier Demotion Logic");
-
-  const history: RoundScore[] = [
-    { roundId: "r1", finalScore: 88, rank: 1, evaluatedAt: "" },
-    { roundId: "r2", finalScore: 50, rank: 3, evaluatedAt: "" },
-    { roundId: "r3", finalScore: 55, rank: 3, evaluatedAt: "" },
-  ];
-
-  const result = evaluateTierChange("advanced", history);
-  assert(result.changed === true, "Should be demoted");
-  assert(result.newTier === "intermediate", "Demoted to intermediate");
-  console.log(`  Reason: ${result.reason}`);
-}
-
-// ---- Test 9: No Tier Change ----
-
-function testNoTierChange() {
-  section("Test 9: No Tier Change — Inconsistent Performance");
-
-  const history: RoundScore[] = [
-    { roundId: "r1", finalScore: 70, rank: 1, evaluatedAt: "" },
-    { roundId: "r2", finalScore: 50, rank: 2, evaluatedAt: "" }, // dips below
-    { roundId: "r3", finalScore: 75, rank: 1, evaluatedAt: "" },
-  ];
-
-  const result = evaluateTierChange("intermediate", history);
-  assert(result.changed === false, "No change with inconsistent scores");
-}
-
-// ---- Test 10: Full Profile Update Flow ----
-
-function testProfileUpdate() {
-  section("Test 10: Full Player Profile Update");
-
-  const profile: PlayerProfile = {
-    userId: "test_user",
-    skillTier: "intermediate",
-    avgScore: 55,
-    roundHistory: [
-      { roundId: "r1", finalScore: 62, rank: 2, evaluatedAt: "" },
-      { roundId: "r2", finalScore: 68, rank: 1, evaluatedAt: "" },
-    ],
-    commonErrors: ["Off-by-one errors"],
-    preferredAlgorithms: ["Binary Search"],
-    promotionHistory: [],
-  };
-
-  const newRound: RoundScore = {
-    roundId: "r3",
-    finalScore: 71,
-    rank: 1,
-    evaluatedAt: new Date().toISOString(),
-  };
-
-  const updated = updatePlayerProfile(profile, newRound);
-
-  console.log(`  Before: ${profile.skillTier} (avg: ${profile.avgScore})`);
-  console.log(`  After:  ${updated.skillTier} (avg: ${updated.avgScore})`);
-  console.log(`  Rounds: ${updated.roundHistory.length}`);
-
-  assert(updated.roundHistory.length === 3, "Round added to history");
-  assert(updated.skillTier === "advanced", "Promoted to advanced after 3 rounds ≥ 60");
-  assert(updated.promotionHistory.length === 1, "Promotion recorded");
-  console.log(`  Promotion: ${updated.promotionHistory[0].reason}`);
-}
-
-// ---- Test 11: Score Breakdown Integrity ----
-
-function testScoreBreakdownIntegrity() {
-  section("Test 11: Score Breakdown Adds Up to Final Score");
-
-  const rankings = computeRankingLocally(
-    MOCK_TC_RESULTS,
-    MOCK_SC_RESULTS,
-    MOCK_ORIG_RESULTS,
-    MOCK_TEST_CASES,
-    DEFAULT_WEIGHTS,
-    MOCK_TIEBREAKER
-  );
-
-  for (const r of rankings) {
-    const sumOfWeighted =
-      r.breakdown.timeComplexity.weighted +
-      r.breakdown.spaceComplexity.weighted +
-      r.breakdown.originality.weighted +
-      r.breakdown.testCases.weighted;
-
-    const diff = Math.abs(sumOfWeighted - r.finalScore);
-    assert(
-      diff < 0.02, // allow tiny floating point drift
-      `${r.userId}: breakdown sum (${sumOfWeighted.toFixed(2)}) ≈ finalScore (${r.finalScore})`
-    );
-  }
-}
-
-// ============================================================
-// RUN ALL TESTS
-// ============================================================
-
-console.log("\n🏟️  Compile-n-Conquer — Evaluation Pipeline Mock Tests\n");
-
-testRankingComputation();
-testTiebreaker();
-testWeightSensitivity();
-testSingleUser();
-testZeroScores();
-testTierClassification();
-testTierPromotion();
-testTierDemotion();
-testNoTierChange();
-testProfileUpdate();
-testScoreBreakdownIntegrity();
-
-section("SUMMARY");
-console.log(
-  process.exitCode
-    ? "  ⚠️  Some tests FAILED. Check output above."
-    : "  🎉 All tests PASSED!"
-);
-console.log("");
diff --git a/backbaord/package.json b/backbaord/package.json
new file mode 100644
index 0000000..3dbc1ca
--- /dev/null
+++ b/backbaord/package.json
@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}
diff --git a/backbaord/test/config.js b/backbaord/test/config.js
new file mode 100644
index 0000000..c9c9896
--- /dev/null
+++ b/backbaord/test/config.js
@@ -0,0 +1,5 @@
+const CONFIG = {
+  MATCH_ID: `match-${Date.now()}`,
+};
+
+export default CONFIG;
diff --git a/backbaord/test/data.js b/backbaord/test/data.js
new file mode 100644
index 0000000..18af46f
--- /dev/null
+++ b/backbaord/test/data.js
@@ -0,0 +1,75 @@
+// ─── QUESTIONS ──────────────────────────────────────────────────
+
+const QUESTIONS = [
+  'Given an array of integers, return indices of the two numbers that add up to a specific target.',
+  'Reverse a singly linked list.',
+  'Find the contiguous subarray with the largest sum.',
+];
+
+// ─── PLAYER SUBMISSIONS ─────────────────────────────────────────
+// Each player has a name and 3 answers (one per question).
+// This is the ONLY input the system needs.
+
+const PLAYERS = [
+  {
+    name: 'Player1',
+    answers: [
+      {
+        question: QUESTIONS[0],
+        answer:
+          'function twoSum(nums, target) { const map = {}; for (let i = 0; i < nums.length; i++) { const c = target - nums[i]; if (map[c] !== undefined) return [map[c], i]; map[nums[i]] = i; } }',
+      },
+      {
+        question: QUESTIONS[1],
+        answer:
+          'function reverseList(head) { let prev = null, curr = head; while (curr) { const next = curr.next; curr.next = prev; prev = curr; curr = next; } return prev; }',
+      },
+      {
+        question: QUESTIONS[2],
+        answer:
+          'function maxSubArray(nums) { let max = nums[0], cur = nums[0]; for (let i = 1; i < nums.length; i++) { cur = Math.max(nums[i], cur + nums[i]); max = Math.max(max, cur); } return max; }',
+      },
+    ],
+  },
+  {
+    name: 'Player2',
+    answers: [
+      {
+        question: QUESTIONS[0],
+        answer:
+          'function twoSum(nums, target) { for (let i = 0; i < nums.length; i++) for (let j = i+1; j < nums.length; j++) if (nums[i]+nums[j] === target) return [i,j]; }',
+      },
+      {
+        question: QUESTIONS[1],
+        answer:
+          'function reverseList(head) { let prev = null, curr = head; while (curr) { const next = curr.next; curr.next = prev; prev = curr; curr = next; } return prev; }',
+      },
+      {
+        question: QUESTIONS[2],
+        answer: 'I have no idea what a subarray is, here is a poem about trees.',
+      },
+    ],
+  },
+  {
+    name: 'Player3',
+    answers: [
+      {
+        question: QUESTIONS[0],
+        answer:
+          'function twoSum(nums, target) { nums.sort((a,b) => a-b); let l = 0, r = nums.length-1; while (l < r) { const s = nums[l]+nums[r]; if (s === target) return [l,r]; s < target ? l++ : r--; } }',
+      },
+      {
+        question: QUESTIONS[1],
+        answer:
+          'function reverseList(head) { if (!head || !head.next) return head; const rest = reverseList(head.next); head.next.next = head; head.next = null; return rest; }',
+      },
+      {
+        question: QUESTIONS[2],
+        answer:
+          'function maxSubArray(nums) { let max = -Infinity; for (let i = 0; i < nums.length; i++) { let sum = 0; for (let j = i; j < nums.length; j++) { sum += nums[j]; if (sum > max) max = sum; } } return max; }',
+      },
+    ],
+  },
+];
+
+export { QUESTIONS, PLAYERS };
diff --git a/backbaord/test/index.js b/backbaord/test/index.js
new file mode 100644
index 0000000..92202d7
--- /dev/null
+++ b/backbaord/test/index.js
@@ -0,0 +1,92 @@
+/**
+ * index.js — Match Runner
+ *
+ * Runs a full competitive coding match via the Backboard API.
+ * Input: questions + player answers (defined in data.js)
+ * Output: AI-evaluated TC/SC/Context + deterministic grades + ranking
+ *
+ * Run: node backboard/test/index.js
+ */
+
+import dotenv from 'dotenv';
+import { resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+dotenv.config({ path: resolve(__dirname, '../../.env.local') });
+
+import CONFIG from './config.js';
+import { PLAYERS } from './data.js';
+import { runMatch } from '../match.js';
+
+// ─── FORMATTING ─────────────────────────────────────────────────
+
+function divider(label) {
+  const line = '─'.repeat(56);
+  console.log(`\n${line}`);
+  if (label) console.log(`  ${label}`);
+  console.log(line);
+}
+
+function pad(str, len) {
+  return String(str).padEnd(len);
+}
+
+// ─── MAIN ───────────────────────────────────────────────────────
+
+async function main() {
+  if (!process.env.BACKBOARD_API_KEY) {
+    console.error('ERROR: BACKBOARD_API_KEY not set. Add it to .env.local');
+    process.exit(1);
+  }
+
+  divider(`MATCH: ${CONFIG.MATCH_ID}  |  Players: ${PLAYERS.length}`);
+  console.log('  Calling Backboard API — waiting for AI evaluation...\n');
+
+  // ── Single call: questions + answers in, grades out ───────────
+  const { assistantId, playerResults, grades } = await runMatch(CONFIG.MATCH_ID, PLAYERS);
+
+  console.log(`  Assistant: ${assistantId}`);
+
+  // ── AI Verdicts ───────────────────────────────────────────────
+  divider('AI VERDICTS (TC / SC / Context)');
+
+  for (const [name, results] of Object.entries(playerResults)) {
+    console.log(`\n  ${name}:`);
+    results.forEach((v, q) => {
+      const ctx = v.Context === 1 ? 'VALID' : 'INVALID';
+      console.log(`    Q${q + 1}:  TC=${pad(v.TC, 12)} SC=${pad(v.SC, 12)} ${ctx}`);
+    });
+  }
+
+  // ── Grades ────────────────────────────────────────────────────
+  divider('SCORES');
+
+  const playerNames = Object.keys(grades);
+  console.log(`  ${pad('Player', 12)}${pad('Q1', 8)}${pad('Q2', 8)}${pad('Q3', 8)}TOTAL`);
+  console.log('  ' + '─'.repeat(44));
+
+  playerNames.forEach((name) => {
+    const scores = grades[name];
+    const total = scores.reduce((a, b) => a + b, 0);
+    console.log(`  ${pad(name, 12)}${scores.map((s) => pad(s, 8)).join('')}${total}`);
+  });
+
+  // ── Ranking ───────────────────────────────────────────────────
+  divider('RANKING');
+
+  const ranked = playerNames
+    .map((name) => ({ name, total: grades[name].reduce((a, b) => a + b, 0) }))
+    .sort((a, b) => b.total - a.total);
+
+  ranked.forEach((r, i) => {
+    console.log(`  #${i + 1}  ${pad(r.name, 12)} ${r.total} pts`);
+  });
+
+  divider();
+}
+
+main().catch((err) => {
+  console.error('MATCH FAILED:', err);
+  process.exit(1);
+});
diff --git a/backbaord/test/package.json b/backbaord/test/package.json
new file mode 100644
index 0000000..3dbc1ca
--- /dev/null
+++ b/backbaord/test/package.json
@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}
diff --git a/backbaord/testing.ts b/backbaord/testing.ts
deleted file mode 100644
index e0d77d3..0000000
--- a/backbaord/testing.ts
+++ /dev/null
@@ -1,39 +0,0 @@
-// Install: npm install backboard-sdk
-import { BackboardClient } from 'backboard-sdk';
-
-async function main() {
-  const apiKey = process.env.BACKBOARD_API_KEY;
-  if (!apiKey) throw new Error('Missing BACKBOARD_API_KEY');
-
-  // Initialize the Backboard client (types are bundled with the package)
-  const client = new BackboardClient({ apiKey });
-
-  // Create an assistant
-  const assistant = await client.createAssistant({
-    name: 'My First Assistant',
-    system_prompt: 'A helpful assistant'
-  });
-
-  // Create a thread
-  const thread = await client.createThread(assistant.assistantId);
-
-  // Send a message and get the complete response
-  const response = await client.addMessage(thread.threadId, {
-    content: 'Hello! Tell me a fun fact about space.',
-    llm_provider: 'google',
-    model_name: 'gemini-2.5-flash',
-    stream: false
-  });
-
-  if ('content' in response) {
-    console.log(response.content);
-  } else {
-    let fullContent = '';
-    for await (const chunk of response) {
-      fullContent += chunk;
-    }
-    console.log(fullContent);
-  }
-}
-
-main().catch(console.error);
\ No newline at end of file
diff --git a/backbaord/tools.ts b/backbaord/tools.ts
deleted file mode 100644
index 87bd1a4..0000000
--- a/backbaord/tools.ts
+++ /dev/null
@@ -1,223 +0,0 @@
-// ============================================================
-// Backboard Tool Definitions for the Evaluation Pipeline
-// ============================================================
-
-import { BackboardToolDef } from "./types";
-
-// ---- Thread 1: Time Complexity Analysis ----
-export const TIME_COMPLEXITY_TOOL: BackboardToolDef = {
-  type: "function",
-  function: {
-    name: "analyze_time_complexity",
-    description:
-      "Analyze and return the Big-O time complexity of the submitted code relative to the problem it solves. Return the complexity class and a numeric efficiency score (1-100) where 100 is the optimal known solution.",
-    parameters: {
-      type: "object",
-      properties: {
-        code: {
-          type: "string",
-          description: "The submitted source code to analyze",
-        },
-        language: {
-          type: "string",
-          description: "Programming language of the submission (python, cpp, javascript, java, etc.)",
-        },
-        questionContext: {
-          type: "string",
-          description: "The problem statement / question description for context",
-        },
-      },
-      required: ["code", "language", "questionContext"],
-    },
-  },
-};
-
-// ---- Thread 2: Space Complexity Analysis ----
-export const SPACE_COMPLEXITY_TOOL: BackboardToolDef = {
-  type: "function",
-  function: {
-    name: "analyze_space_complexity",
-    description:
-      "Analyze and return the Big-O space complexity (auxiliary space only, excluding input) of the submitted code. Return the complexity class and a numeric efficiency score (1-100) where 100 is optimal.",
-    parameters: {
-      type: "object",
-      properties: {
-        code: {
-          type: "string",
-          description: "The submitted source code to analyze",
-        },
-        language: {
-          type: "string",
-          description: "Programming language of the submission",
-        },
-        questionContext: {
-          type: "string",
-          description: "The problem statement for context",
-        },
-      },
-      required: ["code", "language", "questionContext"],
-    },
-  },
-};
-
-// ---- Thread 3: Originality & Relevance Analysis ----
-export const ORIGINALITY_TOOL: BackboardToolDef = {
-  type: "function",
-  function: {
-    name: "analyze_originality",
-    description:
-      "Analyze code for originality signals. Check comment density (high comment-to-code ratio = likely AI-generated), code style patterns, boilerplate detection, and relevance to the problem. Return an originality score (1-10 where 10 is clearly human-written) and a relevance score (1-10 where 10 perfectly solves the problem).",
-    parameters: {
-      type: "object",
-      properties: {
-        code: {
-          type: "string",
-          description: "The submitted source code to analyze",
-        },
-        language: {
-          type: "string",
-          description: "Programming language of the submission",
-        },
-        questionContext: {
-          type: "string",
-          description: "The problem statement to check relevance against",
-        },
-      },
-      required: ["code", "language", "questionContext"],
-    },
-  },
-};
-
-// ---- Thread 4: Final Ranking Aggregation ----
-export const RANKING_TOOL: BackboardToolDef = {
-  type: "function",
-  function: {
-    name: "compute_final_ranking",
-    description:
-      "Given all metric scores for all users in a round, compute weighted final scores and produce a ranking. Apply the provided weights to normalize scores. In case of tied final scores, use the tiebreaker data (time taken in ms — lower is better) to determine rank order.",
-    parameters: {
-      type: "object",
-      properties: {
-        timeComplexityResults: {
-          type: "string",
-          description: "JSON string of time complexity results for all users",
-        },
-        spaceComplexityResults: {
-          type: "string",
-          description: "JSON string of space complexity results for all users",
-        },
-        originalityResults: {
-          type: "string",
-          description: "JSON string of originality/relevance results for all users",
-        },
-        testCaseResults: {
-          type: "string",
-          description: "JSON string of { userId: { passed, total } } from the database",
-        },
-        weights: {
-          type: "string",
-          description: "JSON string of scoring weights { timeComplexity, spaceComplexity, originality, testCases }",
-        },
-        tiebreakerData: {
-          type: "string",
-          description: "JSON string of { userId: timeTakenMs } for tiebreaker resolution",
-        },
-      },
-      required: [
-        "timeComplexityResults",
-        "spaceComplexityResults",
-        "originalityResults",
-        "testCaseResults",
-        "weights",
-        "tiebreakerData",
-      ],
-    },
-  },
-};
-
-// ---- System Prompts ----
-
-export const SYSTEM_PROMPTS = {
-  timeComplexity: `You are an expert algorithm analyst for a competitive coding platform called Compile-n-Conquer.
-
-Your job: Analyze submitted code and determine its Big-O TIME COMPLEXITY.
-
-For each piece of code you receive:
-1. Identify the dominant operations and loops
-2. Determine the worst-case time complexity as a Big-O expression
-3. Score the efficiency from 1-100 (100 = optimal known solution for the problem)
-4. Provide brief reasoning
-
-You will receive batched submissions for a round. Analyze each one using the analyze_time_complexity tool. Be strict and accurate — this is a competitive setting.
-
-IMPORTANT: You MUST call the analyze_time_complexity tool for EVERY submission in the batch. Do not skip any.`,
-
-  spaceComplexity: `You are an expert algorithm analyst for a competitive coding platform called Compile-n-Conquer.
-
-Your job: Analyze submitted code and determine its Big-O SPACE COMPLEXITY (auxiliary space only — do not count the input).
-
-For each piece of code you receive:
-1. Identify all extra data structures, recursion depth, and allocations
-2. Determine the worst-case auxiliary space complexity as a Big-O expression
-3. Score the efficiency from 1-100 (100 = optimal space usage)
-4. Provide brief reasoning
-
-You will receive batched submissions for a round. Analyze each one using the analyze_space_complexity tool. Be strict and accurate.
-
-IMPORTANT: You MUST call the analyze_space_complexity tool for EVERY submission in the batch. Do not skip any.`,
-
-  originality: `You are a code originality and relevance analyst for a competitive coding platform called Compile-n-Conquer.
-
-Your job: Detect whether code was likely AI-generated (e.g. from ChatGPT/Copilot) and assess how relevant it is to the problem.
-
-Detection signals for AI-generated code:
-- Excessive inline comments explaining obvious operations
-- Over-structured docstrings with parameter/return descriptions for simple functions
-- Boilerplate patterns (e.g. "# Initialize variables", "# Edge case handling")
-- Unnaturally consistent and verbose naming conventions
-- Generic solution patterns that don't match the specific problem constraints
-
-Scoring:
-- originalityScore (1-10): 10 = clearly human-written competitive code, 1 = obviously pasted from AI
-- relevanceScore (1-10): 10 = perfectly addresses the problem, 1 = completely unrelated code
-- commentDensity: percentage of comment lines vs code lines
-- flags: array of detected signals
-
-You will receive batched submissions. Analyze each one using the analyze_originality tool.
-
-IMPORTANT: You MUST call the analyze_originality tool for EVERY submission in the batch.`,
-
-  ranking: `You are the ranking engine for Compile-n-Conquer.
-
-You receive pre-computed scores from three analysis threads (time complexity, space complexity, originality) plus test case pass rates from the database.
-
-Your job:
-1. Apply the provided scoring weights to compute a final score for each user
-2. Average scores across all questions in the round
-3. Rank users from highest to lowest final score
-4. If two users have the exact same final score, the one with LOWER timeTakenMs ranks higher
-
-Use the compute_final_ranking tool with all the data to produce the final ranking.
-
-Output a clear, structured ranking with full score breakdowns.`,
-
-  memory: `You are the Player Profile Manager for Compile-n-Conquer, a competitive coding platform.
-
-You maintain persistent memory about each player:
-- Skill tier: beginner / intermediate / advanced / pro
-- Performance history: scores, ranks, trends
-- Common error patterns and weak areas
-- Preferred algorithms and languages
-- Coaching recommendations
-
-Tier classification rules:
-- Beginner: avg score < 30 across recent rounds
-- Intermediate: avg score 30-60
-- Advanced: avg score 60-85
-- Pro: avg score 85+
-
-Promotion: 3 consecutive rounds with avg score in the next tier → promote
-Demotion: 2 consecutive rounds below current tier threshold → demote
-
-Always provide actionable coaching feedback based on the player's history.`,
-};
diff --git a/backbaord/types.ts b/backbaord/types.ts
deleted file mode 100644
index f54cde7..0000000
--- a/backbaord/types.ts
+++ /dev/null
@@ -1,174 +0,0 @@
-// ============================================================
-// Compile-n-Conquer — Evaluation Pipeline Types
-// ============================================================
-
-// ---- Input Types ----
-
-export interface Question {
-  id: string;
-  title: string;
-  description: string;
-  difficulty: "easy" | "medium" | "hard";
-}
-
-export interface UserResponse {
-  questionId: string;
-  code: string;
-  language: string;
-  submittedAt: string; // ISO timestamp
-}
-
-export interface UserSubmission {
-  userId: string;
-  responses: UserResponse[];
-}
-
-export interface RoundSubmissions {
-  roundId: string;
-  questions: Question[];
-  submissions: UserSubmission[];
-}
-
-// ---- Metric Result Types ----
-
-export interface ComplexityResult {
-  questionId: string;
-  complexity: string; // e.g. "O(n)", "O(n log n)"
-  score: number;      // 1-100
-  reasoning: string;
-}
-
-export interface OriginalityResult {
-  questionId: string;
-  originalityScore: number;  // 1-10
-  relevanceScore: number;    // 1-10
-  commentDensity: number;    // percentage
-  flags: string[];
-  reasoning: string;
-}
-
-export interface MetricResults<T> {
-  roundId: string;
-  metric: "time_complexity" | "space_complexity" | "originality";
-  results: Record<string, T[]>; // userId -> per-question results
-}
-
-export type TimeComplexityResults = MetricResults<ComplexityResult>;
-export type SpaceComplexityResults = MetricResults<ComplexityResult>;
-export type OriginalityResults = MetricResults<OriginalityResult>;
-
-// ---- Test Case Types ----
-
-export interface TestCaseResult {
-  passed: number;
-  total: number;
-}
-
-export type TestCaseResults = Record<string, TestCaseResult>; // userId -> result
-
-// ---- Scoring & Ranking Types ----
-
-export interface ScoringWeights {
-  timeComplexity: number;  // e.g. 0.25
-  spaceComplexity: number; // e.g. 0.20
-  originality: number;     // e.g. 0.15
-  testCases: number;       // e.g. 0.40
-}
-
-export const DEFAULT_WEIGHTS: ScoringWeights = {
-  timeComplexity: 0.25,
-  spaceComplexity: 0.20,
-  originality: 0.15,
-  testCases: 0.40,
-};
-
-export interface ScoreBreakdown {
-  timeComplexity: { avgScore: number; weighted: number };
-  spaceComplexity: { avgScore: number; weighted: number };
-  originality: { avgScore: number; weighted: number };
-  testCases: { passRate: number; weighted: number };
-}
-
-export interface RankedUser {
-  rank: number;
-  userId: string;
-  finalScore: number;
-  breakdown: ScoreBreakdown;
-  timeTakenMs: number;
-}
-
-export interface RoundEvaluation {
-  roundId: string;
-  evaluationId: string;
-  rankings: RankedUser[];
-  threadIds: {
-    timeComplexity: string;
-    spaceComplexity: string;
-    originality: string;
-    ranking: string;
-  };
-  evaluatedAt: string;
-}
-
-// ---- Tiebreaker ----
-
-export type TiebreakerData = Record<string, number>; // userId -> timeTakenMs
-
-// ---- Memory / Skill Tier Types ----
-
-export type SkillTier = "beginner" | "intermediate" | "advanced" | "pro";
-
-export interface PlayerProfile {
-  userId: string;
-  skillTier: SkillTier;
-  avgScore: number;
-  roundHistory: RoundScore[];
-  commonErrors: string[];
-  preferredAlgorithms: string[];
-  promotionHistory: TierChange[];
-}
-
-export interface RoundScore {
-  roundId: string;
-  finalScore: number;
-  rank: number;
-  evaluatedAt: string;
-}
-
-export interface TierChange {
-  from: SkillTier;
-  to: SkillTier;
-  reason: string;
-  changedAt: string;
-}
-
-// ---- Backboard Tool Definitions ----
-
-export interface BackboardToolDef {
-  type: "function";
-  function: {
-    name: string;
-    description: string;
-    parameters: {
-      type: "object";
-      properties: Record<string, { type: string; description: string }>;
-      required: string[];
-    };
-  };
-}
-
-// ---- Evaluation Pipeline Config ----
-
-export interface EvaluationConfig {
-  llmProvider: string;
-  modelName: string;
-  weights: ScoringWeights;
-  maxRetries: number;
-}
-
-export const DEFAULT_EVAL_CONFIG: EvaluationConfig = {
-  llmProvider: "google",
-  modelName: "gemini-2.5-flash",
-  weights: DEFAULT_WEIGHTS,
-  maxRetries: 2,
-};
diff --git a/package-lock.json b/package-lock.json
index 909f89f..ae30f6d 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -19,7 +19,7 @@
         "lucide-react": "^0.460.0",
         "next": "16.1.6",
         "pg": "^8.18.0",
-        "prisma": "^7.3.0",
+        "prisma": "^6.19.2",
         "react": "19.2.3",
         "react-dom": "19.2.3",
         "socket.io": "^4.8.3",
@@ -293,66 +293,6 @@
         "node": ">=6.9.0"
       }
     },
-    "node_modules/@chevrotain/cst-dts-gen": {
-      "version": "10.5.0",
-      "resolved": "https://registry.npmjs.org/@chevrotain/cst-dts-gen/-/cst-dts-gen-10.5.0.tgz",
-      "integrity": "sha512-lhmC/FyqQ2o7pGK4Om+hzuDrm9rhFYIJ/AXoQBeongmn870Xeb0L6oGEiuR8nohFNL5sMaQEJWCxr1oIVIVXrw==",
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@chevrotain/gast": "10.5.0",
-        "@chevrotain/types": "10.5.0",
-        "lodash": "4.17.21"
-      }
-    },
-    "node_modules/@chevrotain/gast": {
-      "version": "10.5.0",
-      "resolved": "https://registry.npmjs.org/@chevrotain/gast/-/gast-10.5.0.tgz",
-      "integrity": "sha512-pXdMJ9XeDAbgOWKuD1Fldz4ieCs6+nLNmyVhe2gZVqoO7v8HXuHYs5OV2EzUtbuai37TlOAQHrTDvxMnvMJz3A==",
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@chevrotain/types": "10.5.0",
-        "lodash": "4.17.21"
-      }
-    },
-    "node_modules/@chevrotain/types": {
-      "version": "10.5.0",
-      "resolved": "https://registry.npmjs.org/@chevrotain/types/-/types-10.5.0.tgz",
-      "integrity": "sha512-f1MAia0x/pAVPWH/T73BJVyO2XU5tI4/iE7cnxb7tqdNTNhQI3Uq3XkqcoteTmD4t1aM0LbHCJOhgIDn07kl2A==",
-      "license": "Apache-2.0"
-    },
-    "node_modules/@chevrotain/utils": {
-      "version": "10.5.0",
-      "resolved": "https://registry.npmjs.org/@chevrotain/utils/-/utils-10.5.0.tgz",
-      "integrity": "sha512-hBzuU5+JjB2cqNZyszkDHZgOSrUUT8V3dhgRl8Q9Gp6dAj/H5+KILGjbhDpc3Iy9qmqlm/akuOI2ut9VUtzJxQ==",
-      "license": "Apache-2.0"
-    },
-    "node_modules/@electric-sql/pglite": {
-      "version": "0.3.15",
-      "resolved": "https://registry.npmjs.org/@electric-sql/pglite/-/pglite-0.3.15.tgz",
-      "integrity": "sha512-Cj++n1Mekf9ETfdc16TlDi+cDDQF0W7EcbyRHYOAeZdsAe8M/FJg18itDTSwyHfar2WIezawM9o0EKaRGVKygQ==",
-      "license": "Apache-2.0"
-    },
-    "node_modules/@electric-sql/pglite-socket": {
-      "version": "0.0.20",
-      "resolved": "https://registry.npmjs.org/@electric-sql/pglite-socket/-/pglite-socket-0.0.20.tgz",
-      "integrity": "sha512-J5nLGsicnD9wJHnno9r+DGxfcZWh+YJMCe0q/aCgtG6XOm9Z7fKeite8IZSNXgZeGltSigM9U/vAWZQWdgcSFg==",
-      "license": "Apache-2.0",
-      "bin": {
-        "pglite-server": "dist/scripts/server.js"
-      },
-      "peerDependencies": {
-        "@electric-sql/pglite": "0.3.15"
-      }
-    },
-    "node_modules/@electric-sql/pglite-tools": {
-      "version": "0.2.20",
-      "resolved": "https://registry.npmjs.org/@electric-sql/pglite-tools/-/pglite-tools-0.2.20.tgz",
-      "integrity": "sha512-BK50ZnYa3IG7ztXhtgYf0Q7zijV32Iw1cYS8C+ThdQlwx12V5VZ9KRJ42y82Hyb4PkTxZQklVQA9JHyUlex33A==",
-      "license": "Apache-2.0",
-      "peerDependencies": {
-        "@electric-sql/pglite": "0.3.15"
-      }
-    },
     "node_modules/@emnapi/core": {
       "version": "1.8.1",
       "resolved": "https://registry.npmjs.org/@emnapi/core/-/core-1.8.1.tgz",
@@ -1169,18 +1109,6 @@
         "node": ">=6"
       }
     },
-    "node_modules/@hono/node-server": {
-      "version": "1.19.9",
-      "resolved": "https://registry.npmjs.org/@hono/node-server/-/node-server-1.19.9.tgz",
-      "integrity": "sha512-vHL6w3ecZsky+8P5MD+eFfaGTyCeOHUIFYMGpQGbrBTSmNNoxv0if69rEZ5giu36weC5saFuznL411gRX7bJDw==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=18.14.1"
-      },
-      "peerDependencies": {
-        "hono": "^4"
-      }
-    },
     "node_modules/@humanfs/core": {
       "version": "0.19.1",
       "resolved": "https://registry.npmjs.org/@humanfs/core/-/core-0.19.1.tgz",
@@ -1772,19 +1700,6 @@
         "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0"
       }
     },
-    "node_modules/@mrleebo/prisma-ast": {
-      "version": "0.13.1",
-      "resolved": "https://registry.npmjs.org/@mrleebo/prisma-ast/-/prisma-ast-0.13.1.tgz",
-      "integrity": "sha512-XyroGQXcHrZdvmrGJvsA9KNeOOgGMg1Vg9OlheUsBOSKznLMDl+YChxbkboRHvtFYJEMRYmlV3uoo/njCw05iw==",
-      "license": "MIT",
-      "dependencies": {
-        "chevrotain": "^10.5.0",
-        "lilconfig": "^2.1.0"
-      },
-      "engines": {
-        "node": ">=16"
-      }
-    },
     "node_modules/@napi-rs/wasm-runtime": {
       "version": "0.2.12",
       "resolved": "https://registry.npmjs.org/@napi-rs/wasm-runtime/-/wasm-runtime-0.2.12.tgz",
@@ -2032,9 +1947,9 @@
       "license": "Apache-2.0"
     },
     "node_modules/@prisma/config": {
-      "version": "7.3.0",
-      "resolved": "https://registry.npmjs.org/@prisma/config/-/config-7.3.0.tgz",
-      "integrity": "sha512-QyMV67+eXF7uMtKxTEeQqNu/Be7iH+3iDZOQZW5ttfbSwBamCSdwPszA0dum+Wx27I7anYTPLmRmMORKViSW1A==",
+      "version": "6.19.2",
+      "resolved": "https://registry.npmjs.org/@prisma/config/-/config-6.19.2.tgz",
+      "integrity": "sha512-kadBGDl+aUswv/zZMk9Mx0C8UZs1kjao8H9/JpI4Wh4SHZaM7zkTwiKn/iFLfRg+XtOAo/Z/c6pAYhijKl0nzQ==",
       "license": "Apache-2.0",
       "dependencies": {
         "c12": "3.1.0",
@@ -2049,31 +1964,6 @@
       "integrity": "sha512-yh/tHhraCzYkffsI1/3a7SHX8tpgbJu1NPnuxS4rEpJdWAUDHUH25F1EDo6PPzirpyLNkgPPZdhojQK804BGtg==",
       "license": "Apache-2.0"
     },
-    "node_modules/@prisma/dev": {
-      "version": "0.20.0",
-      "resolved": "https://registry.npmjs.org/@prisma/dev/-/dev-0.20.0.tgz",
-      "integrity": "sha512-ovlBYwWor0OzG+yH4J3Ot+AneD818BttLA+Ii7wjbcLHUrnC4tbUPVGyNd3c/+71KETPKZfjhkTSpdS15dmXNQ==",
-      "license": "ISC",
-      "dependencies": {
-        "@electric-sql/pglite": "0.3.15",
-        "@electric-sql/pglite-socket": "0.0.20",
-        "@electric-sql/pglite-tools": "0.2.20",
-        "@hono/node-server": "1.19.9",
-        "@mrleebo/prisma-ast": "0.13.1",
-        "@prisma/get-platform": "7.2.0",
-        "@prisma/query-plan-executor": "7.2.0",
-        "foreground-child": "3.3.1",
-        "get-port-please": "3.2.0",
-        "hono": "4.11.4",
-        "http-status-codes": "2.3.0",
-        "pathe": "2.0.3",
-        "proper-lockfile": "4.1.2",
-        "remeda": "2.33.4",
-        "std-env": "3.10.0",
-        "valibot": "1.2.0",
-        "zeptomatch": "2.1.0"
-      }
-    },
     "node_modules/@prisma/driver-adapter-utils": {
       "version": "7.3.0",
       "resolved": "https://registry.npmjs.org/@prisma/driver-adapter-utils/-/driver-adapter-utils-7.3.0.tgz",
@@ -2084,85 +1974,62 @@
       }
     },
     "node_modules/@prisma/engines": {
-      "version": "7.3.0",
-      "resolved": "https://registry.npmjs.org/@prisma/engines/-/engines-7.3.0.tgz",
-      "integrity": "sha512-cWRQoPDXPtR6stOWuWFZf9pHdQ/o8/QNWn0m0zByxf5Kd946Q875XdEJ52pEsX88vOiXUmjuPG3euw82mwQNMg==",
+      "version": "6.19.2",
+      "resolved": "https://registry.npmjs.org/@prisma/engines/-/engines-6.19.2.tgz",
+      "integrity": "sha512-TTkJ8r+uk/uqczX40wb+ODG0E0icVsMgwCTyTHXehaEfb0uo80M9g1aW1tEJrxmFHeOZFXdI2sTA1j1AgcHi4A==",
       "hasInstallScript": true,
       "license": "Apache-2.0",
       "dependencies": {
-        "@prisma/debug": "7.3.0",
-        "@prisma/engines-version": "7.3.0-16.9d6ad21cbbceab97458517b147a6a09ff43aa735",
-        "@prisma/fetch-engine": "7.3.0",
-        "@prisma/get-platform": "7.3.0"
+        "@prisma/debug": "6.19.2",
+        "@prisma/engines-version": "7.1.1-3.c2990dca591cba766e3b7ef5d9e8a84796e47ab7",
+        "@prisma/fetch-engine": "6.19.2",
+        "@prisma/get-platform": "6.19.2"
       }
     },
     "node_modules/@prisma/engines-version": {
-      "version": "7.3.0-16.9d6ad21cbbceab97458517b147a6a09ff43aa735",
-      "resolved": "https://registry.npmjs.org/@prisma/engines-version/-/engines-version-7.3.0-16.9d6ad21cbbceab97458517b147a6a09ff43aa735.tgz",
-      "integrity": "sha512-IH2va2ouUHihyiTTRW889LjKAl1CusZOvFfZxCDNpjSENt7g2ndFsK0vdIw/72v7+jCN6YgkHmdAP/BI7SDgyg==",
+      "version": "7.1.1-3.c2990dca591cba766e3b7ef5d9e8a84796e47ab7",
+      "resolved": "https://registry.npmjs.org/@prisma/engines-version/-/engines-version-7.1.1-3.c2990dca591cba766e3b7ef5d9e8a84796e47ab7.tgz",
+      "integrity": "sha512-03bgb1VD5gvuumNf+7fVGBzfpJPjmqV423l/WxsWk2cNQ42JD0/SsFBPhN6z8iAvdHs07/7ei77SKu7aZfq8bA==",
       "license": "Apache-2.0"
     },
-    "node_modules/@prisma/engines/node_modules/@prisma/get-platform": {
-      "version": "7.3.0",
-      "resolved": "https://registry.npmjs.org/@prisma/get-platform/-/get-platform-7.3.0.tgz",
-      "integrity": "sha512-N7c6m4/I0Q6JYmWKP2RCD/sM9eWiyCPY98g5c0uEktObNSZnugW2U/PO+pwL0UaqzxqTXt7gTsYsb0FnMnJNbg==",
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@prisma/debug": "7.3.0"
-      }
+    "node_modules/@prisma/engines/node_modules/@prisma/debug": {
+      "version": "6.19.2",
+      "resolved": "https://registry.npmjs.org/@prisma/debug/-/debug-6.19.2.tgz",
+      "integrity": "sha512-lFnEZsLdFLmEVCVNdskLDCL8Uup41GDfU0LUfquw+ercJC8ODTuL0WNKgOKmYxCJVvFwf0OuZBzW99DuWmoH2A==",
+      "license": "Apache-2.0"
     },
     "node_modules/@prisma/fetch-engine": {
-      "version": "7.3.0",
-      "resolved": "https://registry.npmjs.org/@prisma/fetch-engine/-/fetch-engine-7.3.0.tgz",
-      "integrity": "sha512-Mm0F84JMqM9Vxk70pzfNpGJ1lE4hYjOeLMu7nOOD1i83nvp8MSAcFYBnHqLvEZiA6onUR+m8iYogtOY4oPO5lQ==",
+      "version": "6.19.2",
+      "resolved": "https://registry.npmjs.org/@prisma/fetch-engine/-/fetch-engine-6.19.2.tgz",
+      "integrity": "sha512-h4Ff4Pho+SR1S8XerMCC12X//oY2bG3Iug/fUnudfcXEUnIeRiBdXHFdGlGOgQ3HqKgosTEhkZMvGM9tWtYC+Q==",
       "license": "Apache-2.0",
       "dependencies": {
-        "@prisma/debug": "7.3.0",
-        "@prisma/engines-version": "7.3.0-16.9d6ad21cbbceab97458517b147a6a09ff43aa735",
-        "@prisma/get-platform": "7.3.0"
+        "@prisma/debug": "6.19.2",
+        "@prisma/engines-version": "7.1.1-3.c2990dca591cba766e3b7ef5d9e8a84796e47ab7",
+        "@prisma/get-platform": "6.19.2"
       }
     },
-    "node_modules/@prisma/fetch-engine/node_modules/@prisma/get-platform": {
-      "version": "7.3.0",
-      "resolved": "https://registry.npmjs.org/@prisma/get-platform/-/get-platform-7.3.0.tgz",
-      "integrity": "sha512-N7c6m4/I0Q6JYmWKP2RCD/sM9eWiyCPY98g5c0uEktObNSZnugW2U/PO+pwL0UaqzxqTXt7gTsYsb0FnMnJNbg==",
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@prisma/debug": "7.3.0"
-      }
+    "node_modules/@prisma/fetch-engine/node_modules/@prisma/debug": {
+      "version": "6.19.2",
+      "resolved": "https://registry.npmjs.org/@prisma/debug/-/debug-6.19.2.tgz",
+      "integrity": "sha512-lFnEZsLdFLmEVCVNdskLDCL8Uup41GDfU0LUfquw+ercJC8ODTuL0WNKgOKmYxCJVvFwf0OuZBzW99DuWmoH2A==",
+      "license": "Apache-2.0"
     },
     "node_modules/@prisma/get-platform": {
-      "version": "7.2.0",
-      "resolved": "https://registry.npmjs.org/@prisma/get-platform/-/get-platform-7.2.0.tgz",
-      "integrity": "sha512-k1V0l0Td1732EHpAfi2eySTezyllok9dXb6UQanajkJQzPUGi3vO2z7jdkz67SypFTdmbnyGYxvEvYZdZsMAVA==",
+      "version": "6.19.2",
+      "resolved": "https://registry.npmjs.org/@prisma/get-platform/-/get-platform-6.19.2.tgz",
+      "integrity": "sha512-PGLr06JUSTqIvztJtAzIxOwtWKtJm5WwOG6xpsgD37Rc84FpfUBGLKz65YpJBGtkRQGXTYEFie7pYALocC3MtA==",
       "license": "Apache-2.0",
       "dependencies": {
-        "@prisma/debug": "7.2.0"
+        "@prisma/debug": "6.19.2"
       }
     },
     "node_modules/@prisma/get-platform/node_modules/@prisma/debug": {
-      "version": "7.2.0",
-      "resolved": "https://registry.npmjs.org/@prisma/debug/-/debug-7.2.0.tgz",
-      "integrity": "sha512-YSGTiSlBAVJPzX4ONZmMotL+ozJwQjRmZweQNIq/ER0tQJKJynNkRB3kyvt37eOfsbMCXk3gnLF6J9OJ4QWftw==",
+      "version": "6.19.2",
+      "resolved": "https://registry.npmjs.org/@prisma/debug/-/debug-6.19.2.tgz",
+      "integrity": "sha512-lFnEZsLdFLmEVCVNdskLDCL8Uup41GDfU0LUfquw+ercJC8ODTuL0WNKgOKmYxCJVvFwf0OuZBzW99DuWmoH2A==",
       "license": "Apache-2.0"
     },
-    "node_modules/@prisma/query-plan-executor": {
-      "version": "7.2.0",
-      "resolved": "https://registry.npmjs.org/@prisma/query-plan-executor/-/query-plan-executor-7.2.0.tgz",
-      "integrity": "sha512-EOZmNzcV8uJ0mae3DhTsiHgoNCuu1J9mULQpGCh62zN3PxPTd+qI9tJvk5jOst8WHKQNwJWR3b39t0XvfBB0WQ==",
-      "license": "Apache-2.0"
-    },
-    "node_modules/@prisma/studio-core": {
-      "version": "0.13.1",
-      "resolved": "https://registry.npmjs.org/@prisma/studio-core/-/studio-core-0.13.1.tgz",
-      "integrity": "sha512-agdqaPEePRHcQ7CexEfkX1RvSH9uWDb6pXrZnhCRykhDFAV0/0P3d07WtfiY8hZWb7oRU4v+NkT4cGFHkQJIPg==",
-      "license": "Apache-2.0",
-      "peerDependencies": {
-        "@types/react": "^18.0.0 || ^19.0.0",
-        "react": "^18.0.0 || ^19.0.0",
-        "react-dom": "^18.0.0 || ^19.0.0"
-      }
-    },
     "node_modules/@protobufjs/aspromise": {
       "version": "1.1.2",
       "resolved": "https://registry.npmjs.org/@protobufjs/aspromise/-/aspromise-1.1.2.tgz",
@@ -2605,6 +2472,7 @@
       "version": "19.2.13",
       "resolved": "https://registry.npmjs.org/@types/react/-/react-19.2.13.tgz",
       "integrity": "sha512-KkiJeU6VbYbUOp5ITMIc7kBfqlYkKA5KhEHVrGMmUUMt7NeaZg65ojdPk+FtNrBAOXNVM5QM72jnADjM+XVRAQ==",
+      "dev": true,
       "license": "MIT",
       "dependencies": {
         "csstype": "^3.2.2"
@@ -3459,15 +3327,6 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/aws-ssl-profiles": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/aws-ssl-profiles/-/aws-ssl-profiles-1.1.2.tgz",
-      "integrity": "sha512-NZKeq9AfyQvEeNlN0zSYAaWrmBffJh3IELMZfRpJVWgrpEbtEpnjvzqBPf+mxoI287JohRDoa+/nsfqqiZmF6g==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 6.0.0"
-      }
-    },
     "node_modules/axe-core": {
       "version": "4.11.1",
       "resolved": "https://registry.npmjs.org/axe-core/-/axe-core-4.11.1.tgz",
@@ -3723,20 +3582,6 @@
         "url": "https://github.com/chalk/chalk?sponsor=1"
       }
     },
-    "node_modules/chevrotain": {
-      "version": "10.5.0",
-      "resolved": "https://registry.npmjs.org/chevrotain/-/chevrotain-10.5.0.tgz",
-      "integrity": "sha512-Pkv5rBY3+CsHOYfV5g/Vs5JY9WTHHDEKOlohI2XeygaZhUeqhAlldZ8Hz9cRmxu709bvS08YzxHdTPHhffc13A==",
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@chevrotain/cst-dts-gen": "10.5.0",
-        "@chevrotain/gast": "10.5.0",
-        "@chevrotain/types": "10.5.0",
-        "@chevrotain/utils": "10.5.0",
-        "lodash": "4.17.21",
-        "regexp-to-ast": "0.5.0"
-      }
-    },
     "node_modules/chokidar": {
       "version": "4.0.3",
       "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-4.0.3.tgz",
@@ -3879,6 +3724,7 @@
       "version": "7.0.6",
       "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",
       "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==",
+      "dev": true,
       "license": "MIT",
       "dependencies": {
         "path-key": "^3.1.0",
@@ -3893,6 +3739,7 @@
       "version": "3.2.3",
       "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.2.3.tgz",
       "integrity": "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==",
+      "dev": true,
       "license": "MIT"
     },
     "node_modules/damerau-levenshtein": {
@@ -4049,15 +3896,6 @@
         "node": ">=0.4.0"
       }
     },
-    "node_modules/denque": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/denque/-/denque-2.1.0.tgz",
-      "integrity": "sha512-HVQE3AAb/pxF8fQAoiqpvg9i3evqug3hoiwakOyZAwJm+6vZehbkYXZ0l4JxS+I3QxM97v5aaRNhj8v5oBhekw==",
-      "license": "Apache-2.0",
-      "engines": {
-        "node": ">=0.10"
-      }
-    },
     "node_modules/destr": {
       "version": "2.0.5",
       "resolved": "https://registry.npmjs.org/destr/-/destr-2.0.5.tgz",
@@ -5080,22 +4918,6 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/foreground-child": {
-      "version": "3.3.1",
-      "resolved": "https://registry.npmjs.org/foreground-child/-/foreground-child-3.3.1.tgz",
-      "integrity": "sha512-gIXjKqtFuWEgzFRJA9WCQeSJLZDjgJUOMCMzxtvFq/37KojM1BFGufqsCy0r4qSQmYLsZYMeyRqzIWOMup03sw==",
-      "license": "ISC",
-      "dependencies": {
-        "cross-spawn": "^7.0.6",
-        "signal-exit": "^4.0.1"
-      },
-      "engines": {
-        "node": ">=14"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/isaacs"
-      }
-    },
     "node_modules/form-data": {
       "version": "4.0.5",
       "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.5.tgz",
@@ -5164,15 +4986,6 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/generate-function": {
-      "version": "2.3.1",
-      "resolved": "https://registry.npmjs.org/generate-function/-/generate-function-2.3.1.tgz",
-      "integrity": "sha512-eeB5GfMNeevm/GRYq20ShmsaGcmI81kIX2K9XQx5miC8KdHaC6Jm0qQ8ZNeGOi7wYB8OsdxKs+Y2oVuTFuVwKQ==",
-      "license": "MIT",
-      "dependencies": {
-        "is-property": "^1.0.2"
-      }
-    },
     "node_modules/generator-function": {
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/generator-function/-/generator-function-2.0.1.tgz",
@@ -5226,12 +5039,6 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/get-port-please": {
-      "version": "3.2.0",
-      "resolved": "https://registry.npmjs.org/get-port-please/-/get-port-please-3.2.0.tgz",
-      "integrity": "sha512-I9QVvBw5U/hw3RmWpYKRumUeaDgxTPd401x364rLmWBJcOQ753eov1eTgzDqRG9bqFIfDc7gfzcQEWrUri3o1A==",
-      "license": "MIT"
-    },
     "node_modules/get-proto": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz",
@@ -5352,19 +5159,9 @@
       "version": "4.2.11",
       "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz",
       "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==",
+      "dev": true,
       "license": "ISC"
     },
-    "node_modules/grammex": {
-      "version": "3.1.12",
-      "resolved": "https://registry.npmjs.org/grammex/-/grammex-3.1.12.tgz",
-      "integrity": "sha512-6ufJOsSA7LcQehIJNCO7HIBykfM7DXQual0Ny780/DEcJIpBlHRvcqEBWGPYd7hrXL2GJ3oJI1MIhaXjWmLQOQ==",
-      "license": "MIT"
-    },
-    "node_modules/graphmatch": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/graphmatch/-/graphmatch-1.1.0.tgz",
-      "integrity": "sha512-0E62MaTW5rPZVRLyIJZG/YejmdA/Xr1QydHEw3Vt+qOKkMIOE8WDLc9ZX2bmAjtJFZcId4lEdrdmASsEy7D1QA=="
-    },
     "node_modules/has-bigints": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/has-bigints/-/has-bigints-1.1.0.tgz",
@@ -5473,43 +5270,12 @@
         "hermes-estree": "0.25.1"
       }
     },
-    "node_modules/hono": {
-      "version": "4.11.4",
-      "resolved": "https://registry.npmjs.org/hono/-/hono-4.11.4.tgz",
-      "integrity": "sha512-U7tt8JsyrxSRKspfhtLET79pU8K+tInj5QZXs1jSugO1Vq5dFj3kmZsRldo29mTBfcjDRVRXrEZ6LS63Cog9ZA==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=16.9.0"
-      }
-    },
     "node_modules/http-parser-js": {
       "version": "0.5.10",
       "resolved": "https://registry.npmjs.org/http-parser-js/-/http-parser-js-0.5.10.tgz",
       "integrity": "sha512-Pysuw9XpUq5dVc/2SMHpuTY01RFl8fttgcyunjL7eEMhGM3cI4eOmiCycJDVCo/7O7ClfQD3SaI6ftDzqOXYMA==",
       "license": "MIT"
     },
-    "node_modules/http-status-codes": {
-      "version": "2.3.0",
-      "resolved": "https://registry.npmjs.org/http-status-codes/-/http-status-codes-2.3.0.tgz",
-      "integrity": "sha512-RJ8XvFvpPM/Dmc5SV+dC4y5PCeOhT3x1Hq0NU3rjGeg5a/CqlhZ7uudknPwZFz4aeAXDcbAyaeP7GAo9lvngtA==",
-      "license": "MIT"
-    },
-    "node_modules/iconv-lite": {
-      "version": "0.7.2",
-      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.7.2.tgz",
-      "integrity": "sha512-im9DjEDQ55s9fL4EYzOAv0yMqmMBSZp6G0VvFyTMPKWxiSBHUj9NW/qqLmXUwXrrM7AvqSlTCfvqRb0cM8yYqw==",
-      "license": "MIT",
-      "dependencies": {
-        "safer-buffer": ">= 2.1.2 < 3.0.0"
-      },
-      "engines": {
-        "node": ">=0.10.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/express"
-      }
-    },
     "node_modules/idb": {
       "version": "7.1.1",
       "resolved": "https://registry.npmjs.org/idb/-/idb-7.1.1.tgz",
@@ -5847,12 +5613,6 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/is-property": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/is-property/-/is-property-1.0.2.tgz",
-      "integrity": "sha512-Ks/IoX00TtClbGQr4TWXemAnktAQvYB7HzcCxDGqEZU6oCmb2INHuOoKxbtR+HFkmYWBKv/dOZtGRiAjDhj92g==",
-      "license": "MIT"
-    },
     "node_modules/is-regex": {
       "version": "1.2.1",
       "resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.2.1.tgz",
@@ -6009,6 +5769,7 @@
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
       "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==",
+      "dev": true,
       "license": "ISC"
     },
     "node_modules/iterator.prototype": {
@@ -6481,15 +6242,6 @@
         "url": "https://opencollective.com/parcel"
       }
     },
-    "node_modules/lilconfig": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/lilconfig/-/lilconfig-2.1.0.tgz",
-      "integrity": "sha512-utWOt/GHzuUxnLKxB6dk81RoOeoNeHgbrXiuGk4yyF5qlRz+iIVWu56E2fqGHFrXz0QNUhLB/8nKqvRH66JKGQ==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=10"
-      }
-    },
     "node_modules/locate-path": {
       "version": "6.0.0",
       "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz",
@@ -6506,12 +6258,6 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/lodash": {
-      "version": "4.17.21",
-      "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz",
-      "integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==",
-      "license": "MIT"
-    },
     "node_modules/lodash.camelcase": {
       "version": "4.3.0",
       "resolved": "https://registry.npmjs.org/lodash.camelcase/-/lodash.camelcase-4.3.0.tgz",
@@ -6596,21 +6342,6 @@
         "yallist": "^3.0.2"
       }
     },
-    "node_modules/lru.min": {
-      "version": "1.1.4",
-      "resolved": "https://registry.npmjs.org/lru.min/-/lru.min-1.1.4.tgz",
-      "integrity": "sha512-DqC6n3QQ77zdFpCMASA1a3Jlb64Hv2N2DciFGkO/4L9+q/IpIAuRlKOvCXabtRW6cQf8usbmM6BE/TOPysCdIA==",
-      "license": "MIT",
-      "engines": {
-        "bun": ">=1.0.0",
-        "deno": ">=1.30.0",
-        "node": ">=8.0.0"
-      },
-      "funding": {
-        "type": "github",
-        "url": "https://github.com/sponsors/wellwelwel"
-      }
-    },
     "node_modules/lucide-react": {
       "version": "0.460.0",
       "resolved": "https://registry.npmjs.org/lucide-react/-/lucide-react-0.460.0.tgz",
@@ -6737,38 +6468,6 @@
       "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
       "license": "MIT"
     },
-    "node_modules/mysql2": {
-      "version": "3.15.3",
-      "resolved": "https://registry.npmjs.org/mysql2/-/mysql2-3.15.3.tgz",
-      "integrity": "sha512-FBrGau0IXmuqg4haEZRBfHNWB5mUARw6hNwPDXXGg0XzVJ50mr/9hb267lvpVMnhZ1FON3qNd4Xfcez1rbFwSg==",
-      "license": "MIT",
-      "dependencies": {
-        "aws-ssl-profiles": "^1.1.1",
-        "denque": "^2.1.0",
-        "generate-function": "^2.3.1",
-        "iconv-lite": "^0.7.0",
-        "long": "^5.2.1",
-        "lru.min": "^1.0.0",
-        "named-placeholders": "^1.1.3",
-        "seq-queue": "^0.0.5",
-        "sqlstring": "^2.3.2"
-      },
-      "engines": {
-        "node": ">= 8.0"
-      }
-    },
-    "node_modules/named-placeholders": {
-      "version": "1.1.6",
-      "resolved": "https://registry.npmjs.org/named-placeholders/-/named-placeholders-1.1.6.tgz",
-      "integrity": "sha512-Tz09sEL2EEuv5fFowm419c1+a/jSMiBjI9gHxVLrVdbUkkNUUfjsVYs9pVZu5oCon/kmRh9TfLEObFtkVxmY0w==",
-      "license": "MIT",
-      "dependencies": {
-        "lru.min": "^1.1.0"
-      },
-      "engines": {
-        "node": ">=8.0.0"
-      }
-    },
     "node_modules/nanoid": {
       "version": "3.3.11",
       "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.11.tgz",
@@ -7197,6 +6896,7 @@
       "version": "3.1.1",
       "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
       "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==",
+      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">=8"
@@ -7388,19 +7088,6 @@
         "node": "^10 || ^12 || >=14"
       }
     },
-    "node_modules/postgres": {
-      "version": "3.4.7",
-      "resolved": "https://registry.npmjs.org/postgres/-/postgres-3.4.7.tgz",
-      "integrity": "sha512-Jtc2612XINuBjIl/QTWsV5UvE8UHuNblcO3vVADSrKsrc6RqGX6lOW1cEo3CM2v0XG4Nat8nI+YM7/f26VxXLw==",
-      "license": "Unlicense",
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "type": "individual",
-        "url": "https://github.com/sponsors/porsager"
-      }
-    },
     "node_modules/postgres-array": {
       "version": "3.0.4",
       "resolved": "https://registry.npmjs.org/postgres-array/-/postgres-array-3.0.4.tgz",
@@ -7451,33 +7138,25 @@
       }
     },
     "node_modules/prisma": {
-      "version": "7.3.0",
-      "resolved": "https://registry.npmjs.org/prisma/-/prisma-7.3.0.tgz",
-      "integrity": "sha512-ApYSOLHfMN8WftJA+vL6XwAPOh/aZ0BgUyyKPwUFgjARmG6EBI9LzDPf6SWULQMSAxydV9qn5gLj037nPNlg2w==",
+      "version": "6.19.2",
+      "resolved": "https://registry.npmjs.org/prisma/-/prisma-6.19.2.tgz",
+      "integrity": "sha512-XTKeKxtQElcq3U9/jHyxSPgiRgeYDKxWTPOf6NkXA0dNj5j40MfEsZkMbyNpwDWCUv7YBFUl7I2VK/6ALbmhEg==",
       "hasInstallScript": true,
       "license": "Apache-2.0",
       "dependencies": {
-        "@prisma/config": "7.3.0",
-        "@prisma/dev": "0.20.0",
-        "@prisma/engines": "7.3.0",
-        "@prisma/studio-core": "0.13.1",
-        "mysql2": "3.15.3",
-        "postgres": "3.4.7"
+        "@prisma/config": "6.19.2",
+        "@prisma/engines": "6.19.2"
       },
       "bin": {
         "prisma": "build/index.js"
       },
       "engines": {
-        "node": "^20.19 || ^22.12 || >=24.0"
+        "node": ">=18.18"
       },
       "peerDependencies": {
-        "better-sqlite3": ">=9.0.0",
-        "typescript": ">=5.4.0"
+        "typescript": ">=5.1.0"
       },
       "peerDependenciesMeta": {
-        "better-sqlite3": {
-          "optional": true
-        },
         "typescript": {
           "optional": true
         }
@@ -7495,23 +7174,6 @@
         "react-is": "^16.13.1"
       }
     },
-    "node_modules/proper-lockfile": {
-      "version": "4.1.2",
-      "resolved": "https://registry.npmjs.org/proper-lockfile/-/proper-lockfile-4.1.2.tgz",
-      "integrity": "sha512-TjNPblN4BwAWMXU8s9AEz4JmQxnD1NNL7bNOY/AKUzyamc379FWASUhc/K1pL2noVb+XmZKLL68cjzLsiOAMaA==",
-      "license": "MIT",
-      "dependencies": {
-        "graceful-fs": "^4.2.4",
-        "retry": "^0.12.0",
-        "signal-exit": "^3.0.2"
-      }
-    },
-    "node_modules/proper-lockfile/node_modules/signal-exit": {
-      "version": "3.0.7",
-      "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz",
-      "integrity": "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==",
-      "license": "ISC"
-    },
     "node_modules/protobufjs": {
       "version": "7.5.4",
       "resolved": "https://registry.npmjs.org/protobufjs/-/protobufjs-7.5.4.tgz",
@@ -7657,12 +7319,6 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/regexp-to-ast": {
-      "version": "0.5.0",
-      "resolved": "https://registry.npmjs.org/regexp-to-ast/-/regexp-to-ast-0.5.0.tgz",
-      "integrity": "sha512-tlbJqcMHnPKI9zSrystikWKwHkBqu2a/Sgw01h3zFjvYrMxEDYHzzoMZnUrbIfpTFEsoRnnviOXNCzFiSc54Qw==",
-      "license": "MIT"
-    },
     "node_modules/regexp.prototype.flags": {
       "version": "1.5.4",
       "resolved": "https://registry.npmjs.org/regexp.prototype.flags/-/regexp.prototype.flags-1.5.4.tgz",
@@ -7684,15 +7340,6 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/remeda": {
-      "version": "2.33.4",
-      "resolved": "https://registry.npmjs.org/remeda/-/remeda-2.33.4.tgz",
-      "integrity": "sha512-ygHswjlc/opg2VrtiYvUOPLjxjtdKvjGz1/plDhkG66hjNjFr1xmfrs2ClNFo/E6TyUFiwYNh53bKV26oBoMGQ==",
-      "license": "MIT",
-      "funding": {
-        "url": "https://github.com/sponsors/remeda"
-      }
-    },
     "node_modules/require-directory": {
       "version": "2.1.1",
       "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz",
@@ -7743,15 +7390,6 @@
         "url": "https://github.com/privatenumber/resolve-pkg-maps?sponsor=1"
       }
     },
-    "node_modules/retry": {
-      "version": "0.12.0",
-      "resolved": "https://registry.npmjs.org/retry/-/retry-0.12.0.tgz",
-      "integrity": "sha512-9LkiTwjUh6rT555DtE9rTX+BKByPfrMzEAtnlEtdEwr3Nkffwiihqe2bWADg+OQRjt9gl6ICdmB/ZFDCGAtSow==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 4"
-      }
-    },
     "node_modules/reusify": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/reusify/-/reusify-1.1.0.tgz",
@@ -7862,12 +7500,6 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/safer-buffer": {
-      "version": "2.1.2",
-      "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
-      "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==",
-      "license": "MIT"
-    },
     "node_modules/scheduler": {
       "version": "0.27.0",
       "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.27.0.tgz",
@@ -7884,11 +7516,6 @@
         "semver": "bin/semver.js"
       }
     },
-    "node_modules/seq-queue": {
-      "version": "0.0.5",
-      "resolved": "https://registry.npmjs.org/seq-queue/-/seq-queue-0.0.5.tgz",
-      "integrity": "sha512-hr3Wtp/GZIc/6DAGPDcV4/9WoZhjrkXsi5B/07QgX8tsdc6ilr7BFM6PM6rbdAX1kFSDYeZGLipIZZKyQP0O5Q=="
-    },
     "node_modules/set-function-length": {
       "version": "1.2.2",
       "resolved": "https://registry.npmjs.org/set-function-length/-/set-function-length-1.2.2.tgz",
@@ -8000,6 +7627,7 @@
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
       "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==",
+      "dev": true,
       "license": "MIT",
       "dependencies": {
         "shebang-regex": "^3.0.0"
@@ -8012,6 +7640,7 @@
       "version": "3.0.0",
       "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz",
       "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==",
+      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">=8"
@@ -8093,18 +7722,6 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/signal-exit": {
-      "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz",
-      "integrity": "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==",
-      "license": "ISC",
-      "engines": {
-        "node": ">=14"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/isaacs"
-      }
-    },
     "node_modules/socket.io": {
       "version": "4.8.3",
       "resolved": "https://registry.npmjs.org/socket.io/-/socket.io-4.8.3.tgz",
@@ -8179,15 +7796,6 @@
         "node": ">= 10.x"
       }
     },
-    "node_modules/sqlstring": {
-      "version": "2.3.3",
-      "resolved": "https://registry.npmjs.org/sqlstring/-/sqlstring-2.3.3.tgz",
-      "integrity": "sha512-qC9iz2FlN7DQl3+wjwn3802RTyjCx7sDvfQEXchwa6CWOx07/WVfh91gBmQ9fahw8snwGEWU3xGzOt4tFyHLxg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
     "node_modules/stable-hash": {
       "version": "0.0.5",
       "resolved": "https://registry.npmjs.org/stable-hash/-/stable-hash-0.0.5.tgz",
@@ -8201,12 +7809,6 @@
       "integrity": "sha512-HTEHMNieakEnoe33shBYcZ7NX83ACUjCu8c40iOGEZsngj9zRnkqS9j1pqQPXwobB0ZcVTk27REb7COQ0UR59w==",
       "license": "MIT"
     },
-    "node_modules/std-env": {
-      "version": "3.10.0",
-      "resolved": "https://registry.npmjs.org/std-env/-/std-env-3.10.0.tgz",
-      "integrity": "sha512-5GS12FdOZNliM5mAOxFRg7Ir0pWz8MdpYm6AY6VPkGpbA7ZzmbzNcBJQ0GPvvyWgcY7QAhCgf9Uy89I03faLkg==",
-      "license": "MIT"
-    },
     "node_modules/stop-iteration-iterator": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/stop-iteration-iterator/-/stop-iteration-iterator-1.1.0.tgz",
@@ -8822,20 +8424,6 @@
         "punycode": "^2.1.0"
       }
     },
-    "node_modules/valibot": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/valibot/-/valibot-1.2.0.tgz",
-      "integrity": "sha512-mm1rxUsmOxzrwnX5arGS+U4T25RdvpPjPN4yR0u9pUBov9+zGVtO84tif1eY4r6zWxVxu3KzIyknJy3rxfRZZg==",
-      "license": "MIT",
-      "peerDependencies": {
-        "typescript": ">=5"
-      },
-      "peerDependenciesMeta": {
-        "typescript": {
-          "optional": true
-        }
-      }
-    },
     "node_modules/vary": {
       "version": "1.1.2",
       "resolved": "https://registry.npmjs.org/vary/-/vary-1.1.2.tgz",
@@ -8887,6 +8475,7 @@
       "version": "2.0.2",
       "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
       "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==",
+      "dev": true,
       "license": "ISC",
       "dependencies": {
         "isexe": "^2.0.0"
@@ -9108,16 +8697,6 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/zeptomatch": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/zeptomatch/-/zeptomatch-2.1.0.tgz",
-      "integrity": "sha512-KiGErG2J0G82LSpniV0CtIzjlJ10E04j02VOudJsPyPwNZgGnRKQy7I1R7GMyg/QswnE4l7ohSGrQbQbjXPPDA==",
-      "license": "MIT",
-      "dependencies": {
-        "grammex": "^3.1.11",
-        "graphmatch": "^1.1.0"
-      }
-    },
     "node_modules/zod": {
       "version": "4.3.6",
       "resolved": "https://registry.npmjs.org/zod/-/zod-4.3.6.tgz",
diff --git a/package.json b/package.json
index da68c8d..e8f703c 100644
--- a/package.json
+++ b/package.json
@@ -25,7 +25,7 @@
     "lucide-react": "^0.460.0",
     "next": "16.1.6",
     "pg": "^8.18.0",
-    "prisma": "^7.3.0",
+    "prisma": "^6.19.2",
     "react": "19.2.3",
     "react-dom": "19.2.3",
     "socket.io": "^4.8.3",

From eacd785eb106908a2c164d2a3cca858ef0d4c370 Mon Sep 17 00:00:00 2001
From: "Sree Raj Muthaiya.A.L" <passiveuser369@gmail.com>
Date: Tue, 10 Feb 2026 13:07:05 +0530
Subject: [PATCH 7/9] nigga push 1.75

---
 app/api/match/[matchId]/submit/route.ts |  62 +---
 app/arena/page.tsx                      | 262 +++++++++++++++-
 app/arena/spectate/page.tsx             | 237 +++++++++++++++
 app/arena/submitted/page.tsx            |  37 +++
 components/arena/code-editor.tsx        | 378 ++++++++++++++++++++++--
 components/arena/points-panel.tsx       |  54 +++-
 components/arena/users-panel.tsx        |  21 +-
 lib/piston.ts                           |  14 +-
 pages/api/socket.ts                     |   4 +
 9 files changed, 967 insertions(+), 102 deletions(-)
 create mode 100644 app/arena/spectate/page.tsx
 create mode 100644 app/arena/submitted/page.tsx

diff --git a/app/api/match/[matchId]/submit/route.ts b/app/api/match/[matchId]/submit/route.ts
index 8bc3e23..2f52cc3 100644
--- a/app/api/match/[matchId]/submit/route.ts
+++ b/app/api/match/[matchId]/submit/route.ts
@@ -1,12 +1,11 @@
 // ============================================================
 // POST /api/match/[matchId]/submit — Submit code for a question
 // ============================================================
-// Runs code against test cases via Piston, stores results.
+// Stores submission without running code.
 
 import { NextRequest, NextResponse } from "next/server";
 import { prisma } from "@/lib/db";
 import { getUserFromRequest } from "@/lib/auth";
-import { runCode, type PistonResult } from "@/lib/piston";
 
 export async function POST(
   req: NextRequest,
@@ -70,48 +69,7 @@ export async function POST(
       );
     }
 
-    const question = matchQuestion.question;
-
-    // Run code against test cases via Piston
-    let testsPassed = 0;
-    let testsTotal = 0;
-    let lastStdout = "";
-    let lastStderr = "";
-    let lastExitCode = 0;
-    let execTimeMs = 0;
-
-    const testCases = (question.testCases as Array<{
-      input: string;
-      expectedOutput: string;
-    }>) || [];
-
-    testsTotal = testCases.length;
-
-    if (testsTotal > 0) {
-      for (const tc of testCases) {
-        const result: PistonResult = await runCode(language, code, tc.input);
-
-        lastStdout = result.run.stdout;
-        lastStderr = result.run.stderr;
-        lastExitCode = result.run.code;
-
-        // Compare output (trim whitespace)
-        const actual = result.run.stdout.trim();
-        const expected = tc.expectedOutput.trim();
-
-        if (actual === expected) {
-          testsPassed++;
-        }
-      }
-    } else {
-      // No test cases — just run the code once
-      const result: PistonResult = await runCode(language, code);
-      lastStdout = result.run.stdout;
-      lastStderr = result.run.stderr;
-      lastExitCode = result.run.code;
-    }
-
-    // Save submission
+    // Save submission (no execution required)
     const submission = await prisma.submission.create({
       data: {
         matchId,
@@ -120,23 +78,17 @@ export async function POST(
         code,
         language,
         charCount: code.length,
-        stdout: lastStdout,
-        stderr: lastStderr,
-        exitCode: lastExitCode,
-        execTimeMs,
-        testsPassed,
-        testsTotal,
       },
     });
 
     return NextResponse.json({
       submission: {
         id: submission.id,
-        testsPassed,
-        testsTotal,
-        stdout: lastStdout,
-        stderr: lastStderr,
-        exitCode: lastExitCode,
+        testsPassed: submission.testsPassed,
+        testsTotal: submission.testsTotal,
+        stdout: submission.stdout,
+        stderr: submission.stderr,
+        exitCode: submission.exitCode,
       },
     });
   } catch (error) {
diff --git a/app/arena/page.tsx b/app/arena/page.tsx
index 0d4d106..4cdc52d 100644
--- a/app/arena/page.tsx
+++ b/app/arena/page.tsx
@@ -1,12 +1,13 @@
 "use client"
 
-import { useEffect, useMemo, useState } from "react"
+import { useEffect, useMemo, useRef, useState } from "react"
 import { useSearchParams } from "next/navigation"
 import { CodeEditor } from "@/components/arena/code-editor"
 import { UsersPanel } from "@/components/arena/users-panel"
 import { PointsPanel } from "@/components/arena/points-panel"
 import { Terminal, ArrowLeft } from "lucide-react"
 import Link from "next/link"
+import { io, type Socket } from "socket.io-client"
 
 type MatchQuestion = {
   questionId: string
@@ -71,13 +72,69 @@ export default function ArenaPage() {
   const [match, setMatch] = useState<MatchDetails | null>(null)
   const [error, setError] = useState<string | null>(null)
   const [isLoading, setIsLoading] = useState(false)
+  const [isSubmittingAll, setIsSubmittingAll] = useState(false)
+  const [submitAllError, setSubmitAllError] = useState<string | null>(null)
   const [currentUserId, setCurrentUserId] = useState<string | null>(null)
+  const [activeQuestionId, setActiveQuestionId] = useState<string | null>(null)
+  const [seenQuestionIds, setSeenQuestionIds] = useState<string[]>([])
+  const [codeForBroadcast, setCodeForBroadcast] = useState("")
+  const [currentLanguage, setCurrentLanguage] = useState("python")
+  const socketRef = useRef<Socket | null>(null)
+  const broadcastTimer = useRef<number | null>(null)
 
   useEffect(() => {
     if (typeof window === "undefined") return
     setCurrentUserId(window.localStorage.getItem("cnc.userId"))
   }, [])
 
+  useEffect(() => {
+    if (!matchId) return
+    let active = true
+
+    const initSocket = async () => {
+      await fetch("/api/socket")
+      const socket = io({ path: "/api/socket" })
+      socketRef.current = socket
+
+      socket.on("connect", () => {
+        if (!active) return
+      })
+    }
+
+    initSocket()
+
+    return () => {
+      active = false
+      socketRef.current?.disconnect()
+      socketRef.current = null
+    }
+  }, [matchId])
+
+  useEffect(() => {
+    if (!socketRef.current || !matchId || !currentUserId || !activeQuestionId) {
+      return
+    }
+
+    if (broadcastTimer.current) {
+      window.clearTimeout(broadcastTimer.current)
+    }
+
+    broadcastTimer.current = window.setTimeout(() => {
+      socketRef.current?.emit("arena:code", {
+        matchId,
+        userId: currentUserId,
+        questionId: activeQuestionId,
+        code: codeForBroadcast,
+      })
+    }, 400)
+
+    return () => {
+      if (broadcastTimer.current) {
+        window.clearTimeout(broadcastTimer.current)
+      }
+    }
+  }, [activeQuestionId, codeForBroadcast, currentUserId, matchId])
+
   useEffect(() => {
     if (!matchId) return
     let active = true
@@ -110,6 +167,24 @@ export default function ArenaPage() {
     }
   }, [matchId])
 
+  useEffect(() => {
+    if (!match?.questions?.length) {
+      setActiveQuestionId(null)
+      setSeenQuestionIds([])
+      return
+    }
+    const firstId = match.questions[0].questionId
+    setActiveQuestionId(firstId)
+    setSeenQuestionIds([firstId])
+  }, [match?.id])
+
+  useEffect(() => {
+    if (!activeQuestionId) return
+    setSeenQuestionIds((prev) =>
+      prev.includes(activeQuestionId) ? prev : [...prev, activeQuestionId],
+    )
+  }, [activeQuestionId, match?.questions])
+
   const submissionStatus = useMemo(() => {
     const attempted = new Set<string>()
     const solved = new Set<string>()
@@ -158,11 +233,13 @@ export default function ArenaPage() {
   const scoreboardQuestions = useMemo(() => {
     if (!match) return undefined
     return match.questions.map((mq, index) => {
-      let status: "solved" | "attempted" | "locked" = "locked"
+      let status: "solved" | "attempted" | "seen" | "locked" = "locked"
       if (submissionStatus.solved.has(mq.questionId)) {
         status = "solved"
       } else if (submissionStatus.attempted.has(mq.questionId)) {
         status = "attempted"
+      } else if (seenQuestionIds.includes(mq.questionId)) {
+        status = "seen"
       }
 
       const maxPoints =
@@ -172,6 +249,7 @@ export default function ArenaPage() {
 
       return {
         id: index + 1,
+        questionId: mq.questionId,
         title: mq.question.title,
         status,
         points,
@@ -179,9 +257,11 @@ export default function ArenaPage() {
         bonuses: [],
       }
     })
-  }, [match, submissionStatus])
+  }, [match, seenQuestionIds, submissionStatus])
 
-  const activeQuestion = match?.questions?.[0]?.question
+  const activeQuestion =
+    match?.questions.find((q) => q.questionId === activeQuestionId)?.question ??
+    match?.questions?.[0]?.question
   const activeExamples = Array.isArray(activeQuestion?.testCases)
     ? activeQuestion?.testCases
     : []
@@ -242,12 +322,80 @@ export default function ArenaPage() {
           {error}
         </div>
       )}
+      {submitAllError && (
+        <div className="border-b border-border bg-destructive/10 px-4 py-2 text-xs text-destructive">
+          {submitAllError}
+        </div>
+      )}
 
       {/* Main content area */}
       <div className="flex flex-1 overflow-hidden">
         {/* Code editor - center/left */}
         <div className="relative flex flex-1 flex-col overflow-hidden p-2">
-          <CodeEditor problem={problem} />
+          <CodeEditor
+            problem={problem}
+            matchId={match?.id ?? matchId}
+            questionId={activeQuestionId}
+            problemTitle={activeQuestion?.title}
+            onCodeChange={(next) => setCodeForBroadcast(next)}
+            onLanguageChange={(next) => setCurrentLanguage(next)}
+            onSubmissionRecorded={({ questionId, testsPassed, testsTotal }) => {
+              setMatch((prev) => {
+                if (!prev) return prev
+                const existing = prev.submissions.find(
+                  (s) => s.questionId === questionId,
+                )
+                const nextSubmission = {
+                  questionId,
+                  testsPassed,
+                  testsTotal,
+                }
+                const submissions = existing
+                  ? prev.submissions.map((s) =>
+                      s.questionId === questionId ? nextSubmission : s,
+                    )
+                  : [...prev.submissions, nextSubmission]
+
+                const ordered = [...prev.questions].sort(
+                  (a, b) => a.order - b.order,
+                )
+                const currentIndex = ordered.findIndex(
+                  (q) => q.questionId === questionId,
+                )
+                const attempted = new Set(
+                  submissions.map((s) => s.questionId),
+                )
+
+                let nextId: string | null = null
+                for (let i = currentIndex + 1; i < ordered.length; i += 1) {
+                  if (!attempted.has(ordered[i].questionId)) {
+                    nextId = ordered[i].questionId
+                    break
+                  }
+                }
+                if (!nextId) {
+                  for (let i = 0; i < ordered.length; i += 1) {
+                    if (!attempted.has(ordered[i].questionId)) {
+                      nextId = ordered[i].questionId
+                      break
+                    }
+                  }
+                }
+
+                if (nextId) {
+                  setActiveQuestionId(nextId)
+                } else {
+                  if (matchId) {
+                    window.location.href = `/arena/spectate?match=${matchId}`
+                  } else {
+                    window.location.href = "/arena/spectate"
+                  }
+                }
+
+                return { ...prev, submissions }
+              })
+            }}
+          />
           {isLoading && (
             <div className="absolute bottom-4 left-4 rounded-sm border border-border bg-card px-3 py-1.5 text-xs text-muted-foreground">
               Loading match...
@@ -264,6 +412,110 @@ export default function ArenaPage() {
                 ? scoreboardQuestions
                 : undefined
             }
+            activeQuestionId={activeQuestionId}
+            onSelectQuestion={(questionId) => setActiveQuestionId(questionId)}
+            actionLabel="Submit All Codes"
+            actionDisabled={isSubmittingAll}
+            actionLoading={isSubmittingAll}
+            onAction={async () => {
+              if (!matchId || !match) {
+                setSubmitAllError("Match not loaded.")
+                return
+              }
+              setSubmitAllError(null)
+              setIsSubmittingAll(true)
+              try {
+                if (
+                  typeof window !== "undefined" &&
+                  activeQuestionId &&
+                  activeQuestion?.title
+                ) {
+                  window.localStorage.setItem(
+                    activeQuestion.title,
+                    codeForBroadcast,
+                  )
+                }
+                const ordered = [...match.questions].sort(
+                  (a, b) => a.order - b.order,
+                )
+                const submissions: MatchSubmission[] = []
+                const failures: string[] = []
+
+                const placeholderForLanguage = (lang: string) => {
+                  const key = lang.toLowerCase()
+                  if (key.includes("python")) return "# no code submitted\n"
+                  if (key.includes("javascript") || key === "js")
+                    return "// no code submitted\n"
+                  if (key.includes("typescript") || key === "ts")
+                    return "// no code submitted\n"
+                  if (key === "java")
+                    return "public class Main { public static void main(String[] args) {} }\n"
+                  if (key.includes("c++") || key.includes("cpp"))
+                    return "#include <bits/stdc++.h>\nint main(){return 0;}\n"
+                  if (key === "c") return "#include <stdio.h>\nint main(){return 0;}\n"
+                  if (key.includes("go"))
+                    return "package main\nfunc main(){}\n"
+                  if (key.includes("rust"))
+                    return "fn main() {}\n"
+                  return "// no code submitted\n"
+                }
+
+                for (const item of ordered) {
+                  const title = item.question.title
+                  const code =
+                    typeof window !== "undefined"
+                      ? window.localStorage.getItem(title) ?? ""
+                      : ""
+                  const finalCode =
+                    code.trim().length > 0
+                      ? code
+                      : placeholderForLanguage(currentLanguage || "python")
+
+                  const res = await fetch(`/api/match/${matchId}/submit`, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify({
+                      questionId: item.questionId,
+                      code: finalCode,
+                      language: currentLanguage || "python",
+                    }),
+                  })
+                  const payload = await res.json().catch(() => ({}))
+                  if (!res.ok) {
+                    failures.push(
+                      `${title}: ${payload?.error || "submit failed"}`,
+                    )
+                    continue
+                  }
+                  submissions.push({
+                    questionId: item.questionId,
+                    testsPassed: payload?.submission?.testsPassed ?? 0,
+                    testsTotal: payload?.submission?.testsTotal ?? 0,
+                  })
+                }
+
+                if (submissions.length > 0) {
+                  setMatch((prev) =>
+                    prev ? { ...prev, submissions } : prev,
+                  )
+                }
+
+                if (failures.length > 0) {
+                  setSubmitAllError(
+                    `Some submissions failed: ${failures.join(", ")}`,
+                  )
+                  return
+                }
+
+                window.location.href = `/arena/submitted?match=${matchId}`
+              } catch (err) {
+                setSubmitAllError(
+                  err instanceof Error ? err.message : "Submit all failed.",
+                )
+              } finally {
+                setIsSubmittingAll(false)
+              }
+            }}
           />
         </div>
       </div>
diff --git a/app/arena/spectate/page.tsx b/app/arena/spectate/page.tsx
new file mode 100644
index 0000000..8b12232
--- /dev/null
+++ b/app/arena/spectate/page.tsx
@@ -0,0 +1,237 @@
+"use client"
+
+import { useEffect, useMemo, useRef, useState } from "react"
+import { useSearchParams } from "next/navigation"
+import Link from "next/link"
+import { ArrowLeft, Terminal, Eye } from "lucide-react"
+import { io, type Socket } from "socket.io-client"
+
+type MatchQuestion = {
+  questionId: string
+  question: {
+    title: string
+  }
+}
+
+type MatchPlayer = {
+  userId: string
+  user: {
+    id: string
+    username: string
+    displayName: string | null
+    elo: number
+  }
+}
+
+type MatchDetails = {
+  id: string
+  players: MatchPlayer[]
+  questions: MatchQuestion[]
+}
+
+type CodePayload = {
+  matchId: string
+  userId: string
+  questionId?: string
+  code?: string
+}
+
+export default function SpectatePage() {
+  const searchParams = useSearchParams()
+  const matchId = searchParams.get("match")
+  const [match, setMatch] = useState<MatchDetails | null>(null)
+  const [error, setError] = useState<string | null>(null)
+  const [selectedUserId, setSelectedUserId] = useState<string | null>(null)
+  const [codeByUser, setCodeByUser] = useState<
+    Record<string, { code: string; questionId?: string }>
+  >({})
+  const socketRef = useRef<Socket | null>(null)
+
+  useEffect(() => {
+    if (!matchId) return
+    let active = true
+
+    const loadMatch = async () => {
+      try {
+        const res = await fetch(`/api/match/${matchId}`, {
+          credentials: "include",
+        })
+        const payload = await res.json().catch(() => ({}))
+        if (!res.ok) {
+          throw new Error(payload?.error || "Failed to load match.")
+        }
+        if (!active) return
+        setMatch(payload.match as MatchDetails)
+        const first = payload.match?.players?.[0]?.userId ?? null
+        setSelectedUserId((prev) => prev ?? first)
+      } catch (err) {
+        if (!active) return
+        setError(err instanceof Error ? err.message : "Failed to load match.")
+      }
+    }
+
+    loadMatch()
+
+    return () => {
+      active = false
+    }
+  }, [matchId])
+
+  useEffect(() => {
+    if (!matchId) return
+    let active = true
+
+    const initSocket = async () => {
+      await fetch("/api/socket")
+      const socket = io({ path: "/api/socket" })
+      socketRef.current = socket
+
+      socket.on("arena:code", (payload: CodePayload) => {
+        if (!active || payload.matchId !== matchId) return
+        setCodeByUser((prev) => ({
+          ...prev,
+          [payload.userId]: {
+            code: payload.code ?? "",
+            questionId: payload.questionId,
+          },
+        }))
+      })
+    }
+
+    initSocket()
+
+    return () => {
+      active = false
+      socketRef.current?.disconnect()
+      socketRef.current = null
+    }
+  }, [matchId])
+
+  const selectedPlayer = match?.players.find(
+    (player) => player.userId === selectedUserId,
+  )
+
+  const selectedName = selectedPlayer
+    ? selectedPlayer.user.displayName || selectedPlayer.user.username
+    : "Select a player"
+
+  const selectedCode = selectedUserId
+    ? codeByUser[selectedUserId]?.code ?? ""
+    : ""
+
+  const selectedQuestionTitle = useMemo(() => {
+    if (!selectedUserId || !match) return "Waiting for activity..."
+    const questionId = codeByUser[selectedUserId]?.questionId
+    if (!questionId) return "Waiting for activity..."
+    const question = match.questions.find((q) => q.questionId === questionId)
+    return question?.question.title ?? "Working on a question..."
+  }, [codeByUser, match, selectedUserId])
+
+  return (
+    <main className="relative min-h-screen bg-background px-4 py-8">
+      <div className="mx-auto w-full max-w-5xl">
+        <Link
+          href="/arena/lobby"
+          className="mb-6 inline-flex items-center gap-2 text-xs uppercase tracking-widest text-muted-foreground transition-colors hover:text-primary"
+        >
+          <ArrowLeft className="h-3 w-3" />
+          Back to Lobby
+        </Link>
+
+        <div className="rounded-sm border border-border bg-card p-6">
+          <div className="mb-6 flex items-center gap-3">
+            <div className="flex h-10 w-10 items-center justify-center rounded-sm border border-border bg-secondary">
+              <Terminal className="h-5 w-5 text-primary" />
+            </div>
+            <div>
+              <h1 className="text-lg font-bold uppercase tracking-widest text-foreground">
+                Spectate Arena
+              </h1>
+              <p className="text-xs text-muted-foreground">
+                Watch any player in real time.
+              </p>
+            </div>
+          </div>
+
+          {error && (
+            <div className="mb-4 rounded-sm border border-destructive/30 bg-destructive/10 px-3 py-2 text-xs text-destructive">
+              {error}
+            </div>
+          )}
+
+          {!matchId && (
+            <div className="rounded-sm border border-border bg-secondary/40 px-3 py-2 text-xs text-muted-foreground">
+              No match selected.
+            </div>
+          )}
+
+          {matchId && (
+            <div className="grid gap-4 lg:grid-cols-[260px,1fr]">
+              <div className="rounded-sm border border-border bg-secondary/40 p-3">
+                <div className="mb-3 flex items-center gap-2 text-xs uppercase tracking-widest text-primary">
+                  <Eye className="h-4 w-4" />
+                  Players
+                </div>
+                <div className="space-y-2">
+                  {(match?.players ?? []).map((player) => {
+                    const display =
+                      player.user.displayName || player.user.username
+                    const isActive = player.userId === selectedUserId
+                    return (
+                      <button
+                        key={player.userId}
+                        type="button"
+                        onClick={() => setSelectedUserId(player.userId)}
+                        className={`flex w-full items-center justify-between rounded-sm border px-3 py-2 text-xs transition ${
+                          isActive
+                            ? "border-primary/40 bg-primary/10 text-primary"
+                            : "border-border bg-card text-foreground hover:border-primary/30"
+                        }`}
+                      >
+                        <span className="font-semibold">{display}</span>
+                        <span className="text-muted-foreground">
+                          {player.user.elo} ELO
+                        </span>
+                      </button>
+                    )
+                  })}
+                  {match && match.players.length === 0 && (
+                    <p className="text-xs text-muted-foreground">
+                      No players connected.
+                    </p>
+                  )}
+                </div>
+              </div>
+
+              <div className="rounded-sm border border-border bg-secondary/40 p-4">
+                <div className="mb-3 flex items-center justify-between">
+                  <div>
+                    <p className="text-xs uppercase tracking-widest text-muted-foreground">
+                      Watching
+                    </p>
+                    <h2 className="text-lg font-semibold text-foreground">
+                      {selectedName}
+                    </h2>
+                  </div>
+                  <span className="text-xs uppercase tracking-widest text-primary">
+                    Live
+                  </span>
+                </div>
+
+                <div className="mb-4 rounded-sm border border-border bg-card px-3 py-2 text-xs text-muted-foreground">
+                  {selectedQuestionTitle}
+                </div>
+
+                <div className="rounded-sm border border-border bg-black/60 p-3">
+                  <pre className="min-h-[280px] whitespace-pre-wrap text-xs text-foreground">
+                    {selectedCode || "Waiting for code updates..."}
+                  </pre>
+                </div>
+              </div>
+            </div>
+          )}
+        </div>
+      </div>
+    </main>
+  )
+}
diff --git a/app/arena/submitted/page.tsx b/app/arena/submitted/page.tsx
new file mode 100644
index 0000000..57ec762
--- /dev/null
+++ b/app/arena/submitted/page.tsx
@@ -0,0 +1,37 @@
+"use client"
+
+import Link from "next/link"
+import { ArrowLeft, Terminal } from "lucide-react"
+
+export default function ArenaSubmittedPage() {
+  return (
+    <main className="relative flex min-h-screen items-center justify-center bg-background px-4">
+      <div className="w-full max-w-lg rounded-sm border border-border bg-card p-6 text-center">
+        <div className="mx-auto mb-4 flex h-12 w-12 items-center justify-center rounded-sm border border-border bg-secondary">
+          <Terminal className="h-6 w-6 text-primary" />
+        </div>
+        <h1 className="text-lg font-bold uppercase tracking-widest text-foreground">
+          All Codes Submitted
+        </h1>
+        <p className="mt-2 text-xs text-muted-foreground">
+          Your solutions have been recorded. You can head back to your profile.
+        </p>
+
+        <Link
+          href="/profile"
+          className="mt-6 inline-flex w-full items-center justify-center rounded-sm border border-primary bg-primary px-4 py-2 text-xs font-bold uppercase tracking-widest text-primary-foreground transition hover:bg-primary/90"
+        >
+          Go to Profile
+        </Link>
+
+        <Link
+          href="/arena/lobby"
+          className="mt-3 inline-flex w-full items-center justify-center gap-2 rounded-sm border border-border bg-secondary px-4 py-2 text-xs uppercase tracking-widest text-foreground transition hover:border-primary/40"
+        >
+          <ArrowLeft className="h-3 w-3" />
+          Back to Lobby
+        </Link>
+      </div>
+    </main>
+  )
+}
diff --git a/components/arena/code-editor.tsx b/components/arena/code-editor.tsx
index a43a4ac..075943a 100644
--- a/components/arena/code-editor.tsx
+++ b/components/arena/code-editor.tsx
@@ -1,7 +1,7 @@
 "use client"
 
-import { useEffect, useMemo, useState } from "react"
-import { Play, RotateCcw, Send, ChevronDown } from "lucide-react"
+import { useEffect, useMemo, useRef, useState } from "react"
+import { Play, RotateCcw, ChevronDown } from "lucide-react"
 import dynamic from "next/dynamic"
 
 const MonacoEditor = dynamic(
@@ -189,22 +189,121 @@ type CodeEditorProblem = {
 
 type CodeEditorProps = {
   problem?: CodeEditorProblem
+  matchId?: string | null
+  questionId?: string | null
+  problemTitle?: string
+  onSubmissionRecorded?: (payload: {
+    questionId: string
+    testsPassed: number
+    testsTotal: number
+  }) => void
+  onCodeChange?: (code: string) => void
+  onLanguageChange?: (language: string) => void
 }
 
-export function CodeEditor({ problem }: CodeEditorProps) {
+type SubmissionCacheItem = {
+  problemTitle: string
+  codeDescription: string
+  submittedAt: string
+  testsPassed: string
+}
+
+export function CodeEditor({
+  problem,
+  matchId,
+  questionId,
+  problemTitle,
+  onSubmissionRecorded,
+  onCodeChange,
+  onLanguageChange,
+}: CodeEditorProps) {
   const [code, setCode] = useState(defaultCode)
-  const [activeTab, setActiveTab] = useState<"problem" | "output">("problem")
+  const [activeTab, setActiveTab] = useState<"problem" | "input">("problem")
   const [language, setLanguage] = useState("python")
   const [showLangDropdown, setShowLangDropdown] = useState(false)
   const [output, setOutput] = useState("")
+  const [customInput, setCustomInput] = useState("")
   const [runtimes, setRuntimes] = useState<PistonRuntime[]>([])
   const [runtimeError, setRuntimeError] = useState<string | null>(null)
   const [isLoadingRuntimes, setIsLoadingRuntimes] = useState(false)
   const [isRunning, setIsRunning] = useState(false)
+  const [isRunningSamples, setIsRunningSamples] = useState(false)
+  const [sampleError, setSampleError] = useState<string | null>(null)
+  const [sampleResults, setSampleResults] = useState<
+    Array<{
+      input: string
+      expected: string
+      actual?: string
+      status: "pass" | "fail" | "error" | "idle"
+    }>
+  >([])
+  const [submissionCache, setSubmissionCache] = useState<SubmissionCacheItem[]>(
+    [],
+  )
   const activeProblem = problem ?? problemStatement
   const problemTag = activeProblem.tag ?? problemStatement.tag
   const problemDifficulty =
     activeProblem.difficulty ?? problemStatement.difficulty
+  const difficultyClass = (() => {
+    const normalized = problemDifficulty?.toLowerCase()
+    if (normalized === "easy") {
+      return "border-emerald-500/40 bg-emerald-500/10 text-emerald-300"
+    }
+    if (normalized === "medium") {
+      return "border-amber-500/40 bg-amber-500/10 text-amber-300"
+    }
+    if (normalized === "hard") {
+      return "border-rose-500/40 bg-rose-500/10 text-rose-300"
+    }
+    return "border-primary/30 bg-primary/10 text-primary"
+  })()
+  const saveTimerRef = useRef<number | null>(null)
+  const lastTitleRef = useRef<string | null>(null)
+
+  const storageTitle = problemTitle ?? activeProblem.title
+
+  useEffect(() => {
+    if (!storageTitle) return
+    if (lastTitleRef.current !== storageTitle) {
+      const isFirstLoad = lastTitleRef.current === null
+      lastTitleRef.current = storageTitle
+      if (typeof window !== "undefined") {
+        const cached = window.localStorage.getItem(storageTitle)
+        if (cached !== null) {
+          setCode(cached)
+        } else if (!isFirstLoad) {
+          setCode("")
+        }
+      }
+    }
+  }, [storageTitle])
+  useEffect(() => {
+    if (onCodeChange) {
+      onCodeChange(code)
+    }
+  }, [code, onCodeChange])
+
+  useEffect(() => {
+    if (onLanguageChange) {
+      onLanguageChange(language)
+    }
+  }, [language, onLanguageChange])
+
+  useEffect(() => {
+    if (!storageTitle) return
+    if (saveTimerRef.current) {
+      window.clearTimeout(saveTimerRef.current)
+    }
+    saveTimerRef.current = window.setTimeout(() => {
+      if (typeof window === "undefined") return
+      window.localStorage.setItem(storageTitle, code)
+    }, 3000)
+    return () => {
+      if (saveTimerRef.current) {
+        window.clearTimeout(saveTimerRef.current)
+      }
+    }
+  }, [code, storageTitle])
 
   const handleEditorWillMount = (monaco: any) => {
     monaco.editor.defineTheme("black-green", {
@@ -272,7 +371,7 @@ export function CodeEditor({ problem }: CodeEditorProps) {
   }, [])
 
   const handleRun = async () => {
-    setActiveTab("output")
+    setActiveTab("input")
     setOutput("Running...\n")
     setIsRunning(true)
 
@@ -299,7 +398,7 @@ export function CodeEditor({ problem }: CodeEditorProps) {
               content: code,
             },
           ],
-          stdin: "",
+          stdin: customInput,
         }),
       })
 
@@ -313,14 +412,147 @@ export function CodeEditor({ problem }: CodeEditorProps) {
     }
   }
 
-  const handleSubmit = () => {
-    setActiveTab("output")
+  const handleRunSamples = async () => {
+    setSampleError(null)
+    const examples =
+      activeProblem.examples && activeProblem.examples.length > 0
+        ? activeProblem.examples
+        : problemStatement.examples
+
+    if (!examples || examples.length === 0) {
+      setSampleError("No sample tests available for this question.")
+      return
+    }
+
+    if (!selectedRuntime) {
+      setSampleError("No runtime available for the selected language.")
+      return
+    }
+
+    setIsRunningSamples(true)
+    setSampleResults(
+      examples.map((ex) => ({
+        input: ex.input,
+        expected: ex.output,
+        status: "idle",
+      })),
+    )
+
+    const fileName = fileNameForLanguage(language)
+    const results: Array<{
+      input: string
+      expected: string
+      actual?: string
+      status: "pass" | "fail" | "error" | "idle"
+    }> = []
+
+    for (const ex of examples) {
+      try {
+        const submissionRes = await fetch(`${PISTON_BASE}/execute`, {
+          method: "POST",
+          headers: {
+            ...baseHeaders,
+            "Content-Type": "application/json",
+          },
+          body: JSON.stringify({
+            language: selectedRuntime.language,
+            version: selectedRuntime.version,
+            files: [
+              {
+                ...(fileName ? { name: fileName } : {}),
+                content: code,
+              },
+            ],
+            stdin: ex.input ?? "",
+          }),
+        })
+
+        const execution = await jsonGuard<PistonExecuteResponse>(submissionRes)
+        const actual = (execution.run.stdout || execution.run.output || "")
+          .trim()
+        const expected = (ex.output ?? "").trim()
+        const status = actual === expected ? "pass" : "fail"
+        results.push({
+          input: ex.input,
+          expected: ex.output,
+          actual,
+          status,
+        })
+      } catch (err: unknown) {
+        const message = err instanceof Error ? err.message : "Execution failed."
+        results.push({
+          input: ex.input,
+          expected: ex.output,
+          actual: message,
+          status: "error",
+        })
+      }
+      setSampleResults([...results])
+    }
+
+    setIsRunningSamples(false)
+  }
+
+  const handleSubmit = async () => {
+    setActiveTab("input")
     setOutput("Submitting...\n")
-    setTimeout(() => {
+
+    if (!matchId || !questionId) {
+      setOutput("Missing match or question context. Unable to submit.")
+      return
+    }
+
+    try {
+      const res = await fetch(`/api/match/${matchId}/submit`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          questionId,
+          code,
+          language,
+        }),
+      })
+      const payload = await res.json().catch(() => ({}))
+      if (!res.ok) {
+        setOutput(payload?.error || "Submission failed.")
+        return
+      }
+
+      const testsPassed = payload?.submission?.testsPassed ?? 0
+      const testsTotal = payload?.submission?.testsTotal ?? 0
+      const outputText =
+        payload?.submission?.stdout ||
+        payload?.submission?.stderr ||
+        "Submitted."
+
       setOutput(
-        `$ submit solution.py\n\n[ACCEPTED]\n\nRuntime: 4ms (faster than 95.2%)\nMemory: 14.2 MB (less than 88.1%)\n\nTime Complexity: O(n)\nSpace Complexity: O(n)\n\nCode Quality Score: 87/100\n  - Naming: 9/10\n  - Readability: 9/10\n  - Efficiency: 10/10\n  - Clean Code: 8.7/10\n\n+150 XP | +25 Speed Bonus | First Blood: +50 XP`
+        `${outputText}\n\nTests: ${testsPassed}/${testsTotal}\nSubmission recorded.`,
       )
-    }, 1500)
+
+      const cacheItem: SubmissionCacheItem = {
+        problemTitle: problemTitle ?? activeProblem.title,
+        codeDescription: code,
+        submittedAt: new Date().toISOString(),
+        testsPassed: `${testsPassed}/${testsTotal}`,
+      }
+
+      setSubmissionCache((prev) => {
+        const next = [cacheItem, ...prev]
+        if (typeof window !== "undefined") {
+          window.localStorage.setItem(
+            "cnc.submissions",
+            JSON.stringify(next),
+          )
+        }
+        return next
+      })
+
+      if (onSubmissionRecorded && questionId) {
+        onSubmissionRecorded({ questionId, testsPassed, testsTotal })
+      }
+    } catch (err) {
+      setOutput(err instanceof Error ? err.message : "Submission failed.")
+    }
   }
 
   return (
@@ -340,14 +572,14 @@ export function CodeEditor({ problem }: CodeEditorProps) {
             Problem
           </button>
           <button
-            onClick={() => setActiveTab("output")}
+            onClick={() => setActiveTab("input")}
             className={`flex-1 px-4 py-2 text-xs uppercase tracking-widest transition-colors ${
-              activeTab === "output"
+              activeTab === "input"
                 ? "border-b-2 border-primary bg-secondary/50 text-primary"
                 : "text-muted-foreground hover:text-foreground"
             }`}
           >
-            Output
+            Custom Input
           </button>
         </div>
 
@@ -361,7 +593,7 @@ export function CodeEditor({ problem }: CodeEditorProps) {
                   {activeProblem.title}
                 </h2>
                 {problemDifficulty && (
-                  <span className="rounded-sm border border-primary/30 bg-primary/10 px-2 py-0.5 text-xs text-primary">
+                  <span className={`rounded-sm border px-2 py-0.5 text-xs ${difficultyClass}`}>
                     {problemDifficulty}
                   </span>
                 )}
@@ -408,11 +640,113 @@ export function CodeEditor({ problem }: CodeEditorProps) {
                     </ul>
                   </div>
                 )}
+
+              <div className="mt-2 flex flex-col gap-3">
+                <div className="flex items-center justify-between">
+                  <span className="text-xs uppercase tracking-widest text-primary">
+                    {"Sample tests"}
+                  </span>
+                  <button
+                    onClick={handleRunSamples}
+                    disabled={isRunningSamples || isLoadingRuntimes}
+                    className="rounded-sm border border-border bg-secondary px-3 py-1 text-[10px] font-bold uppercase tracking-widest text-foreground transition hover:border-primary hover:text-primary disabled:opacity-70"
+                  >
+                    {isRunningSamples ? "Running..." : "Run Samples"}
+                  </button>
+                </div>
+
+                {sampleError && (
+                  <div className="rounded-sm border border-destructive/30 bg-destructive/10 px-3 py-2 text-xs text-destructive">
+                    {sampleError}
+                  </div>
+                )}
+
+                <div className="space-y-2">
+                  {(sampleResults.length > 0
+                    ? sampleResults
+                    : (activeProblem.examples && activeProblem.examples.length > 0
+                        ? activeProblem.examples
+                        : problemStatement.examples
+                      ).map((ex) => ({
+                        input: ex.input,
+                        expected: ex.output,
+                        status: "idle" as const,
+                      }))
+                  ).map((result, index) => (
+                    <div
+                      key={`${result.input}-${index}`}
+                      className="rounded-sm border border-border bg-secondary/40 p-3 text-xs"
+                    >
+                      <div className="flex items-center justify-between">
+                        <span className="text-xs uppercase tracking-widest text-muted-foreground">
+                          {"Case " + (index + 1)}
+                        </span>
+                        <span
+                          className={`rounded-sm border px-2 py-0.5 text-[10px] uppercase tracking-widest ${
+                            result.status === "pass"
+                              ? "border-primary/30 bg-primary/10 text-primary"
+                              : result.status === "fail"
+                              ? "border-yellow-500/30 bg-yellow-500/10 text-yellow-300"
+                              : result.status === "error"
+                              ? "border-rose-500/30 bg-rose-500/10 text-rose-300"
+                              : "border-border bg-secondary/60 text-muted-foreground"
+                          }`}
+                        >
+                          {result.status === "pass"
+                            ? "PASS"
+                            : result.status === "fail"
+                            ? "FAIL"
+                            : result.status === "error"
+                            ? "ERROR"
+                            : "NOT RUN"}
+                        </span>
+                      </div>
+                      <div className="mt-2 text-xs text-muted-foreground">
+                        <span className="text-primary">{"Input: "}</span>
+                        {result.input}
+                      </div>
+                      <div className="mt-1 text-xs text-muted-foreground">
+                        <span className="text-primary">{"Expected: "}</span>
+                        {result.expected}
+                      </div>
+                      {result.status !== "idle" && (
+                        <div className="mt-1 text-xs text-muted-foreground">
+                          <span className="text-primary">{"Actual: "}</span>
+                          {result.actual ?? ""}
+                        </div>
+                      )}
+                    </div>
+                  ))}
+                </div>
+              </div>
             </div>
           ) : (
-            <pre className="whitespace-pre-wrap text-xs leading-relaxed text-foreground">
-              {output || "No output yet. Run your code to see results."}
-            </pre>
+            <div className="flex flex-col gap-3">
+              <div className="flex items-center justify-between">
+                <span className="text-xs uppercase tracking-widest text-primary">
+                  {"Custom input"}
+                </span>
+                <span className="text-[10px] uppercase tracking-widest text-muted-foreground">
+                  {"stdin"}
+                </span>
+              </div>
+              <textarea
+                className="h-24 w-full resize-none rounded-sm border border-border bg-secondary/40 px-3 py-2 text-xs text-foreground focus:border-primary focus:outline-none"
+                value={customInput}
+                onChange={(event) => setCustomInput(event.target.value)}
+                placeholder="Provide input for your program (optional)"
+              />
+              <div className="flex flex-col gap-2">
+                <span className="text-xs uppercase tracking-widest text-primary">
+                  {"Last output"}
+                </span>
+                <div className="rounded-sm border border-border bg-secondary/40 p-3">
+                  <pre className="whitespace-pre-wrap text-xs leading-relaxed text-foreground">
+                    {output || "No output yet. Run your code to see results."}
+                  </pre>
+                </div>
+              </div>
+            </div>
           )}
         </div>
       </div>
@@ -484,13 +818,7 @@ export function CodeEditor({ problem }: CodeEditorProps) {
               <Play className="h-3 w-3 text-primary" />
               {isRunning ? "Running" : "Run"}
             </button>
-            <button
-              onClick={handleSubmit}
-              className="flex items-center gap-1.5 rounded-sm border border-primary bg-primary px-3 py-1.5 text-xs uppercase tracking-widest text-primary-foreground transition-all hover:bg-primary/90"
-            >
-              <Send className="h-3 w-3" />
-              Submit
-            </button>
+            {/* Submit moved to scoreboard */}
           </div>
         </div>
 
diff --git a/components/arena/points-panel.tsx b/components/arena/points-panel.tsx
index 1ab55af..d3177b2 100644
--- a/components/arena/points-panel.tsx
+++ b/components/arena/points-panel.tsx
@@ -2,8 +2,9 @@ import { Trophy, Zap, Star, Clock } from "lucide-react"
 
 interface QuestionResult {
   id: number
+  questionId?: string
   title: string
-  status: "solved" | "attempted" | "locked"
+  status: "solved" | "attempted" | "seen" | "locked"
   points: number
   maxPoints: number
   bonuses: string[]
@@ -55,20 +56,36 @@ const questions: QuestionResult[] = [
 const statusStyles = {
   solved: "border-primary/30 bg-primary/5 text-primary",
   attempted: "border-yellow-500/30 bg-yellow-500/5 text-yellow-400",
+  seen: "border-border bg-secondary/50 text-foreground",
   locked: "border-border bg-secondary/30 text-muted-foreground",
 }
 
 const statusLabels = {
   solved: "SOLVED",
   attempted: "IN PROGRESS",
+  seen: "SEEN",
   locked: "NOT SEEN",
 }
 
 type PointsPanelProps = {
   questions?: QuestionResult[]
+  activeQuestionId?: string | null
+  onSelectQuestion?: (questionId: string) => void
+  actionLabel?: string
+  onAction?: () => void
+  actionDisabled?: boolean
+  actionLoading?: boolean
 }
 
-export function PointsPanel({ questions: questionsProp }: PointsPanelProps) {
+export function PointsPanel({
+  questions: questionsProp,
+  activeQuestionId,
+  onSelectQuestion,
+  actionLabel,
+  onAction,
+  actionDisabled,
+  actionLoading,
+}: PointsPanelProps) {
   const resolvedQuestions =
     questionsProp && questionsProp.length > 0 ? questionsProp : questions
   const totalPoints = resolvedQuestions.reduce((sum, q) => sum + q.points, 0)
@@ -90,11 +107,24 @@ export function PointsPanel({ questions: questionsProp }: PointsPanelProps) {
 
       {/* Question breakdown */}
       <div className="flex flex-col">
-        {resolvedQuestions.map((q) => (
+        {resolvedQuestions.map((q) => {
+          const isActive = Boolean(
+            activeQuestionId && q.questionId === activeQuestionId,
+          )
+          const canSelect = Boolean(onSelectQuestion && q.questionId)
+          return (
           <button
             key={q.id}
             type="button"
-            className="flex w-full flex-col gap-1.5 border-b border-border/50 px-3 py-2.5 text-left transition hover:bg-primary/5 focus:outline-none focus-visible:ring-1 focus-visible:ring-primary last:border-b-0"
+            onClick={() => {
+              if (canSelect && q.questionId) {
+                onSelectQuestion(q.questionId)
+              }
+            }}
+            disabled={!canSelect}
+            className={`flex w-full flex-col gap-1.5 border-b border-border/50 px-3 py-2.5 text-left transition focus:outline-none focus-visible:ring-1 focus-visible:ring-primary last:border-b-0 ${
+              isActive ? "bg-primary/10" : "hover:bg-primary/5"
+            } ${!canSelect ? "cursor-default" : ""}`}
           >
             <div className="flex items-center justify-between">
               <div className="flex items-center gap-2">
@@ -134,7 +164,8 @@ export function PointsPanel({ questions: questionsProp }: PointsPanelProps) {
               </div>
             )}
           </button>
-        ))}
+          )
+        })}
       </div>
 
       {/* Summary footer */}
@@ -151,6 +182,19 @@ export function PointsPanel({ questions: questionsProp }: PointsPanelProps) {
         </div>
         <span className="text-xs font-bold text-primary">+85 XP bonus</span>
       </div>
+
+      {actionLabel && onAction && (
+        <div className="border-t border-border px-3 py-3">
+          <button
+            type="button"
+            onClick={onAction}
+            disabled={actionDisabled || actionLoading}
+            className="w-full rounded-sm border border-primary bg-primary px-3 py-2 text-xs font-bold uppercase tracking-widest text-primary-foreground transition hover:bg-primary/90 disabled:opacity-60"
+          >
+            {actionLoading ? "Submitting..." : actionLabel}
+          </button>
+        </div>
+      )}
     </div>
   )
 }
diff --git a/components/arena/users-panel.tsx b/components/arena/users-panel.tsx
index 54c71ed..0439362 100644
--- a/components/arena/users-panel.tsx
+++ b/components/arena/users-panel.tsx
@@ -106,11 +106,12 @@ export function UsersPanel({ users: usersProp }: UsersPanelProps) {
               </div>
 
               {/* Info */}
-              <div className="flex flex-1 flex-col">
+              <div className="flex min-w-0 flex-1 flex-col">
                 <span
                   className={`text-xs font-bold ${
                     user.id === "1" ? "text-primary" : "text-foreground"
-                  }`}
+                  } truncate`}
+                  title={user.name}
                 >
                   {user.name}
                 </span>
@@ -119,13 +120,15 @@ export function UsersPanel({ users: usersProp }: UsersPanelProps) {
                 </span>
               </div>
 
-              {/* Status */}
-              <div className="flex items-center gap-1.5">
-                <div className={`h-1.5 w-1.5 rounded-full ${sc.dotClass}`} />
-                <span className="text-xs text-muted-foreground">{sc.label}</span>
-              </div>
-              <div className="ml-2 text-xs text-muted-foreground">
-                {user.solved}/{user.total}
+              <div className="flex flex-shrink-0 items-center gap-3">
+                {/* Status */}
+                <div className="flex items-center gap-1.5">
+                  <div className={`h-1.5 w-1.5 rounded-full ${sc.dotClass}`} />
+                  <span className="text-xs text-muted-foreground">{sc.label}</span>
+                </div>
+                <div className="text-xs text-muted-foreground">
+                  {user.solved}/{user.total}
+                </div>
               </div>
             </div>
           )
diff --git a/lib/piston.ts b/lib/piston.ts
index ac235d3..83e0261 100644
--- a/lib/piston.ts
+++ b/lib/piston.ts
@@ -3,7 +3,15 @@
 // ============================================================
 // Runs user code against the Piston API (self-hosted or public).
 
-const PISTON_URL = process.env.PISTON_URL || "https://emkc.org/api/v2/piston";
+const rawBase =
+  process.env.PISTON_BASE ||
+  process.env.PISTON_URL ||
+  "https://emkc.org";
+
+const normalizedBase = rawBase.replace(/\/+$/, "");
+const PISTON_BASE = normalizedBase.includes("/api/v2")
+  ? normalizedBase
+  : `${normalizedBase}/api/v2`;
 
 // Language → Piston runtime mapping
 const LANGUAGE_MAP: Record<string, { language: string; version: string }> = {
@@ -53,7 +61,7 @@ export async function runCode(
     );
   }
 
-  const response = await fetch(`${PISTON_URL}/api/v2/execute`, {
+  const response = await fetch(`${PISTON_BASE}/execute`, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
     body: JSON.stringify({
@@ -80,7 +88,7 @@ export async function runCode(
 export async function getRuntimes(): Promise<
   Array<{ language: string; version: string; aliases: string[] }>
 > {
-  const response = await fetch(`${PISTON_URL}/api/v2/runtimes`);
+  const response = await fetch(`${PISTON_BASE}/runtimes`);
   if (!response.ok) {
     throw new Error(`Failed to fetch runtimes: ${response.status}`);
   }
diff --git a/pages/api/socket.ts b/pages/api/socket.ts
index 3249445..6ed3e59 100644
--- a/pages/api/socket.ts
+++ b/pages/api/socket.ts
@@ -28,6 +28,10 @@ export default function handler(
 
     io.on("connection", (socket) => {
       socket.emit("lobby:connected", { id: socket.id })
+
+      socket.on("arena:code", (payload) => {
+        io.emit("arena:code", payload)
+      })
     })
   } else if (res.socket.server.io) {
     setSocketServer(res.socket.server.io)

From cf55b61ea970c5ce339f82a2ec621180b9b7e589 Mon Sep 17 00:00:00 2001
From: "Sree Raj Muthaiya.A.L" <passiveuser369@gmail.com>
Date: Tue, 10 Feb 2026 14:22:50 +0530
Subject: [PATCH 8/9] checking submissions

---
 app/api/match/[matchId]/evaluate/route.ts    |  12 +-
 app/api/match/[matchId]/route.ts             |  13 +-
 app/api/match/[matchId]/submit/route.ts      |  71 ++-
 app/arena/page.tsx                           |  58 ++-
 prisma/generated/prisma/internal/class.ts    |   4 +-
 prisma/generated/prisma/models/Question.ts   | 138 ------
 prisma/generated/prisma/models/Submission.ts | 468 +------------------
 prisma/generated/prisma/models/User.ts       | 162 -------
 prisma/schema.prisma                         |   6 +-
 9 files changed, 156 insertions(+), 776 deletions(-)

diff --git a/app/api/match/[matchId]/evaluate/route.ts b/app/api/match/[matchId]/evaluate/route.ts
index 431ea7a..f4b3ef7 100644
--- a/app/api/match/[matchId]/evaluate/route.ts
+++ b/app/api/match/[matchId]/evaluate/route.ts
@@ -51,15 +51,18 @@ export async function POST(
     const roundSubmissions = {
       roundId: matchId,
       questions: match.questions.map((mq) => ({
-        id: mq.question.id,
+        id: mq.question.title,
         title: mq.question.title,
         description: mq.question.description,
         difficulty: mq.question.difficulty.toLowerCase() as "easy" | "medium" | "hard",
       })),
       submissions: match.players.map((player) => ({
-        userId: player.userId,
+        userId: player.user.displayName || player.user.username,
         responses: match.submissions
-          .filter((s) => s.userId === player.userId)
+          .filter(
+            (s) =>
+              s.userId === (player.user.displayName || player.user.username),
+          )
           .map((s) => ({
             questionId: s.questionId,
             code: s.code,
@@ -72,8 +75,9 @@ export async function POST(
     // For now, compute rankings based on test case results
     // The full Backboard LLM pipeline can be triggered async
     const playerScores = match.players.map((player) => {
+      const playerName = player.user.displayName || player.user.username;
       const playerSubmissions = match.submissions.filter(
-        (s) => s.userId === player.userId
+        (s) => s.userId === playerName
       );
 
       // Calculate average test pass rate
diff --git a/app/api/match/[matchId]/route.ts b/app/api/match/[matchId]/route.ts
index 2a3ae51..0c8beb9 100644
--- a/app/api/match/[matchId]/route.ts
+++ b/app/api/match/[matchId]/route.ts
@@ -19,6 +19,12 @@ export async function GET(
   const { matchId } = await params;
 
   try {
+    const viewer = await prisma.user.findUnique({
+      where: { id: payload.userId },
+      select: { username: true, displayName: true },
+    });
+    const viewerName = viewer?.displayName || viewer?.username || payload.username;
+
     const match = await prisma.match.findUnique({
       where: { id: matchId },
       include: {
@@ -40,7 +46,7 @@ export async function GET(
           orderBy: { order: "asc" },
         },
         submissions: {
-          where: { userId: payload.userId },
+          where: { userId: viewerName },
           select: {
             id: true,
             questionId: true,
@@ -59,7 +65,10 @@ export async function GET(
 
     // Verify user is a player in this match
     const isPlayer = match.players.some(
-      (p) => p.userId === payload.userId
+      (p) =>
+        p.userId === payload.userId ||
+        p.user.username === payload.username ||
+        p.user.displayName === payload.username,
     );
     if (!isPlayer) {
       return NextResponse.json(
diff --git a/app/api/match/[matchId]/submit/route.ts b/app/api/match/[matchId]/submit/route.ts
index 2f52cc3..2db9721 100644
--- a/app/api/match/[matchId]/submit/route.ts
+++ b/app/api/match/[matchId]/submit/route.ts
@@ -33,7 +33,17 @@ export async function POST(
     const match = await prisma.match.findUnique({
       where: { id: matchId },
       include: {
-        players: true,
+        players: {
+          include: {
+            user: {
+              select: {
+                id: true,
+                username: true,
+                displayName: true,
+              },
+            },
+          },
+        },
         questions: { include: { question: true } },
       },
     });
@@ -50,7 +60,12 @@ export async function POST(
     }
 
     // Verify user is a player
-    const isPlayer = match.players.some((p) => p.userId === payload.userId);
+    const isPlayer = match.players.some(
+      (p) =>
+        p.userId === payload.userId ||
+        p.user.username === payload.username ||
+        p.user.displayName === payload.username,
+    );
     if (!isPlayer) {
       return NextResponse.json(
         { error: "You are not a player in this match" },
@@ -69,18 +84,66 @@ export async function POST(
       );
     }
 
+    const user = await prisma.user.findUnique({
+      where: { id: payload.userId },
+      select: { username: true, displayName: true },
+    });
+    const userName = user?.displayName || user?.username || payload.username;
+
     // Save submission (no execution required)
     const submission = await prisma.submission.create({
       data: {
         matchId,
-        userId: payload.userId,
-        questionId,
+        userId: userName,
+        questionId: matchQuestion.question.title,
         code,
         language,
         charCount: code.length,
       },
     });
 
+    const questionTitles = match.questions.map((mq) => mq.question.title);
+    const questionTitleSet = new Set(questionTitles);
+    const playerNames = match.players.map(
+      (player) => player.user.displayName || player.user.username,
+    );
+
+    if (playerNames.length > 0 && questionTitles.length > 0) {
+      const submissions = await prisma.submission.findMany({
+        where: {
+          matchId,
+          userId: { in: playerNames },
+        },
+        select: {
+          userId: true,
+          questionId: true,
+        },
+      });
+
+      const progress = new Map<string, Set<string>>();
+      for (const entry of submissions) {
+        if (!questionTitleSet.has(entry.questionId)) continue;
+        if (!progress.has(entry.userId)) {
+          progress.set(entry.userId, new Set());
+        }
+        progress.get(entry.userId)?.add(entry.questionId);
+      }
+
+      const allCompleted = playerNames.every(
+        (name) => (progress.get(name)?.size ?? 0) >= questionTitles.length,
+      );
+
+      if (allCompleted) {
+        await prisma.match.update({
+          where: { id: matchId },
+          data: {
+            status: "COMPLETED",
+            endedAt: new Date(),
+          },
+        });
+      }
+    }
+
     return NextResponse.json({
       submission: {
         id: submission.id,
diff --git a/app/arena/page.tsx b/app/arena/page.tsx
index 4cdc52d..8bcbf8c 100644
--- a/app/arena/page.tsx
+++ b/app/arena/page.tsx
@@ -188,16 +188,20 @@ export default function ArenaPage() {
   const submissionStatus = useMemo(() => {
     const attempted = new Set<string>()
     const solved = new Set<string>()
-    if (match?.submissions) {
+    if (match?.submissions && match?.questions) {
+      const titleToId = new Map(
+        match.questions.map((q) => [q.question.title, q.questionId]),
+      )
       match.submissions.forEach((s) => {
-        attempted.add(s.questionId)
+        const key = titleToId.get(s.questionId) ?? s.questionId
+        attempted.add(key)
         if (s.testsTotal > 0 && s.testsPassed === s.testsTotal) {
-          solved.add(s.questionId)
+          solved.add(key)
         }
       })
     }
     return { attempted, solved }
-  }, [match?.submissions])
+  }, [match?.questions, match?.submissions])
 
   const totalQuestions = match?.questions?.length ?? 0
   const solvedCount = useMemo(() => {
@@ -425,16 +429,42 @@ export default function ArenaPage() {
               setSubmitAllError(null)
               setIsSubmittingAll(true)
               try {
-                if (
-                  typeof window !== "undefined" &&
-                  activeQuestionId &&
-                  activeQuestion?.title
-                ) {
-                  window.localStorage.setItem(
-                    activeQuestion.title,
-                    codeForBroadcast,
+                let codeCache: Record<string, string> = {}
+                let userName = ""
+                if (typeof window !== "undefined") {
+                  if (activeQuestionId && activeQuestion?.title) {
+                    window.localStorage.setItem(
+                      activeQuestion.title,
+                      codeForBroadcast,
+                    )
+                  }
+
+                  codeCache = (match.questions || []).reduce(
+                    (acc, item) => {
+                      const title = item.question.title
+                      acc[title] = window.localStorage.getItem(title) ?? ""
+                      return acc
+                    },
+                    {} as Record<string, string>,
+                  )
+
+                  const currentPlayer = match.players.find(
+                    (player) => player.userId === currentUserId,
                   )
+                  userName =
+                    currentPlayer?.user.displayName ||
+                    currentPlayer?.user.username ||
+                    ""
+
+                  window.localStorage.clear()
+                  if (currentUserId) {
+                    window.localStorage.setItem("cnc.userId", currentUserId)
+                  }
+                  if (userName) {
+                    window.localStorage.setItem("cnc.userName", userName)
+                  }
                 }
+
                 const ordered = [...match.questions].sort(
                   (a, b) => a.order - b.order,
                 )
@@ -463,9 +493,7 @@ export default function ArenaPage() {
                 for (const item of ordered) {
                   const title = item.question.title
                   const code =
-                    typeof window !== "undefined"
-                      ? window.localStorage.getItem(title) ?? ""
-                      : ""
+                    typeof window !== "undefined" ? codeCache[title] ?? "" : ""
                   const finalCode =
                     code.trim().length > 0
                       ? code
diff --git a/prisma/generated/prisma/internal/class.ts b/prisma/generated/prisma/internal/class.ts
index de3bda1..17148dc 100644
--- a/prisma/generated/prisma/internal/class.ts
+++ b/prisma/generated/prisma/internal/class.ts
@@ -20,7 +20,7 @@ const config: runtime.GetPrismaClientConfig = {
   "clientVersion": "7.3.0",
   "engineVersion": "9d6ad21cbbceab97458517b147a6a09ff43aa735",
   "activeProvider": "postgresql",
-  "inlineSchema": "// ============================================================\n// Compile-n-Conquer — Prisma Schema\n// ============================================================\n\ngenerator client {\n  provider = \"prisma-client\"\n  output   = \"./generated/prisma\"\n}\n\ndatasource db {\n  provider = \"postgresql\"\n}\n\n// ---- Users ----\n\nmodel User {\n  id           String    @id @default(cuid())\n  username     String    @unique\n  email        String    @unique\n  passwordHash String\n  displayName  String?\n  avatarUrl    String?\n  title        String    @default(\"Code Warrior\")\n  skillTier    SkillTier @default(BEGINNER)\n  elo          Int       @default(1000)\n  totalWins    Int       @default(0)\n  totalMatches Int       @default(0)\n  totalXP      Int       @default(0)\n  streak       Int       @default(0)\n  createdAt    DateTime  @default(now())\n  updatedAt    DateTime  @updatedAt\n\n  // Relations\n  submissions  Submission[]\n  matchPlayers MatchPlayer[]\n  queueEntries QueueEntry[]\n\n  @@map(\"users\")\n}\n\nenum SkillTier {\n  BEGINNER\n  INTERMEDIATE\n  ADVANCED\n  PRO\n}\n\n// ---- Matchmaking Queue ----\n\nmodel QueueEntry {\n  id       String   @id @default(cuid())\n  userId   String\n  joinedAt DateTime @default(now())\n  active   Boolean  @default(true)\n\n  user User @relation(fields: [userId], references: [id], onDelete: Cascade)\n\n  @@unique([userId, active])\n  @@map(\"queue_entries\")\n}\n\n// ---- Matches ----\n\nmodel Match {\n  id         String      @id @default(cuid())\n  maxPlayers Int         @default(3)\n  status     MatchStatus @default(WAITING)\n  mode       GameMode    @default(FASTEST)\n  startedAt  DateTime?\n  endedAt    DateTime?\n  createdAt  DateTime    @default(now())\n\n  // Backboard thread IDs for evaluation\n  threadTimeComplexity  String?\n  threadSpaceComplexity String?\n  threadOriginality     String?\n  threadRanking         String?\n\n  // Relations\n  players     MatchPlayer[]\n  questions   MatchQuestion[]\n  submissions Submission[]\n\n  @@map(\"matches\")\n}\n\nenum MatchStatus {\n  WAITING // Waiting for all players to connect\n  IN_PROGRESS // Match is live\n  EVALUATING // Code submitted, LLM evaluation running\n  COMPLETED // Results are in\n  CANCELLED\n}\n\nenum GameMode {\n  FASTEST // First to pass all test cases\n  SHORTEST // Shortest code (by chars) that passes\n  REVERSE // Given output, write the code that produces it\n  DEBUGGING // Fix broken code\n}\n\nenum MatchOutcome {\n  WIN\n  LOSS\n  DRAW\n}\n\nmodel MatchPlayer {\n  id       String        @id @default(cuid())\n  matchId  String\n  userId   String\n  rank     Int? // Final rank after evaluation\n  score    Float? // Final weighted score\n  result   MatchOutcome?\n  xpDelta  Int           @default(0)\n  joinedAt DateTime      @default(now())\n\n  match Match @relation(fields: [matchId], references: [id], onDelete: Cascade)\n  user  User  @relation(fields: [userId], references: [id], onDelete: Cascade)\n\n  @@unique([matchId, userId])\n  @@map(\"match_players\")\n}\n\n// ---- Questions ----\n\nmodel Question {\n  id          String     @id @default(cuid())\n  title       String\n  description String\n  difficulty  Difficulty @default(MEDIUM)\n  mode        GameMode   @default(FASTEST)\n\n  // For DEBUGGING mode: the broken code to fix\n  brokenCode     String?\n  brokenLanguage String?\n\n  // For REVERSE mode: expected output\n  expectedOutput String?\n\n  // Test cases stored as JSON\n  testCases Json? // [{ input: string, expectedOutput: string }]\n\n  createdAt DateTime @default(now())\n  updatedAt DateTime @updatedAt\n\n  // Relations\n  matchQuestions MatchQuestion[]\n  submissions    Submission[]\n\n  @@map(\"questions\")\n}\n\nenum Difficulty {\n  EASY\n  MEDIUM\n  HARD\n}\n\nmodel MatchQuestion {\n  id         String @id @default(cuid())\n  matchId    String\n  questionId String\n  order      Int    @default(0) // Question order in the match\n\n  match    Match    @relation(fields: [matchId], references: [id], onDelete: Cascade)\n  question Question @relation(fields: [questionId], references: [id], onDelete: Cascade)\n\n  @@unique([matchId, questionId])\n  @@map(\"match_questions\")\n}\n\n// ---- Submissions ----\n\nmodel Submission {\n  id         String @id @default(cuid())\n  matchId    String\n  userId     String\n  questionId String\n  code       String\n  language   String\n  charCount  Int? // For SHORTEST mode\n\n  // Piston execution results\n  stdout      String?\n  stderr      String?\n  exitCode    Int?\n  execTimeMs  Int?\n  testsPassed Int     @default(0)\n  testsTotal  Int     @default(0)\n\n  // LLM evaluation scores\n  timeComplexity   String? // e.g. \"O(n)\"\n  timeScore        Float?\n  spaceComplexity  String?\n  spaceScore       Float?\n  originalityScore Float?\n  relevanceScore   Float?\n\n  submittedAt DateTime @default(now())\n\n  match    Match    @relation(fields: [matchId], references: [id], onDelete: Cascade)\n  user     User     @relation(fields: [userId], references: [id], onDelete: Cascade)\n  question Question @relation(fields: [questionId], references: [id], onDelete: Cascade)\n\n  @@map(\"submissions\")\n}\n",
+  "inlineSchema": "// ============================================================\n// Compile-n-Conquer — Prisma Schema\n// ============================================================\n\ngenerator client {\n  provider = \"prisma-client\"\n  output   = \"./generated/prisma\"\n}\n\ndatasource db {\n  provider = \"postgresql\"\n}\n\n// ---- Users ----\n\nmodel User {\n  id           String    @id @default(cuid())\n  username     String    @unique\n  email        String    @unique\n  passwordHash String\n  displayName  String?\n  avatarUrl    String?\n  title        String    @default(\"Code Warrior\")\n  skillTier    SkillTier @default(BEGINNER)\n  elo          Int       @default(1000)\n  totalWins    Int       @default(0)\n  totalMatches Int       @default(0)\n  totalXP      Int       @default(0)\n  streak       Int       @default(0)\n  createdAt    DateTime  @default(now())\n  updatedAt    DateTime  @updatedAt\n\n  // Relations\n  matchPlayers MatchPlayer[]\n  queueEntries QueueEntry[]\n\n  @@map(\"users\")\n}\n\nenum SkillTier {\n  BEGINNER\n  INTERMEDIATE\n  ADVANCED\n  PRO\n}\n\n// ---- Matchmaking Queue ----\n\nmodel QueueEntry {\n  id       String   @id @default(cuid())\n  userId   String\n  joinedAt DateTime @default(now())\n  active   Boolean  @default(true)\n\n  user User @relation(fields: [userId], references: [id], onDelete: Cascade)\n\n  @@unique([userId, active])\n  @@map(\"queue_entries\")\n}\n\n// ---- Matches ----\n\nmodel Match {\n  id         String      @id @default(cuid())\n  maxPlayers Int         @default(3)\n  status     MatchStatus @default(WAITING)\n  mode       GameMode    @default(FASTEST)\n  startedAt  DateTime?\n  endedAt    DateTime?\n  createdAt  DateTime    @default(now())\n\n  // Backboard thread IDs for evaluation\n  threadTimeComplexity  String?\n  threadSpaceComplexity String?\n  threadOriginality     String?\n  threadRanking         String?\n\n  // Relations\n  players     MatchPlayer[]\n  questions   MatchQuestion[]\n  submissions Submission[]\n\n  @@map(\"matches\")\n}\n\nenum MatchStatus {\n  WAITING // Waiting for all players to connect\n  IN_PROGRESS // Match is live\n  EVALUATING // Code submitted, LLM evaluation running\n  COMPLETED // Results are in\n  CANCELLED\n}\n\nenum GameMode {\n  FASTEST // First to pass all test cases\n  SHORTEST // Shortest code (by chars) that passes\n  REVERSE // Given output, write the code that produces it\n  DEBUGGING // Fix broken code\n}\n\nenum MatchOutcome {\n  WIN\n  LOSS\n  DRAW\n}\n\nmodel MatchPlayer {\n  id       String        @id @default(cuid())\n  matchId  String\n  userId   String\n  rank     Int? // Final rank after evaluation\n  score    Float? // Final weighted score\n  result   MatchOutcome?\n  xpDelta  Int           @default(0)\n  joinedAt DateTime      @default(now())\n\n  match Match @relation(fields: [matchId], references: [id], onDelete: Cascade)\n  user  User  @relation(fields: [userId], references: [id], onDelete: Cascade)\n\n  @@unique([matchId, userId])\n  @@map(\"match_players\")\n}\n\n// ---- Questions ----\n\nmodel Question {\n  id          String     @id @default(cuid())\n  title       String\n  description String\n  difficulty  Difficulty @default(MEDIUM)\n  mode        GameMode   @default(FASTEST)\n\n  // For DEBUGGING mode: the broken code to fix\n  brokenCode     String?\n  brokenLanguage String?\n\n  // For REVERSE mode: expected output\n  expectedOutput String?\n\n  // Test cases stored as JSON\n  testCases Json? // [{ input: string, expectedOutput: string }]\n\n  createdAt DateTime @default(now())\n  updatedAt DateTime @updatedAt\n\n  // Relations\n  matchQuestions MatchQuestion[]\n\n  @@map(\"questions\")\n}\n\nenum Difficulty {\n  EASY\n  MEDIUM\n  HARD\n}\n\nmodel MatchQuestion {\n  id         String @id @default(cuid())\n  matchId    String\n  questionId String\n  order      Int    @default(0) // Question order in the match\n\n  match    Match    @relation(fields: [matchId], references: [id], onDelete: Cascade)\n  question Question @relation(fields: [questionId], references: [id], onDelete: Cascade)\n\n  @@unique([matchId, questionId])\n  @@map(\"match_questions\")\n}\n\n// ---- Submissions ----\n\nmodel Submission {\n  id         String @id @default(cuid())\n  matchId    String\n  userId     String\n  questionId String\n  code       String\n  language   String\n  charCount  Int? // For SHORTEST mode\n\n  // Piston execution results\n  stdout      String?\n  stderr      String?\n  exitCode    Int?\n  execTimeMs  Int?\n  testsPassed Int     @default(0)\n  testsTotal  Int     @default(0)\n\n  // LLM evaluation scores\n  timeComplexity   String? // e.g. \"O(n)\"\n  timeScore        Float?\n  spaceComplexity  String?\n  spaceScore       Float?\n  originalityScore Float?\n  relevanceScore   Float?\n\n  submittedAt DateTime @default(now())\n\n  match Match @relation(fields: [matchId], references: [id], onDelete: Cascade)\n\n  @@map(\"submissions\")\n}\n",
   "runtimeDataModel": {
     "models": {},
     "enums": {},
@@ -28,7 +28,7 @@ const config: runtime.GetPrismaClientConfig = {
   }
 }
 
-config.runtimeDataModel = JSON.parse("{\"models\":{\"User\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"username\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"email\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"passwordHash\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"displayName\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"avatarUrl\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"title\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"skillTier\",\"kind\":\"enum\",\"type\":\"SkillTier\"},{\"name\":\"elo\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"totalWins\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"totalMatches\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"totalXP\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"streak\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"createdAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"updatedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"submissions\",\"kind\":\"object\",\"type\":\"Submission\",\"relationName\":\"SubmissionToUser\"},{\"name\":\"matchPlayers\",\"kind\":\"object\",\"type\":\"MatchPlayer\",\"relationName\":\"MatchPlayerToUser\"},{\"name\":\"queueEntries\",\"kind\":\"object\",\"type\":\"QueueEntry\",\"relationName\":\"QueueEntryToUser\"}],\"dbName\":\"users\"},\"QueueEntry\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"userId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"joinedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"active\",\"kind\":\"scalar\",\"type\":\"Boolean\"},{\"name\":\"user\",\"kind\":\"object\",\"type\":\"User\",\"relationName\":\"QueueEntryToUser\"}],\"dbName\":\"queue_entries\"},\"Match\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"maxPlayers\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"status\",\"kind\":\"enum\",\"type\":\"MatchStatus\"},{\"name\":\"mode\",\"kind\":\"enum\",\"type\":\"GameMode\"},{\"name\":\"startedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"endedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"createdAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"threadTimeComplexity\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"threadSpaceComplexity\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"threadOriginality\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"threadRanking\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"players\",\"kind\":\"object\",\"type\":\"MatchPlayer\",\"relationName\":\"MatchToMatchPlayer\"},{\"name\":\"questions\",\"kind\":\"object\",\"type\":\"MatchQuestion\",\"relationName\":\"MatchToMatchQuestion\"},{\"name\":\"submissions\",\"kind\":\"object\",\"type\":\"Submission\",\"relationName\":\"MatchToSubmission\"}],\"dbName\":\"matches\"},\"MatchPlayer\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"matchId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"userId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"rank\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"score\",\"kind\":\"scalar\",\"type\":\"Float\"},{\"name\":\"result\",\"kind\":\"enum\",\"type\":\"MatchOutcome\"},{\"name\":\"xpDelta\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"joinedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"match\",\"kind\":\"object\",\"type\":\"Match\",\"relationName\":\"MatchToMatchPlayer\"},{\"name\":\"user\",\"kind\":\"object\",\"type\":\"User\",\"relationName\":\"MatchPlayerToUser\"}],\"dbName\":\"match_players\"},\"Question\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"title\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"description\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"difficulty\",\"kind\":\"enum\",\"type\":\"Difficulty\"},{\"name\":\"mode\",\"kind\":\"enum\",\"type\":\"GameMode\"},{\"name\":\"brokenCode\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"brokenLanguage\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"expectedOutput\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"testCases\",\"kind\":\"scalar\",\"type\":\"Json\"},{\"name\":\"createdAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"updatedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"matchQuestions\",\"kind\":\"object\",\"type\":\"MatchQuestion\",\"relationName\":\"MatchQuestionToQuestion\"},{\"name\":\"submissions\",\"kind\":\"object\",\"type\":\"Submission\",\"relationName\":\"QuestionToSubmission\"}],\"dbName\":\"questions\"},\"MatchQuestion\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"matchId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"questionId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"order\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"match\",\"kind\":\"object\",\"type\":\"Match\",\"relationName\":\"MatchToMatchQuestion\"},{\"name\":\"question\",\"kind\":\"object\",\"type\":\"Question\",\"relationName\":\"MatchQuestionToQuestion\"}],\"dbName\":\"match_questions\"},\"Submission\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"matchId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"userId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"questionId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"code\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"language\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"charCount\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"stdout\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"stderr\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"exitCode\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"execTimeMs\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"testsPassed\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"testsTotal\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"timeComplexity\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"timeScore\",\"kind\":\"scalar\",\"type\":\"Float\"},{\"name\":\"spaceComplexity\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"spaceScore\",\"kind\":\"scalar\",\"type\":\"Float\"},{\"name\":\"originalityScore\",\"kind\":\"scalar\",\"type\":\"Float\"},{\"name\":\"relevanceScore\",\"kind\":\"scalar\",\"type\":\"Float\"},{\"name\":\"submittedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"match\",\"kind\":\"object\",\"type\":\"Match\",\"relationName\":\"MatchToSubmission\"},{\"name\":\"user\",\"kind\":\"object\",\"type\":\"User\",\"relationName\":\"SubmissionToUser\"},{\"name\":\"question\",\"kind\":\"object\",\"type\":\"Question\",\"relationName\":\"QuestionToSubmission\"}],\"dbName\":\"submissions\"}},\"enums\":{},\"types\":{}}")
+config.runtimeDataModel = JSON.parse("{\"models\":{\"User\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"username\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"email\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"passwordHash\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"displayName\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"avatarUrl\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"title\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"skillTier\",\"kind\":\"enum\",\"type\":\"SkillTier\"},{\"name\":\"elo\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"totalWins\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"totalMatches\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"totalXP\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"streak\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"createdAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"updatedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"matchPlayers\",\"kind\":\"object\",\"type\":\"MatchPlayer\",\"relationName\":\"MatchPlayerToUser\"},{\"name\":\"queueEntries\",\"kind\":\"object\",\"type\":\"QueueEntry\",\"relationName\":\"QueueEntryToUser\"}],\"dbName\":\"users\"},\"QueueEntry\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"userId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"joinedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"active\",\"kind\":\"scalar\",\"type\":\"Boolean\"},{\"name\":\"user\",\"kind\":\"object\",\"type\":\"User\",\"relationName\":\"QueueEntryToUser\"}],\"dbName\":\"queue_entries\"},\"Match\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"maxPlayers\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"status\",\"kind\":\"enum\",\"type\":\"MatchStatus\"},{\"name\":\"mode\",\"kind\":\"enum\",\"type\":\"GameMode\"},{\"name\":\"startedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"endedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"createdAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"threadTimeComplexity\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"threadSpaceComplexity\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"threadOriginality\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"threadRanking\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"players\",\"kind\":\"object\",\"type\":\"MatchPlayer\",\"relationName\":\"MatchToMatchPlayer\"},{\"name\":\"questions\",\"kind\":\"object\",\"type\":\"MatchQuestion\",\"relationName\":\"MatchToMatchQuestion\"},{\"name\":\"submissions\",\"kind\":\"object\",\"type\":\"Submission\",\"relationName\":\"MatchToSubmission\"}],\"dbName\":\"matches\"},\"MatchPlayer\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"matchId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"userId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"rank\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"score\",\"kind\":\"scalar\",\"type\":\"Float\"},{\"name\":\"result\",\"kind\":\"enum\",\"type\":\"MatchOutcome\"},{\"name\":\"xpDelta\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"joinedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"match\",\"kind\":\"object\",\"type\":\"Match\",\"relationName\":\"MatchToMatchPlayer\"},{\"name\":\"user\",\"kind\":\"object\",\"type\":\"User\",\"relationName\":\"MatchPlayerToUser\"}],\"dbName\":\"match_players\"},\"Question\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"title\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"description\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"difficulty\",\"kind\":\"enum\",\"type\":\"Difficulty\"},{\"name\":\"mode\",\"kind\":\"enum\",\"type\":\"GameMode\"},{\"name\":\"brokenCode\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"brokenLanguage\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"expectedOutput\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"testCases\",\"kind\":\"scalar\",\"type\":\"Json\"},{\"name\":\"createdAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"updatedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"matchQuestions\",\"kind\":\"object\",\"type\":\"MatchQuestion\",\"relationName\":\"MatchQuestionToQuestion\"}],\"dbName\":\"questions\"},\"MatchQuestion\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"matchId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"questionId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"order\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"match\",\"kind\":\"object\",\"type\":\"Match\",\"relationName\":\"MatchToMatchQuestion\"},{\"name\":\"question\",\"kind\":\"object\",\"type\":\"Question\",\"relationName\":\"MatchQuestionToQuestion\"}],\"dbName\":\"match_questions\"},\"Submission\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"matchId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"userId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"questionId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"code\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"language\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"charCount\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"stdout\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"stderr\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"exitCode\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"execTimeMs\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"testsPassed\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"testsTotal\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"timeComplexity\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"timeScore\",\"kind\":\"scalar\",\"type\":\"Float\"},{\"name\":\"spaceComplexity\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"spaceScore\",\"kind\":\"scalar\",\"type\":\"Float\"},{\"name\":\"originalityScore\",\"kind\":\"scalar\",\"type\":\"Float\"},{\"name\":\"relevanceScore\",\"kind\":\"scalar\",\"type\":\"Float\"},{\"name\":\"submittedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"match\",\"kind\":\"object\",\"type\":\"Match\",\"relationName\":\"MatchToSubmission\"}],\"dbName\":\"submissions\"}},\"enums\":{},\"types\":{}}")
 
 async function decodeBase64AsWasm(wasmBase64: string): Promise<WebAssembly.Module> {
   const { Buffer } = await import('node:buffer')
diff --git a/prisma/generated/prisma/models/Question.ts b/prisma/generated/prisma/models/Question.ts
index 7c6aa64..a6dea5e 100644
--- a/prisma/generated/prisma/models/Question.ts
+++ b/prisma/generated/prisma/models/Question.ts
@@ -227,7 +227,6 @@ export type QuestionWhereInput = {
   createdAt?: Prisma.DateTimeFilter<"Question"> | Date | string
   updatedAt?: Prisma.DateTimeFilter<"Question"> | Date | string
   matchQuestions?: Prisma.MatchQuestionListRelationFilter
-  submissions?: Prisma.SubmissionListRelationFilter
 }
 
 export type QuestionOrderByWithRelationInput = {
@@ -243,7 +242,6 @@ export type QuestionOrderByWithRelationInput = {
   createdAt?: Prisma.SortOrder
   updatedAt?: Prisma.SortOrder
   matchQuestions?: Prisma.MatchQuestionOrderByRelationAggregateInput
-  submissions?: Prisma.SubmissionOrderByRelationAggregateInput
 }
 
 export type QuestionWhereUniqueInput = Prisma.AtLeast<{
@@ -262,7 +260,6 @@ export type QuestionWhereUniqueInput = Prisma.AtLeast<{
   createdAt?: Prisma.DateTimeFilter<"Question"> | Date | string
   updatedAt?: Prisma.DateTimeFilter<"Question"> | Date | string
   matchQuestions?: Prisma.MatchQuestionListRelationFilter
-  submissions?: Prisma.SubmissionListRelationFilter
 }, "id">
 
 export type QuestionOrderByWithAggregationInput = {
@@ -312,7 +309,6 @@ export type QuestionCreateInput = {
   createdAt?: Date | string
   updatedAt?: Date | string
   matchQuestions?: Prisma.MatchQuestionCreateNestedManyWithoutQuestionInput
-  submissions?: Prisma.SubmissionCreateNestedManyWithoutQuestionInput
 }
 
 export type QuestionUncheckedCreateInput = {
@@ -328,7 +324,6 @@ export type QuestionUncheckedCreateInput = {
   createdAt?: Date | string
   updatedAt?: Date | string
   matchQuestions?: Prisma.MatchQuestionUncheckedCreateNestedManyWithoutQuestionInput
-  submissions?: Prisma.SubmissionUncheckedCreateNestedManyWithoutQuestionInput
 }
 
 export type QuestionUpdateInput = {
@@ -344,7 +339,6 @@ export type QuestionUpdateInput = {
   createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
   updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
   matchQuestions?: Prisma.MatchQuestionUpdateManyWithoutQuestionNestedInput
-  submissions?: Prisma.SubmissionUpdateManyWithoutQuestionNestedInput
 }
 
 export type QuestionUncheckedUpdateInput = {
@@ -360,7 +354,6 @@ export type QuestionUncheckedUpdateInput = {
   createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
   updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
   matchQuestions?: Prisma.MatchQuestionUncheckedUpdateManyWithoutQuestionNestedInput
-  submissions?: Prisma.SubmissionUncheckedUpdateManyWithoutQuestionNestedInput
 }
 
 export type QuestionCreateManyInput = {
@@ -468,20 +461,6 @@ export type QuestionUpdateOneRequiredWithoutMatchQuestionsNestedInput = {
   update?: Prisma.XOR<Prisma.XOR<Prisma.QuestionUpdateToOneWithWhereWithoutMatchQuestionsInput, Prisma.QuestionUpdateWithoutMatchQuestionsInput>, Prisma.QuestionUncheckedUpdateWithoutMatchQuestionsInput>
 }
 
-export type QuestionCreateNestedOneWithoutSubmissionsInput = {
-  create?: Prisma.XOR<Prisma.QuestionCreateWithoutSubmissionsInput, Prisma.QuestionUncheckedCreateWithoutSubmissionsInput>
-  connectOrCreate?: Prisma.QuestionCreateOrConnectWithoutSubmissionsInput
-  connect?: Prisma.QuestionWhereUniqueInput
-}
-
-export type QuestionUpdateOneRequiredWithoutSubmissionsNestedInput = {
-  create?: Prisma.XOR<Prisma.QuestionCreateWithoutSubmissionsInput, Prisma.QuestionUncheckedCreateWithoutSubmissionsInput>
-  connectOrCreate?: Prisma.QuestionCreateOrConnectWithoutSubmissionsInput
-  upsert?: Prisma.QuestionUpsertWithoutSubmissionsInput
-  connect?: Prisma.QuestionWhereUniqueInput
-  update?: Prisma.XOR<Prisma.XOR<Prisma.QuestionUpdateToOneWithWhereWithoutSubmissionsInput, Prisma.QuestionUpdateWithoutSubmissionsInput>, Prisma.QuestionUncheckedUpdateWithoutSubmissionsInput>
-}
-
 export type QuestionCreateWithoutMatchQuestionsInput = {
   id?: string
   title: string
@@ -494,7 +473,6 @@ export type QuestionCreateWithoutMatchQuestionsInput = {
   testCases?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
   createdAt?: Date | string
   updatedAt?: Date | string
-  submissions?: Prisma.SubmissionCreateNestedManyWithoutQuestionInput
 }
 
 export type QuestionUncheckedCreateWithoutMatchQuestionsInput = {
@@ -509,7 +487,6 @@ export type QuestionUncheckedCreateWithoutMatchQuestionsInput = {
   testCases?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
   createdAt?: Date | string
   updatedAt?: Date | string
-  submissions?: Prisma.SubmissionUncheckedCreateNestedManyWithoutQuestionInput
 }
 
 export type QuestionCreateOrConnectWithoutMatchQuestionsInput = {
@@ -540,7 +517,6 @@ export type QuestionUpdateWithoutMatchQuestionsInput = {
   testCases?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
   createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
   updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
-  submissions?: Prisma.SubmissionUpdateManyWithoutQuestionNestedInput
 }
 
 export type QuestionUncheckedUpdateWithoutMatchQuestionsInput = {
@@ -555,83 +531,6 @@ export type QuestionUncheckedUpdateWithoutMatchQuestionsInput = {
   testCases?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
   createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
   updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
-  submissions?: Prisma.SubmissionUncheckedUpdateManyWithoutQuestionNestedInput
-}
-
-export type QuestionCreateWithoutSubmissionsInput = {
-  id?: string
-  title: string
-  description: string
-  difficulty?: $Enums.Difficulty
-  mode?: $Enums.GameMode
-  brokenCode?: string | null
-  brokenLanguage?: string | null
-  expectedOutput?: string | null
-  testCases?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
-  createdAt?: Date | string
-  updatedAt?: Date | string
-  matchQuestions?: Prisma.MatchQuestionCreateNestedManyWithoutQuestionInput
-}
-
-export type QuestionUncheckedCreateWithoutSubmissionsInput = {
-  id?: string
-  title: string
-  description: string
-  difficulty?: $Enums.Difficulty
-  mode?: $Enums.GameMode
-  brokenCode?: string | null
-  brokenLanguage?: string | null
-  expectedOutput?: string | null
-  testCases?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
-  createdAt?: Date | string
-  updatedAt?: Date | string
-  matchQuestions?: Prisma.MatchQuestionUncheckedCreateNestedManyWithoutQuestionInput
-}
-
-export type QuestionCreateOrConnectWithoutSubmissionsInput = {
-  where: Prisma.QuestionWhereUniqueInput
-  create: Prisma.XOR<Prisma.QuestionCreateWithoutSubmissionsInput, Prisma.QuestionUncheckedCreateWithoutSubmissionsInput>
-}
-
-export type QuestionUpsertWithoutSubmissionsInput = {
-  update: Prisma.XOR<Prisma.QuestionUpdateWithoutSubmissionsInput, Prisma.QuestionUncheckedUpdateWithoutSubmissionsInput>
-  create: Prisma.XOR<Prisma.QuestionCreateWithoutSubmissionsInput, Prisma.QuestionUncheckedCreateWithoutSubmissionsInput>
-  where?: Prisma.QuestionWhereInput
-}
-
-export type QuestionUpdateToOneWithWhereWithoutSubmissionsInput = {
-  where?: Prisma.QuestionWhereInput
-  data: Prisma.XOR<Prisma.QuestionUpdateWithoutSubmissionsInput, Prisma.QuestionUncheckedUpdateWithoutSubmissionsInput>
-}
-
-export type QuestionUpdateWithoutSubmissionsInput = {
-  id?: Prisma.StringFieldUpdateOperationsInput | string
-  title?: Prisma.StringFieldUpdateOperationsInput | string
-  description?: Prisma.StringFieldUpdateOperationsInput | string
-  difficulty?: Prisma.EnumDifficultyFieldUpdateOperationsInput | $Enums.Difficulty
-  mode?: Prisma.EnumGameModeFieldUpdateOperationsInput | $Enums.GameMode
-  brokenCode?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
-  brokenLanguage?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
-  expectedOutput?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
-  testCases?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
-  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
-  updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
-  matchQuestions?: Prisma.MatchQuestionUpdateManyWithoutQuestionNestedInput
-}
-
-export type QuestionUncheckedUpdateWithoutSubmissionsInput = {
-  id?: Prisma.StringFieldUpdateOperationsInput | string
-  title?: Prisma.StringFieldUpdateOperationsInput | string
-  description?: Prisma.StringFieldUpdateOperationsInput | string
-  difficulty?: Prisma.EnumDifficultyFieldUpdateOperationsInput | $Enums.Difficulty
-  mode?: Prisma.EnumGameModeFieldUpdateOperationsInput | $Enums.GameMode
-  brokenCode?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
-  brokenLanguage?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
-  expectedOutput?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
-  testCases?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
-  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
-  updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
-  matchQuestions?: Prisma.MatchQuestionUncheckedUpdateManyWithoutQuestionNestedInput
 }
 
 
@@ -641,12 +540,10 @@ export type QuestionUncheckedUpdateWithoutSubmissionsInput = {
 
 export type QuestionCountOutputType = {
   matchQuestions: number
-  submissions: number
 }
 
 export type QuestionCountOutputTypeSelect<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
   matchQuestions?: boolean | QuestionCountOutputTypeCountMatchQuestionsArgs
-  submissions?: boolean | QuestionCountOutputTypeCountSubmissionsArgs
 }
 
 /**
@@ -666,13 +563,6 @@ export type QuestionCountOutputTypeCountMatchQuestionsArgs<ExtArgs extends runti
   where?: Prisma.MatchQuestionWhereInput
 }
 
-/**
- * QuestionCountOutputType without action
- */
-export type QuestionCountOutputTypeCountSubmissionsArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
-  where?: Prisma.SubmissionWhereInput
-}
-
 
 export type QuestionSelect<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
   id?: boolean
@@ -687,7 +577,6 @@ export type QuestionSelect<ExtArgs extends runtime.Types.Extensions.InternalArgs
   createdAt?: boolean
   updatedAt?: boolean
   matchQuestions?: boolean | Prisma.Question$matchQuestionsArgs<ExtArgs>
-  submissions?: boolean | Prisma.Question$submissionsArgs<ExtArgs>
   _count?: boolean | Prisma.QuestionCountOutputTypeDefaultArgs<ExtArgs>
 }, ExtArgs["result"]["question"]>
 
@@ -736,7 +625,6 @@ export type QuestionSelectScalar = {
 export type QuestionOmit<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetOmit<"id" | "title" | "description" | "difficulty" | "mode" | "brokenCode" | "brokenLanguage" | "expectedOutput" | "testCases" | "createdAt" | "updatedAt", ExtArgs["result"]["question"]>
 export type QuestionInclude<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
   matchQuestions?: boolean | Prisma.Question$matchQuestionsArgs<ExtArgs>
-  submissions?: boolean | Prisma.Question$submissionsArgs<ExtArgs>
   _count?: boolean | Prisma.QuestionCountOutputTypeDefaultArgs<ExtArgs>
 }
 export type QuestionIncludeCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {}
@@ -746,7 +634,6 @@ export type $QuestionPayload<ExtArgs extends runtime.Types.Extensions.InternalAr
   name: "Question"
   objects: {
     matchQuestions: Prisma.$MatchQuestionPayload<ExtArgs>[]
-    submissions: Prisma.$SubmissionPayload<ExtArgs>[]
   }
   scalars: runtime.Types.Extensions.GetPayloadResult<{
     id: string
@@ -1155,7 +1042,6 @@ readonly fields: QuestionFieldRefs;
 export interface Prisma__QuestionClient<T, Null = never, ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
   readonly [Symbol.toStringTag]: "PrismaPromise"
   matchQuestions<T extends Prisma.Question$matchQuestionsArgs<ExtArgs> = {}>(args?: Prisma.Subset<T, Prisma.Question$matchQuestionsArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$MatchQuestionPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
-  submissions<T extends Prisma.Question$submissionsArgs<ExtArgs> = {}>(args?: Prisma.Subset<T, Prisma.Question$submissionsArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$SubmissionPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
   /**
    * Attaches callbacks for the resolution and/or rejection of the Promise.
    * @param onfulfilled The callback to execute when the Promise is resolved.
@@ -1607,30 +1493,6 @@ export type Question$matchQuestionsArgs<ExtArgs extends runtime.Types.Extensions
   distinct?: Prisma.MatchQuestionScalarFieldEnum | Prisma.MatchQuestionScalarFieldEnum[]
 }
 
-/**
- * Question.submissions
- */
-export type Question$submissionsArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
-  /**
-   * Select specific fields to fetch from the Submission
-   */
-  select?: Prisma.SubmissionSelect<ExtArgs> | null
-  /**
-   * Omit specific fields from the Submission
-   */
-  omit?: Prisma.SubmissionOmit<ExtArgs> | null
-  /**
-   * Choose, which related nodes to fetch as well
-   */
-  include?: Prisma.SubmissionInclude<ExtArgs> | null
-  where?: Prisma.SubmissionWhereInput
-  orderBy?: Prisma.SubmissionOrderByWithRelationInput | Prisma.SubmissionOrderByWithRelationInput[]
-  cursor?: Prisma.SubmissionWhereUniqueInput
-  take?: number
-  skip?: number
-  distinct?: Prisma.SubmissionScalarFieldEnum | Prisma.SubmissionScalarFieldEnum[]
-}
-
 /**
  * Question without action
  */
diff --git a/prisma/generated/prisma/models/Submission.ts b/prisma/generated/prisma/models/Submission.ts
index 2bfefde..a01ba9f 100644
--- a/prisma/generated/prisma/models/Submission.ts
+++ b/prisma/generated/prisma/models/Submission.ts
@@ -369,8 +369,6 @@ export type SubmissionWhereInput = {
   relevanceScore?: Prisma.FloatNullableFilter<"Submission"> | number | null
   submittedAt?: Prisma.DateTimeFilter<"Submission"> | Date | string
   match?: Prisma.XOR<Prisma.MatchScalarRelationFilter, Prisma.MatchWhereInput>
-  user?: Prisma.XOR<Prisma.UserScalarRelationFilter, Prisma.UserWhereInput>
-  question?: Prisma.XOR<Prisma.QuestionScalarRelationFilter, Prisma.QuestionWhereInput>
 }
 
 export type SubmissionOrderByWithRelationInput = {
@@ -395,8 +393,6 @@ export type SubmissionOrderByWithRelationInput = {
   relevanceScore?: Prisma.SortOrderInput | Prisma.SortOrder
   submittedAt?: Prisma.SortOrder
   match?: Prisma.MatchOrderByWithRelationInput
-  user?: Prisma.UserOrderByWithRelationInput
-  question?: Prisma.QuestionOrderByWithRelationInput
 }
 
 export type SubmissionWhereUniqueInput = Prisma.AtLeast<{
@@ -424,8 +420,6 @@ export type SubmissionWhereUniqueInput = Prisma.AtLeast<{
   relevanceScore?: Prisma.FloatNullableFilter<"Submission"> | number | null
   submittedAt?: Prisma.DateTimeFilter<"Submission"> | Date | string
   match?: Prisma.XOR<Prisma.MatchScalarRelationFilter, Prisma.MatchWhereInput>
-  user?: Prisma.XOR<Prisma.UserScalarRelationFilter, Prisma.UserWhereInput>
-  question?: Prisma.XOR<Prisma.QuestionScalarRelationFilter, Prisma.QuestionWhereInput>
 }, "id">
 
 export type SubmissionOrderByWithAggregationInput = {
@@ -484,6 +478,8 @@ export type SubmissionScalarWhereWithAggregatesInput = {
 
 export type SubmissionCreateInput = {
   id?: string
+  userId: string
+  questionId: string
   code: string
   language: string
   charCount?: number | null
@@ -501,8 +497,6 @@ export type SubmissionCreateInput = {
   relevanceScore?: number | null
   submittedAt?: Date | string
   match: Prisma.MatchCreateNestedOneWithoutSubmissionsInput
-  user: Prisma.UserCreateNestedOneWithoutSubmissionsInput
-  question: Prisma.QuestionCreateNestedOneWithoutSubmissionsInput
 }
 
 export type SubmissionUncheckedCreateInput = {
@@ -530,6 +524,8 @@ export type SubmissionUncheckedCreateInput = {
 
 export type SubmissionUpdateInput = {
   id?: Prisma.StringFieldUpdateOperationsInput | string
+  userId?: Prisma.StringFieldUpdateOperationsInput | string
+  questionId?: Prisma.StringFieldUpdateOperationsInput | string
   code?: Prisma.StringFieldUpdateOperationsInput | string
   language?: Prisma.StringFieldUpdateOperationsInput | string
   charCount?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
@@ -547,8 +543,6 @@ export type SubmissionUpdateInput = {
   relevanceScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
   submittedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
   match?: Prisma.MatchUpdateOneRequiredWithoutSubmissionsNestedInput
-  user?: Prisma.UserUpdateOneRequiredWithoutSubmissionsNestedInput
-  question?: Prisma.QuestionUpdateOneRequiredWithoutSubmissionsNestedInput
 }
 
 export type SubmissionUncheckedUpdateInput = {
@@ -599,6 +593,8 @@ export type SubmissionCreateManyInput = {
 
 export type SubmissionUpdateManyMutationInput = {
   id?: Prisma.StringFieldUpdateOperationsInput | string
+  userId?: Prisma.StringFieldUpdateOperationsInput | string
+  questionId?: Prisma.StringFieldUpdateOperationsInput | string
   code?: Prisma.StringFieldUpdateOperationsInput | string
   language?: Prisma.StringFieldUpdateOperationsInput | string
   charCount?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
@@ -743,48 +739,6 @@ export type SubmissionSumOrderByAggregateInput = {
   relevanceScore?: Prisma.SortOrder
 }
 
-export type SubmissionCreateNestedManyWithoutUserInput = {
-  create?: Prisma.XOR<Prisma.SubmissionCreateWithoutUserInput, Prisma.SubmissionUncheckedCreateWithoutUserInput> | Prisma.SubmissionCreateWithoutUserInput[] | Prisma.SubmissionUncheckedCreateWithoutUserInput[]
-  connectOrCreate?: Prisma.SubmissionCreateOrConnectWithoutUserInput | Prisma.SubmissionCreateOrConnectWithoutUserInput[]
-  createMany?: Prisma.SubmissionCreateManyUserInputEnvelope
-  connect?: Prisma.SubmissionWhereUniqueInput | Prisma.SubmissionWhereUniqueInput[]
-}
-
-export type SubmissionUncheckedCreateNestedManyWithoutUserInput = {
-  create?: Prisma.XOR<Prisma.SubmissionCreateWithoutUserInput, Prisma.SubmissionUncheckedCreateWithoutUserInput> | Prisma.SubmissionCreateWithoutUserInput[] | Prisma.SubmissionUncheckedCreateWithoutUserInput[]
-  connectOrCreate?: Prisma.SubmissionCreateOrConnectWithoutUserInput | Prisma.SubmissionCreateOrConnectWithoutUserInput[]
-  createMany?: Prisma.SubmissionCreateManyUserInputEnvelope
-  connect?: Prisma.SubmissionWhereUniqueInput | Prisma.SubmissionWhereUniqueInput[]
-}
-
-export type SubmissionUpdateManyWithoutUserNestedInput = {
-  create?: Prisma.XOR<Prisma.SubmissionCreateWithoutUserInput, Prisma.SubmissionUncheckedCreateWithoutUserInput> | Prisma.SubmissionCreateWithoutUserInput[] | Prisma.SubmissionUncheckedCreateWithoutUserInput[]
-  connectOrCreate?: Prisma.SubmissionCreateOrConnectWithoutUserInput | Prisma.SubmissionCreateOrConnectWithoutUserInput[]
-  upsert?: Prisma.SubmissionUpsertWithWhereUniqueWithoutUserInput | Prisma.SubmissionUpsertWithWhereUniqueWithoutUserInput[]
-  createMany?: Prisma.SubmissionCreateManyUserInputEnvelope
-  set?: Prisma.SubmissionWhereUniqueInput | Prisma.SubmissionWhereUniqueInput[]
-  disconnect?: Prisma.SubmissionWhereUniqueInput | Prisma.SubmissionWhereUniqueInput[]
-  delete?: Prisma.SubmissionWhereUniqueInput | Prisma.SubmissionWhereUniqueInput[]
-  connect?: Prisma.SubmissionWhereUniqueInput | Prisma.SubmissionWhereUniqueInput[]
-  update?: Prisma.SubmissionUpdateWithWhereUniqueWithoutUserInput | Prisma.SubmissionUpdateWithWhereUniqueWithoutUserInput[]
-  updateMany?: Prisma.SubmissionUpdateManyWithWhereWithoutUserInput | Prisma.SubmissionUpdateManyWithWhereWithoutUserInput[]
-  deleteMany?: Prisma.SubmissionScalarWhereInput | Prisma.SubmissionScalarWhereInput[]
-}
-
-export type SubmissionUncheckedUpdateManyWithoutUserNestedInput = {
-  create?: Prisma.XOR<Prisma.SubmissionCreateWithoutUserInput, Prisma.SubmissionUncheckedCreateWithoutUserInput> | Prisma.SubmissionCreateWithoutUserInput[] | Prisma.SubmissionUncheckedCreateWithoutUserInput[]
-  connectOrCreate?: Prisma.SubmissionCreateOrConnectWithoutUserInput | Prisma.SubmissionCreateOrConnectWithoutUserInput[]
-  upsert?: Prisma.SubmissionUpsertWithWhereUniqueWithoutUserInput | Prisma.SubmissionUpsertWithWhereUniqueWithoutUserInput[]
-  createMany?: Prisma.SubmissionCreateManyUserInputEnvelope
-  set?: Prisma.SubmissionWhereUniqueInput | Prisma.SubmissionWhereUniqueInput[]
-  disconnect?: Prisma.SubmissionWhereUniqueInput | Prisma.SubmissionWhereUniqueInput[]
-  delete?: Prisma.SubmissionWhereUniqueInput | Prisma.SubmissionWhereUniqueInput[]
-  connect?: Prisma.SubmissionWhereUniqueInput | Prisma.SubmissionWhereUniqueInput[]
-  update?: Prisma.SubmissionUpdateWithWhereUniqueWithoutUserInput | Prisma.SubmissionUpdateWithWhereUniqueWithoutUserInput[]
-  updateMany?: Prisma.SubmissionUpdateManyWithWhereWithoutUserInput | Prisma.SubmissionUpdateManyWithWhereWithoutUserInput[]
-  deleteMany?: Prisma.SubmissionScalarWhereInput | Prisma.SubmissionScalarWhereInput[]
-}
-
 export type SubmissionCreateNestedManyWithoutMatchInput = {
   create?: Prisma.XOR<Prisma.SubmissionCreateWithoutMatchInput, Prisma.SubmissionUncheckedCreateWithoutMatchInput> | Prisma.SubmissionCreateWithoutMatchInput[] | Prisma.SubmissionUncheckedCreateWithoutMatchInput[]
   connectOrCreate?: Prisma.SubmissionCreateOrConnectWithoutMatchInput | Prisma.SubmissionCreateOrConnectWithoutMatchInput[]
@@ -827,50 +781,10 @@ export type SubmissionUncheckedUpdateManyWithoutMatchNestedInput = {
   deleteMany?: Prisma.SubmissionScalarWhereInput | Prisma.SubmissionScalarWhereInput[]
 }
 
-export type SubmissionCreateNestedManyWithoutQuestionInput = {
-  create?: Prisma.XOR<Prisma.SubmissionCreateWithoutQuestionInput, Prisma.SubmissionUncheckedCreateWithoutQuestionInput> | Prisma.SubmissionCreateWithoutQuestionInput[] | Prisma.SubmissionUncheckedCreateWithoutQuestionInput[]
-  connectOrCreate?: Prisma.SubmissionCreateOrConnectWithoutQuestionInput | Prisma.SubmissionCreateOrConnectWithoutQuestionInput[]
-  createMany?: Prisma.SubmissionCreateManyQuestionInputEnvelope
-  connect?: Prisma.SubmissionWhereUniqueInput | Prisma.SubmissionWhereUniqueInput[]
-}
-
-export type SubmissionUncheckedCreateNestedManyWithoutQuestionInput = {
-  create?: Prisma.XOR<Prisma.SubmissionCreateWithoutQuestionInput, Prisma.SubmissionUncheckedCreateWithoutQuestionInput> | Prisma.SubmissionCreateWithoutQuestionInput[] | Prisma.SubmissionUncheckedCreateWithoutQuestionInput[]
-  connectOrCreate?: Prisma.SubmissionCreateOrConnectWithoutQuestionInput | Prisma.SubmissionCreateOrConnectWithoutQuestionInput[]
-  createMany?: Prisma.SubmissionCreateManyQuestionInputEnvelope
-  connect?: Prisma.SubmissionWhereUniqueInput | Prisma.SubmissionWhereUniqueInput[]
-}
-
-export type SubmissionUpdateManyWithoutQuestionNestedInput = {
-  create?: Prisma.XOR<Prisma.SubmissionCreateWithoutQuestionInput, Prisma.SubmissionUncheckedCreateWithoutQuestionInput> | Prisma.SubmissionCreateWithoutQuestionInput[] | Prisma.SubmissionUncheckedCreateWithoutQuestionInput[]
-  connectOrCreate?: Prisma.SubmissionCreateOrConnectWithoutQuestionInput | Prisma.SubmissionCreateOrConnectWithoutQuestionInput[]
-  upsert?: Prisma.SubmissionUpsertWithWhereUniqueWithoutQuestionInput | Prisma.SubmissionUpsertWithWhereUniqueWithoutQuestionInput[]
-  createMany?: Prisma.SubmissionCreateManyQuestionInputEnvelope
-  set?: Prisma.SubmissionWhereUniqueInput | Prisma.SubmissionWhereUniqueInput[]
-  disconnect?: Prisma.SubmissionWhereUniqueInput | Prisma.SubmissionWhereUniqueInput[]
-  delete?: Prisma.SubmissionWhereUniqueInput | Prisma.SubmissionWhereUniqueInput[]
-  connect?: Prisma.SubmissionWhereUniqueInput | Prisma.SubmissionWhereUniqueInput[]
-  update?: Prisma.SubmissionUpdateWithWhereUniqueWithoutQuestionInput | Prisma.SubmissionUpdateWithWhereUniqueWithoutQuestionInput[]
-  updateMany?: Prisma.SubmissionUpdateManyWithWhereWithoutQuestionInput | Prisma.SubmissionUpdateManyWithWhereWithoutQuestionInput[]
-  deleteMany?: Prisma.SubmissionScalarWhereInput | Prisma.SubmissionScalarWhereInput[]
-}
-
-export type SubmissionUncheckedUpdateManyWithoutQuestionNestedInput = {
-  create?: Prisma.XOR<Prisma.SubmissionCreateWithoutQuestionInput, Prisma.SubmissionUncheckedCreateWithoutQuestionInput> | Prisma.SubmissionCreateWithoutQuestionInput[] | Prisma.SubmissionUncheckedCreateWithoutQuestionInput[]
-  connectOrCreate?: Prisma.SubmissionCreateOrConnectWithoutQuestionInput | Prisma.SubmissionCreateOrConnectWithoutQuestionInput[]
-  upsert?: Prisma.SubmissionUpsertWithWhereUniqueWithoutQuestionInput | Prisma.SubmissionUpsertWithWhereUniqueWithoutQuestionInput[]
-  createMany?: Prisma.SubmissionCreateManyQuestionInputEnvelope
-  set?: Prisma.SubmissionWhereUniqueInput | Prisma.SubmissionWhereUniqueInput[]
-  disconnect?: Prisma.SubmissionWhereUniqueInput | Prisma.SubmissionWhereUniqueInput[]
-  delete?: Prisma.SubmissionWhereUniqueInput | Prisma.SubmissionWhereUniqueInput[]
-  connect?: Prisma.SubmissionWhereUniqueInput | Prisma.SubmissionWhereUniqueInput[]
-  update?: Prisma.SubmissionUpdateWithWhereUniqueWithoutQuestionInput | Prisma.SubmissionUpdateWithWhereUniqueWithoutQuestionInput[]
-  updateMany?: Prisma.SubmissionUpdateManyWithWhereWithoutQuestionInput | Prisma.SubmissionUpdateManyWithWhereWithoutQuestionInput[]
-  deleteMany?: Prisma.SubmissionScalarWhereInput | Prisma.SubmissionScalarWhereInput[]
-}
-
-export type SubmissionCreateWithoutUserInput = {
+export type SubmissionCreateWithoutMatchInput = {
   id?: string
+  userId: string
+  questionId: string
   code: string
   language: string
   charCount?: number | null
@@ -887,13 +801,11 @@ export type SubmissionCreateWithoutUserInput = {
   originalityScore?: number | null
   relevanceScore?: number | null
   submittedAt?: Date | string
-  match: Prisma.MatchCreateNestedOneWithoutSubmissionsInput
-  question: Prisma.QuestionCreateNestedOneWithoutSubmissionsInput
 }
 
-export type SubmissionUncheckedCreateWithoutUserInput = {
+export type SubmissionUncheckedCreateWithoutMatchInput = {
   id?: string
-  matchId: string
+  userId: string
   questionId: string
   code: string
   language: string
@@ -913,30 +825,30 @@ export type SubmissionUncheckedCreateWithoutUserInput = {
   submittedAt?: Date | string
 }
 
-export type SubmissionCreateOrConnectWithoutUserInput = {
+export type SubmissionCreateOrConnectWithoutMatchInput = {
   where: Prisma.SubmissionWhereUniqueInput
-  create: Prisma.XOR<Prisma.SubmissionCreateWithoutUserInput, Prisma.SubmissionUncheckedCreateWithoutUserInput>
+  create: Prisma.XOR<Prisma.SubmissionCreateWithoutMatchInput, Prisma.SubmissionUncheckedCreateWithoutMatchInput>
 }
 
-export type SubmissionCreateManyUserInputEnvelope = {
-  data: Prisma.SubmissionCreateManyUserInput | Prisma.SubmissionCreateManyUserInput[]
+export type SubmissionCreateManyMatchInputEnvelope = {
+  data: Prisma.SubmissionCreateManyMatchInput | Prisma.SubmissionCreateManyMatchInput[]
   skipDuplicates?: boolean
 }
 
-export type SubmissionUpsertWithWhereUniqueWithoutUserInput = {
+export type SubmissionUpsertWithWhereUniqueWithoutMatchInput = {
   where: Prisma.SubmissionWhereUniqueInput
-  update: Prisma.XOR<Prisma.SubmissionUpdateWithoutUserInput, Prisma.SubmissionUncheckedUpdateWithoutUserInput>
-  create: Prisma.XOR<Prisma.SubmissionCreateWithoutUserInput, Prisma.SubmissionUncheckedCreateWithoutUserInput>
+  update: Prisma.XOR<Prisma.SubmissionUpdateWithoutMatchInput, Prisma.SubmissionUncheckedUpdateWithoutMatchInput>
+  create: Prisma.XOR<Prisma.SubmissionCreateWithoutMatchInput, Prisma.SubmissionUncheckedCreateWithoutMatchInput>
 }
 
-export type SubmissionUpdateWithWhereUniqueWithoutUserInput = {
+export type SubmissionUpdateWithWhereUniqueWithoutMatchInput = {
   where: Prisma.SubmissionWhereUniqueInput
-  data: Prisma.XOR<Prisma.SubmissionUpdateWithoutUserInput, Prisma.SubmissionUncheckedUpdateWithoutUserInput>
+  data: Prisma.XOR<Prisma.SubmissionUpdateWithoutMatchInput, Prisma.SubmissionUncheckedUpdateWithoutMatchInput>
 }
 
-export type SubmissionUpdateManyWithWhereWithoutUserInput = {
+export type SubmissionUpdateManyWithWhereWithoutMatchInput = {
   where: Prisma.SubmissionScalarWhereInput
-  data: Prisma.XOR<Prisma.SubmissionUpdateManyMutationInput, Prisma.SubmissionUncheckedUpdateManyWithoutUserInput>
+  data: Prisma.XOR<Prisma.SubmissionUpdateManyMutationInput, Prisma.SubmissionUncheckedUpdateManyWithoutMatchInput>
 }
 
 export type SubmissionScalarWhereInput = {
@@ -965,234 +877,6 @@ export type SubmissionScalarWhereInput = {
   submittedAt?: Prisma.DateTimeFilter<"Submission"> | Date | string
 }
 
-export type SubmissionCreateWithoutMatchInput = {
-  id?: string
-  code: string
-  language: string
-  charCount?: number | null
-  stdout?: string | null
-  stderr?: string | null
-  exitCode?: number | null
-  execTimeMs?: number | null
-  testsPassed?: number
-  testsTotal?: number
-  timeComplexity?: string | null
-  timeScore?: number | null
-  spaceComplexity?: string | null
-  spaceScore?: number | null
-  originalityScore?: number | null
-  relevanceScore?: number | null
-  submittedAt?: Date | string
-  user: Prisma.UserCreateNestedOneWithoutSubmissionsInput
-  question: Prisma.QuestionCreateNestedOneWithoutSubmissionsInput
-}
-
-export type SubmissionUncheckedCreateWithoutMatchInput = {
-  id?: string
-  userId: string
-  questionId: string
-  code: string
-  language: string
-  charCount?: number | null
-  stdout?: string | null
-  stderr?: string | null
-  exitCode?: number | null
-  execTimeMs?: number | null
-  testsPassed?: number
-  testsTotal?: number
-  timeComplexity?: string | null
-  timeScore?: number | null
-  spaceComplexity?: string | null
-  spaceScore?: number | null
-  originalityScore?: number | null
-  relevanceScore?: number | null
-  submittedAt?: Date | string
-}
-
-export type SubmissionCreateOrConnectWithoutMatchInput = {
-  where: Prisma.SubmissionWhereUniqueInput
-  create: Prisma.XOR<Prisma.SubmissionCreateWithoutMatchInput, Prisma.SubmissionUncheckedCreateWithoutMatchInput>
-}
-
-export type SubmissionCreateManyMatchInputEnvelope = {
-  data: Prisma.SubmissionCreateManyMatchInput | Prisma.SubmissionCreateManyMatchInput[]
-  skipDuplicates?: boolean
-}
-
-export type SubmissionUpsertWithWhereUniqueWithoutMatchInput = {
-  where: Prisma.SubmissionWhereUniqueInput
-  update: Prisma.XOR<Prisma.SubmissionUpdateWithoutMatchInput, Prisma.SubmissionUncheckedUpdateWithoutMatchInput>
-  create: Prisma.XOR<Prisma.SubmissionCreateWithoutMatchInput, Prisma.SubmissionUncheckedCreateWithoutMatchInput>
-}
-
-export type SubmissionUpdateWithWhereUniqueWithoutMatchInput = {
-  where: Prisma.SubmissionWhereUniqueInput
-  data: Prisma.XOR<Prisma.SubmissionUpdateWithoutMatchInput, Prisma.SubmissionUncheckedUpdateWithoutMatchInput>
-}
-
-export type SubmissionUpdateManyWithWhereWithoutMatchInput = {
-  where: Prisma.SubmissionScalarWhereInput
-  data: Prisma.XOR<Prisma.SubmissionUpdateManyMutationInput, Prisma.SubmissionUncheckedUpdateManyWithoutMatchInput>
-}
-
-export type SubmissionCreateWithoutQuestionInput = {
-  id?: string
-  code: string
-  language: string
-  charCount?: number | null
-  stdout?: string | null
-  stderr?: string | null
-  exitCode?: number | null
-  execTimeMs?: number | null
-  testsPassed?: number
-  testsTotal?: number
-  timeComplexity?: string | null
-  timeScore?: number | null
-  spaceComplexity?: string | null
-  spaceScore?: number | null
-  originalityScore?: number | null
-  relevanceScore?: number | null
-  submittedAt?: Date | string
-  match: Prisma.MatchCreateNestedOneWithoutSubmissionsInput
-  user: Prisma.UserCreateNestedOneWithoutSubmissionsInput
-}
-
-export type SubmissionUncheckedCreateWithoutQuestionInput = {
-  id?: string
-  matchId: string
-  userId: string
-  code: string
-  language: string
-  charCount?: number | null
-  stdout?: string | null
-  stderr?: string | null
-  exitCode?: number | null
-  execTimeMs?: number | null
-  testsPassed?: number
-  testsTotal?: number
-  timeComplexity?: string | null
-  timeScore?: number | null
-  spaceComplexity?: string | null
-  spaceScore?: number | null
-  originalityScore?: number | null
-  relevanceScore?: number | null
-  submittedAt?: Date | string
-}
-
-export type SubmissionCreateOrConnectWithoutQuestionInput = {
-  where: Prisma.SubmissionWhereUniqueInput
-  create: Prisma.XOR<Prisma.SubmissionCreateWithoutQuestionInput, Prisma.SubmissionUncheckedCreateWithoutQuestionInput>
-}
-
-export type SubmissionCreateManyQuestionInputEnvelope = {
-  data: Prisma.SubmissionCreateManyQuestionInput | Prisma.SubmissionCreateManyQuestionInput[]
-  skipDuplicates?: boolean
-}
-
-export type SubmissionUpsertWithWhereUniqueWithoutQuestionInput = {
-  where: Prisma.SubmissionWhereUniqueInput
-  update: Prisma.XOR<Prisma.SubmissionUpdateWithoutQuestionInput, Prisma.SubmissionUncheckedUpdateWithoutQuestionInput>
-  create: Prisma.XOR<Prisma.SubmissionCreateWithoutQuestionInput, Prisma.SubmissionUncheckedCreateWithoutQuestionInput>
-}
-
-export type SubmissionUpdateWithWhereUniqueWithoutQuestionInput = {
-  where: Prisma.SubmissionWhereUniqueInput
-  data: Prisma.XOR<Prisma.SubmissionUpdateWithoutQuestionInput, Prisma.SubmissionUncheckedUpdateWithoutQuestionInput>
-}
-
-export type SubmissionUpdateManyWithWhereWithoutQuestionInput = {
-  where: Prisma.SubmissionScalarWhereInput
-  data: Prisma.XOR<Prisma.SubmissionUpdateManyMutationInput, Prisma.SubmissionUncheckedUpdateManyWithoutQuestionInput>
-}
-
-export type SubmissionCreateManyUserInput = {
-  id?: string
-  matchId: string
-  questionId: string
-  code: string
-  language: string
-  charCount?: number | null
-  stdout?: string | null
-  stderr?: string | null
-  exitCode?: number | null
-  execTimeMs?: number | null
-  testsPassed?: number
-  testsTotal?: number
-  timeComplexity?: string | null
-  timeScore?: number | null
-  spaceComplexity?: string | null
-  spaceScore?: number | null
-  originalityScore?: number | null
-  relevanceScore?: number | null
-  submittedAt?: Date | string
-}
-
-export type SubmissionUpdateWithoutUserInput = {
-  id?: Prisma.StringFieldUpdateOperationsInput | string
-  code?: Prisma.StringFieldUpdateOperationsInput | string
-  language?: Prisma.StringFieldUpdateOperationsInput | string
-  charCount?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
-  stdout?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
-  stderr?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
-  exitCode?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
-  execTimeMs?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
-  testsPassed?: Prisma.IntFieldUpdateOperationsInput | number
-  testsTotal?: Prisma.IntFieldUpdateOperationsInput | number
-  timeComplexity?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
-  timeScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
-  spaceComplexity?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
-  spaceScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
-  originalityScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
-  relevanceScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
-  submittedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
-  match?: Prisma.MatchUpdateOneRequiredWithoutSubmissionsNestedInput
-  question?: Prisma.QuestionUpdateOneRequiredWithoutSubmissionsNestedInput
-}
-
-export type SubmissionUncheckedUpdateWithoutUserInput = {
-  id?: Prisma.StringFieldUpdateOperationsInput | string
-  matchId?: Prisma.StringFieldUpdateOperationsInput | string
-  questionId?: Prisma.StringFieldUpdateOperationsInput | string
-  code?: Prisma.StringFieldUpdateOperationsInput | string
-  language?: Prisma.StringFieldUpdateOperationsInput | string
-  charCount?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
-  stdout?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
-  stderr?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
-  exitCode?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
-  execTimeMs?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
-  testsPassed?: Prisma.IntFieldUpdateOperationsInput | number
-  testsTotal?: Prisma.IntFieldUpdateOperationsInput | number
-  timeComplexity?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
-  timeScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
-  spaceComplexity?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
-  spaceScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
-  originalityScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
-  relevanceScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
-  submittedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
-}
-
-export type SubmissionUncheckedUpdateManyWithoutUserInput = {
-  id?: Prisma.StringFieldUpdateOperationsInput | string
-  matchId?: Prisma.StringFieldUpdateOperationsInput | string
-  questionId?: Prisma.StringFieldUpdateOperationsInput | string
-  code?: Prisma.StringFieldUpdateOperationsInput | string
-  language?: Prisma.StringFieldUpdateOperationsInput | string
-  charCount?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
-  stdout?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
-  stderr?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
-  exitCode?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
-  execTimeMs?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
-  testsPassed?: Prisma.IntFieldUpdateOperationsInput | number
-  testsTotal?: Prisma.IntFieldUpdateOperationsInput | number
-  timeComplexity?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
-  timeScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
-  spaceComplexity?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
-  spaceScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
-  originalityScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
-  relevanceScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
-  submittedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
-}
-
 export type SubmissionCreateManyMatchInput = {
   id?: string
   userId: string
@@ -1217,6 +901,8 @@ export type SubmissionCreateManyMatchInput = {
 
 export type SubmissionUpdateWithoutMatchInput = {
   id?: Prisma.StringFieldUpdateOperationsInput | string
+  userId?: Prisma.StringFieldUpdateOperationsInput | string
+  questionId?: Prisma.StringFieldUpdateOperationsInput | string
   code?: Prisma.StringFieldUpdateOperationsInput | string
   language?: Prisma.StringFieldUpdateOperationsInput | string
   charCount?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
@@ -1233,8 +919,6 @@ export type SubmissionUpdateWithoutMatchInput = {
   originalityScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
   relevanceScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
   submittedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
-  user?: Prisma.UserUpdateOneRequiredWithoutSubmissionsNestedInput
-  question?: Prisma.QuestionUpdateOneRequiredWithoutSubmissionsNestedInput
 }
 
 export type SubmissionUncheckedUpdateWithoutMatchInput = {
@@ -1281,94 +965,6 @@ export type SubmissionUncheckedUpdateManyWithoutMatchInput = {
   submittedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
 }
 
-export type SubmissionCreateManyQuestionInput = {
-  id?: string
-  matchId: string
-  userId: string
-  code: string
-  language: string
-  charCount?: number | null
-  stdout?: string | null
-  stderr?: string | null
-  exitCode?: number | null
-  execTimeMs?: number | null
-  testsPassed?: number
-  testsTotal?: number
-  timeComplexity?: string | null
-  timeScore?: number | null
-  spaceComplexity?: string | null
-  spaceScore?: number | null
-  originalityScore?: number | null
-  relevanceScore?: number | null
-  submittedAt?: Date | string
-}
-
-export type SubmissionUpdateWithoutQuestionInput = {
-  id?: Prisma.StringFieldUpdateOperationsInput | string
-  code?: Prisma.StringFieldUpdateOperationsInput | string
-  language?: Prisma.StringFieldUpdateOperationsInput | string
-  charCount?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
-  stdout?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
-  stderr?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
-  exitCode?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
-  execTimeMs?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
-  testsPassed?: Prisma.IntFieldUpdateOperationsInput | number
-  testsTotal?: Prisma.IntFieldUpdateOperationsInput | number
-  timeComplexity?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
-  timeScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
-  spaceComplexity?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
-  spaceScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
-  originalityScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
-  relevanceScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
-  submittedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
-  match?: Prisma.MatchUpdateOneRequiredWithoutSubmissionsNestedInput
-  user?: Prisma.UserUpdateOneRequiredWithoutSubmissionsNestedInput
-}
-
-export type SubmissionUncheckedUpdateWithoutQuestionInput = {
-  id?: Prisma.StringFieldUpdateOperationsInput | string
-  matchId?: Prisma.StringFieldUpdateOperationsInput | string
-  userId?: Prisma.StringFieldUpdateOperationsInput | string
-  code?: Prisma.StringFieldUpdateOperationsInput | string
-  language?: Prisma.StringFieldUpdateOperationsInput | string
-  charCount?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
-  stdout?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
-  stderr?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
-  exitCode?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
-  execTimeMs?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
-  testsPassed?: Prisma.IntFieldUpdateOperationsInput | number
-  testsTotal?: Prisma.IntFieldUpdateOperationsInput | number
-  timeComplexity?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
-  timeScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
-  spaceComplexity?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
-  spaceScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
-  originalityScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
-  relevanceScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
-  submittedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
-}
-
-export type SubmissionUncheckedUpdateManyWithoutQuestionInput = {
-  id?: Prisma.StringFieldUpdateOperationsInput | string
-  matchId?: Prisma.StringFieldUpdateOperationsInput | string
-  userId?: Prisma.StringFieldUpdateOperationsInput | string
-  code?: Prisma.StringFieldUpdateOperationsInput | string
-  language?: Prisma.StringFieldUpdateOperationsInput | string
-  charCount?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
-  stdout?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
-  stderr?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
-  exitCode?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
-  execTimeMs?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
-  testsPassed?: Prisma.IntFieldUpdateOperationsInput | number
-  testsTotal?: Prisma.IntFieldUpdateOperationsInput | number
-  timeComplexity?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
-  timeScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
-  spaceComplexity?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
-  spaceScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
-  originalityScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
-  relevanceScore?: Prisma.NullableFloatFieldUpdateOperationsInput | number | null
-  submittedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
-}
-
 
 
 export type SubmissionSelect<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
@@ -1393,8 +989,6 @@ export type SubmissionSelect<ExtArgs extends runtime.Types.Extensions.InternalAr
   relevanceScore?: boolean
   submittedAt?: boolean
   match?: boolean | Prisma.MatchDefaultArgs<ExtArgs>
-  user?: boolean | Prisma.UserDefaultArgs<ExtArgs>
-  question?: boolean | Prisma.QuestionDefaultArgs<ExtArgs>
 }, ExtArgs["result"]["submission"]>
 
 export type SubmissionSelectCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
@@ -1419,8 +1013,6 @@ export type SubmissionSelectCreateManyAndReturn<ExtArgs extends runtime.Types.Ex
   relevanceScore?: boolean
   submittedAt?: boolean
   match?: boolean | Prisma.MatchDefaultArgs<ExtArgs>
-  user?: boolean | Prisma.UserDefaultArgs<ExtArgs>
-  question?: boolean | Prisma.QuestionDefaultArgs<ExtArgs>
 }, ExtArgs["result"]["submission"]>
 
 export type SubmissionSelectUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
@@ -1445,8 +1037,6 @@ export type SubmissionSelectUpdateManyAndReturn<ExtArgs extends runtime.Types.Ex
   relevanceScore?: boolean
   submittedAt?: boolean
   match?: boolean | Prisma.MatchDefaultArgs<ExtArgs>
-  user?: boolean | Prisma.UserDefaultArgs<ExtArgs>
-  question?: boolean | Prisma.QuestionDefaultArgs<ExtArgs>
 }, ExtArgs["result"]["submission"]>
 
 export type SubmissionSelectScalar = {
@@ -1475,26 +1065,18 @@ export type SubmissionSelectScalar = {
 export type SubmissionOmit<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetOmit<"id" | "matchId" | "userId" | "questionId" | "code" | "language" | "charCount" | "stdout" | "stderr" | "exitCode" | "execTimeMs" | "testsPassed" | "testsTotal" | "timeComplexity" | "timeScore" | "spaceComplexity" | "spaceScore" | "originalityScore" | "relevanceScore" | "submittedAt", ExtArgs["result"]["submission"]>
 export type SubmissionInclude<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
   match?: boolean | Prisma.MatchDefaultArgs<ExtArgs>
-  user?: boolean | Prisma.UserDefaultArgs<ExtArgs>
-  question?: boolean | Prisma.QuestionDefaultArgs<ExtArgs>
 }
 export type SubmissionIncludeCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
   match?: boolean | Prisma.MatchDefaultArgs<ExtArgs>
-  user?: boolean | Prisma.UserDefaultArgs<ExtArgs>
-  question?: boolean | Prisma.QuestionDefaultArgs<ExtArgs>
 }
 export type SubmissionIncludeUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
   match?: boolean | Prisma.MatchDefaultArgs<ExtArgs>
-  user?: boolean | Prisma.UserDefaultArgs<ExtArgs>
-  question?: boolean | Prisma.QuestionDefaultArgs<ExtArgs>
 }
 
 export type $SubmissionPayload<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
   name: "Submission"
   objects: {
     match: Prisma.$MatchPayload<ExtArgs>
-    user: Prisma.$UserPayload<ExtArgs>
-    question: Prisma.$QuestionPayload<ExtArgs>
   }
   scalars: runtime.Types.Extensions.GetPayloadResult<{
     id: string
@@ -1912,8 +1494,6 @@ readonly fields: SubmissionFieldRefs;
 export interface Prisma__SubmissionClient<T, Null = never, ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
   readonly [Symbol.toStringTag]: "PrismaPromise"
   match<T extends Prisma.MatchDefaultArgs<ExtArgs> = {}>(args?: Prisma.Subset<T, Prisma.MatchDefaultArgs<ExtArgs>>): Prisma.Prisma__MatchClient<runtime.Types.Result.GetResult<Prisma.$MatchPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
-  user<T extends Prisma.UserDefaultArgs<ExtArgs> = {}>(args?: Prisma.Subset<T, Prisma.UserDefaultArgs<ExtArgs>>): Prisma.Prisma__UserClient<runtime.Types.Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
-  question<T extends Prisma.QuestionDefaultArgs<ExtArgs> = {}>(args?: Prisma.Subset<T, Prisma.QuestionDefaultArgs<ExtArgs>>): Prisma.Prisma__QuestionClient<runtime.Types.Result.GetResult<Prisma.$QuestionPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
   /**
    * Attaches callbacks for the resolution and/or rejection of the Promise.
    * @param onfulfilled The callback to execute when the Promise is resolved.
diff --git a/prisma/generated/prisma/models/User.ts b/prisma/generated/prisma/models/User.ts
index db33538..d303ce9 100644
--- a/prisma/generated/prisma/models/User.ts
+++ b/prisma/generated/prisma/models/User.ts
@@ -312,7 +312,6 @@ export type UserWhereInput = {
   streak?: Prisma.IntFilter<"User"> | number
   createdAt?: Prisma.DateTimeFilter<"User"> | Date | string
   updatedAt?: Prisma.DateTimeFilter<"User"> | Date | string
-  submissions?: Prisma.SubmissionListRelationFilter
   matchPlayers?: Prisma.MatchPlayerListRelationFilter
   queueEntries?: Prisma.QueueEntryListRelationFilter
 }
@@ -333,7 +332,6 @@ export type UserOrderByWithRelationInput = {
   streak?: Prisma.SortOrder
   createdAt?: Prisma.SortOrder
   updatedAt?: Prisma.SortOrder
-  submissions?: Prisma.SubmissionOrderByRelationAggregateInput
   matchPlayers?: Prisma.MatchPlayerOrderByRelationAggregateInput
   queueEntries?: Prisma.QueueEntryOrderByRelationAggregateInput
 }
@@ -357,7 +355,6 @@ export type UserWhereUniqueInput = Prisma.AtLeast<{
   streak?: Prisma.IntFilter<"User"> | number
   createdAt?: Prisma.DateTimeFilter<"User"> | Date | string
   updatedAt?: Prisma.DateTimeFilter<"User"> | Date | string
-  submissions?: Prisma.SubmissionListRelationFilter
   matchPlayers?: Prisma.MatchPlayerListRelationFilter
   queueEntries?: Prisma.QueueEntryListRelationFilter
 }, "id" | "username" | "email">
@@ -422,7 +419,6 @@ export type UserCreateInput = {
   streak?: number
   createdAt?: Date | string
   updatedAt?: Date | string
-  submissions?: Prisma.SubmissionCreateNestedManyWithoutUserInput
   matchPlayers?: Prisma.MatchPlayerCreateNestedManyWithoutUserInput
   queueEntries?: Prisma.QueueEntryCreateNestedManyWithoutUserInput
 }
@@ -443,7 +439,6 @@ export type UserUncheckedCreateInput = {
   streak?: number
   createdAt?: Date | string
   updatedAt?: Date | string
-  submissions?: Prisma.SubmissionUncheckedCreateNestedManyWithoutUserInput
   matchPlayers?: Prisma.MatchPlayerUncheckedCreateNestedManyWithoutUserInput
   queueEntries?: Prisma.QueueEntryUncheckedCreateNestedManyWithoutUserInput
 }
@@ -464,7 +459,6 @@ export type UserUpdateInput = {
   streak?: Prisma.IntFieldUpdateOperationsInput | number
   createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
   updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
-  submissions?: Prisma.SubmissionUpdateManyWithoutUserNestedInput
   matchPlayers?: Prisma.MatchPlayerUpdateManyWithoutUserNestedInput
   queueEntries?: Prisma.QueueEntryUpdateManyWithoutUserNestedInput
 }
@@ -485,7 +479,6 @@ export type UserUncheckedUpdateInput = {
   streak?: Prisma.IntFieldUpdateOperationsInput | number
   createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
   updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
-  submissions?: Prisma.SubmissionUncheckedUpdateManyWithoutUserNestedInput
   matchPlayers?: Prisma.MatchPlayerUncheckedUpdateManyWithoutUserNestedInput
   queueEntries?: Prisma.QueueEntryUncheckedUpdateManyWithoutUserNestedInput
 }
@@ -671,20 +664,6 @@ export type UserUpdateOneRequiredWithoutMatchPlayersNestedInput = {
   update?: Prisma.XOR<Prisma.XOR<Prisma.UserUpdateToOneWithWhereWithoutMatchPlayersInput, Prisma.UserUpdateWithoutMatchPlayersInput>, Prisma.UserUncheckedUpdateWithoutMatchPlayersInput>
 }
 
-export type UserCreateNestedOneWithoutSubmissionsInput = {
-  create?: Prisma.XOR<Prisma.UserCreateWithoutSubmissionsInput, Prisma.UserUncheckedCreateWithoutSubmissionsInput>
-  connectOrCreate?: Prisma.UserCreateOrConnectWithoutSubmissionsInput
-  connect?: Prisma.UserWhereUniqueInput
-}
-
-export type UserUpdateOneRequiredWithoutSubmissionsNestedInput = {
-  create?: Prisma.XOR<Prisma.UserCreateWithoutSubmissionsInput, Prisma.UserUncheckedCreateWithoutSubmissionsInput>
-  connectOrCreate?: Prisma.UserCreateOrConnectWithoutSubmissionsInput
-  upsert?: Prisma.UserUpsertWithoutSubmissionsInput
-  connect?: Prisma.UserWhereUniqueInput
-  update?: Prisma.XOR<Prisma.XOR<Prisma.UserUpdateToOneWithWhereWithoutSubmissionsInput, Prisma.UserUpdateWithoutSubmissionsInput>, Prisma.UserUncheckedUpdateWithoutSubmissionsInput>
-}
-
 export type UserCreateWithoutQueueEntriesInput = {
   id?: string
   username: string
@@ -701,7 +680,6 @@ export type UserCreateWithoutQueueEntriesInput = {
   streak?: number
   createdAt?: Date | string
   updatedAt?: Date | string
-  submissions?: Prisma.SubmissionCreateNestedManyWithoutUserInput
   matchPlayers?: Prisma.MatchPlayerCreateNestedManyWithoutUserInput
 }
 
@@ -721,7 +699,6 @@ export type UserUncheckedCreateWithoutQueueEntriesInput = {
   streak?: number
   createdAt?: Date | string
   updatedAt?: Date | string
-  submissions?: Prisma.SubmissionUncheckedCreateNestedManyWithoutUserInput
   matchPlayers?: Prisma.MatchPlayerUncheckedCreateNestedManyWithoutUserInput
 }
 
@@ -757,7 +734,6 @@ export type UserUpdateWithoutQueueEntriesInput = {
   streak?: Prisma.IntFieldUpdateOperationsInput | number
   createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
   updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
-  submissions?: Prisma.SubmissionUpdateManyWithoutUserNestedInput
   matchPlayers?: Prisma.MatchPlayerUpdateManyWithoutUserNestedInput
 }
 
@@ -777,7 +753,6 @@ export type UserUncheckedUpdateWithoutQueueEntriesInput = {
   streak?: Prisma.IntFieldUpdateOperationsInput | number
   createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
   updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
-  submissions?: Prisma.SubmissionUncheckedUpdateManyWithoutUserNestedInput
   matchPlayers?: Prisma.MatchPlayerUncheckedUpdateManyWithoutUserNestedInput
 }
 
@@ -797,7 +772,6 @@ export type UserCreateWithoutMatchPlayersInput = {
   streak?: number
   createdAt?: Date | string
   updatedAt?: Date | string
-  submissions?: Prisma.SubmissionCreateNestedManyWithoutUserInput
   queueEntries?: Prisma.QueueEntryCreateNestedManyWithoutUserInput
 }
 
@@ -817,7 +791,6 @@ export type UserUncheckedCreateWithoutMatchPlayersInput = {
   streak?: number
   createdAt?: Date | string
   updatedAt?: Date | string
-  submissions?: Prisma.SubmissionUncheckedCreateNestedManyWithoutUserInput
   queueEntries?: Prisma.QueueEntryUncheckedCreateNestedManyWithoutUserInput
 }
 
@@ -853,7 +826,6 @@ export type UserUpdateWithoutMatchPlayersInput = {
   streak?: Prisma.IntFieldUpdateOperationsInput | number
   createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
   updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
-  submissions?: Prisma.SubmissionUpdateManyWithoutUserNestedInput
   queueEntries?: Prisma.QueueEntryUpdateManyWithoutUserNestedInput
 }
 
@@ -873,103 +845,6 @@ export type UserUncheckedUpdateWithoutMatchPlayersInput = {
   streak?: Prisma.IntFieldUpdateOperationsInput | number
   createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
   updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
-  submissions?: Prisma.SubmissionUncheckedUpdateManyWithoutUserNestedInput
-  queueEntries?: Prisma.QueueEntryUncheckedUpdateManyWithoutUserNestedInput
-}
-
-export type UserCreateWithoutSubmissionsInput = {
-  id?: string
-  username: string
-  email: string
-  passwordHash: string
-  displayName?: string | null
-  avatarUrl?: string | null
-  title?: string
-  skillTier?: $Enums.SkillTier
-  elo?: number
-  totalWins?: number
-  totalMatches?: number
-  totalXP?: number
-  streak?: number
-  createdAt?: Date | string
-  updatedAt?: Date | string
-  matchPlayers?: Prisma.MatchPlayerCreateNestedManyWithoutUserInput
-  queueEntries?: Prisma.QueueEntryCreateNestedManyWithoutUserInput
-}
-
-export type UserUncheckedCreateWithoutSubmissionsInput = {
-  id?: string
-  username: string
-  email: string
-  passwordHash: string
-  displayName?: string | null
-  avatarUrl?: string | null
-  title?: string
-  skillTier?: $Enums.SkillTier
-  elo?: number
-  totalWins?: number
-  totalMatches?: number
-  totalXP?: number
-  streak?: number
-  createdAt?: Date | string
-  updatedAt?: Date | string
-  matchPlayers?: Prisma.MatchPlayerUncheckedCreateNestedManyWithoutUserInput
-  queueEntries?: Prisma.QueueEntryUncheckedCreateNestedManyWithoutUserInput
-}
-
-export type UserCreateOrConnectWithoutSubmissionsInput = {
-  where: Prisma.UserWhereUniqueInput
-  create: Prisma.XOR<Prisma.UserCreateWithoutSubmissionsInput, Prisma.UserUncheckedCreateWithoutSubmissionsInput>
-}
-
-export type UserUpsertWithoutSubmissionsInput = {
-  update: Prisma.XOR<Prisma.UserUpdateWithoutSubmissionsInput, Prisma.UserUncheckedUpdateWithoutSubmissionsInput>
-  create: Prisma.XOR<Prisma.UserCreateWithoutSubmissionsInput, Prisma.UserUncheckedCreateWithoutSubmissionsInput>
-  where?: Prisma.UserWhereInput
-}
-
-export type UserUpdateToOneWithWhereWithoutSubmissionsInput = {
-  where?: Prisma.UserWhereInput
-  data: Prisma.XOR<Prisma.UserUpdateWithoutSubmissionsInput, Prisma.UserUncheckedUpdateWithoutSubmissionsInput>
-}
-
-export type UserUpdateWithoutSubmissionsInput = {
-  id?: Prisma.StringFieldUpdateOperationsInput | string
-  username?: Prisma.StringFieldUpdateOperationsInput | string
-  email?: Prisma.StringFieldUpdateOperationsInput | string
-  passwordHash?: Prisma.StringFieldUpdateOperationsInput | string
-  displayName?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
-  avatarUrl?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
-  title?: Prisma.StringFieldUpdateOperationsInput | string
-  skillTier?: Prisma.EnumSkillTierFieldUpdateOperationsInput | $Enums.SkillTier
-  elo?: Prisma.IntFieldUpdateOperationsInput | number
-  totalWins?: Prisma.IntFieldUpdateOperationsInput | number
-  totalMatches?: Prisma.IntFieldUpdateOperationsInput | number
-  totalXP?: Prisma.IntFieldUpdateOperationsInput | number
-  streak?: Prisma.IntFieldUpdateOperationsInput | number
-  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
-  updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
-  matchPlayers?: Prisma.MatchPlayerUpdateManyWithoutUserNestedInput
-  queueEntries?: Prisma.QueueEntryUpdateManyWithoutUserNestedInput
-}
-
-export type UserUncheckedUpdateWithoutSubmissionsInput = {
-  id?: Prisma.StringFieldUpdateOperationsInput | string
-  username?: Prisma.StringFieldUpdateOperationsInput | string
-  email?: Prisma.StringFieldUpdateOperationsInput | string
-  passwordHash?: Prisma.StringFieldUpdateOperationsInput | string
-  displayName?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
-  avatarUrl?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
-  title?: Prisma.StringFieldUpdateOperationsInput | string
-  skillTier?: Prisma.EnumSkillTierFieldUpdateOperationsInput | $Enums.SkillTier
-  elo?: Prisma.IntFieldUpdateOperationsInput | number
-  totalWins?: Prisma.IntFieldUpdateOperationsInput | number
-  totalMatches?: Prisma.IntFieldUpdateOperationsInput | number
-  totalXP?: Prisma.IntFieldUpdateOperationsInput | number
-  streak?: Prisma.IntFieldUpdateOperationsInput | number
-  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
-  updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
-  matchPlayers?: Prisma.MatchPlayerUncheckedUpdateManyWithoutUserNestedInput
   queueEntries?: Prisma.QueueEntryUncheckedUpdateManyWithoutUserNestedInput
 }
 
@@ -979,13 +854,11 @@ export type UserUncheckedUpdateWithoutSubmissionsInput = {
  */
 
 export type UserCountOutputType = {
-  submissions: number
   matchPlayers: number
   queueEntries: number
 }
 
 export type UserCountOutputTypeSelect<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
-  submissions?: boolean | UserCountOutputTypeCountSubmissionsArgs
   matchPlayers?: boolean | UserCountOutputTypeCountMatchPlayersArgs
   queueEntries?: boolean | UserCountOutputTypeCountQueueEntriesArgs
 }
@@ -1000,13 +873,6 @@ export type UserCountOutputTypeDefaultArgs<ExtArgs extends runtime.Types.Extensi
   select?: Prisma.UserCountOutputTypeSelect<ExtArgs> | null
 }
 
-/**
- * UserCountOutputType without action
- */
-export type UserCountOutputTypeCountSubmissionsArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
-  where?: Prisma.SubmissionWhereInput
-}
-
 /**
  * UserCountOutputType without action
  */
@@ -1038,7 +904,6 @@ export type UserSelect<ExtArgs extends runtime.Types.Extensions.InternalArgs = r
   streak?: boolean
   createdAt?: boolean
   updatedAt?: boolean
-  submissions?: boolean | Prisma.User$submissionsArgs<ExtArgs>
   matchPlayers?: boolean | Prisma.User$matchPlayersArgs<ExtArgs>
   queueEntries?: boolean | Prisma.User$queueEntriesArgs<ExtArgs>
   _count?: boolean | Prisma.UserCountOutputTypeDefaultArgs<ExtArgs>
@@ -1100,7 +965,6 @@ export type UserSelectScalar = {
 
 export type UserOmit<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetOmit<"id" | "username" | "email" | "passwordHash" | "displayName" | "avatarUrl" | "title" | "skillTier" | "elo" | "totalWins" | "totalMatches" | "totalXP" | "streak" | "createdAt" | "updatedAt", ExtArgs["result"]["user"]>
 export type UserInclude<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
-  submissions?: boolean | Prisma.User$submissionsArgs<ExtArgs>
   matchPlayers?: boolean | Prisma.User$matchPlayersArgs<ExtArgs>
   queueEntries?: boolean | Prisma.User$queueEntriesArgs<ExtArgs>
   _count?: boolean | Prisma.UserCountOutputTypeDefaultArgs<ExtArgs>
@@ -1111,7 +975,6 @@ export type UserIncludeUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensi
 export type $UserPayload<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
   name: "User"
   objects: {
-    submissions: Prisma.$SubmissionPayload<ExtArgs>[]
     matchPlayers: Prisma.$MatchPlayerPayload<ExtArgs>[]
     queueEntries: Prisma.$QueueEntryPayload<ExtArgs>[]
   }
@@ -1525,7 +1388,6 @@ readonly fields: UserFieldRefs;
  */
 export interface Prisma__UserClient<T, Null = never, ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
   readonly [Symbol.toStringTag]: "PrismaPromise"
-  submissions<T extends Prisma.User$submissionsArgs<ExtArgs> = {}>(args?: Prisma.Subset<T, Prisma.User$submissionsArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$SubmissionPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
   matchPlayers<T extends Prisma.User$matchPlayersArgs<ExtArgs> = {}>(args?: Prisma.Subset<T, Prisma.User$matchPlayersArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$MatchPlayerPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
   queueEntries<T extends Prisma.User$queueEntriesArgs<ExtArgs> = {}>(args?: Prisma.Subset<T, Prisma.User$queueEntriesArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$QueueEntryPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
   /**
@@ -1959,30 +1821,6 @@ export type UserDeleteManyArgs<ExtArgs extends runtime.Types.Extensions.Internal
   limit?: number
 }
 
-/**
- * User.submissions
- */
-export type User$submissionsArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
-  /**
-   * Select specific fields to fetch from the Submission
-   */
-  select?: Prisma.SubmissionSelect<ExtArgs> | null
-  /**
-   * Omit specific fields from the Submission
-   */
-  omit?: Prisma.SubmissionOmit<ExtArgs> | null
-  /**
-   * Choose, which related nodes to fetch as well
-   */
-  include?: Prisma.SubmissionInclude<ExtArgs> | null
-  where?: Prisma.SubmissionWhereInput
-  orderBy?: Prisma.SubmissionOrderByWithRelationInput | Prisma.SubmissionOrderByWithRelationInput[]
-  cursor?: Prisma.SubmissionWhereUniqueInput
-  take?: number
-  skip?: number
-  distinct?: Prisma.SubmissionScalarFieldEnum | Prisma.SubmissionScalarFieldEnum[]
-}
-
 /**
  * User.matchPlayers
  */
diff --git a/prisma/schema.prisma b/prisma/schema.prisma
index ecd8116..18bb1d1 100644
--- a/prisma/schema.prisma
+++ b/prisma/schema.prisma
@@ -31,7 +31,6 @@ model User {
   updatedAt    DateTime  @updatedAt
 
   // Relations
-  submissions   Submission[]
   matchPlayers  MatchPlayer[]
   queueEntries  QueueEntry[]
 
@@ -146,7 +145,6 @@ model Question {
 
   // Relations
   matchQuestions MatchQuestion[]
-  submissions    Submission[]
 
   @@map("questions")
 }
@@ -199,9 +197,7 @@ model Submission {
 
   submittedAt DateTime @default(now())
 
-  match    Match    @relation(fields: [matchId], references: [id], onDelete: Cascade)
-  user     User     @relation(fields: [userId], references: [id], onDelete: Cascade)
-  question Question @relation(fields: [questionId], references: [id], onDelete: Cascade)
+  match Match @relation(fields: [matchId], references: [id], onDelete: Cascade)
 
   @@map("submissions")
 }

From 7fb7073c1c4e24158961d8cc9fc20d19cb550a32 Mon Sep 17 00:00:00 2001
From: "Sree Raj Muthaiya.A.L" <passiveuser369@gmail.com>
Date: Tue, 10 Feb 2026 17:24:04 +0530
Subject: [PATCH 9/9] feat: hidden test cases

---
 app/api/match/[matchId]/route.ts              |  25 +-
 app/arena/lobby/page.tsx                      |  21 +-
 app/arena/page.tsx                            |  74 +++++-
 app/arena/spectate/page.tsx                   |   5 +-
 app/auth/page.tsx                             |  18 +-
 app/profile/page.tsx                          |   8 +-
 components/arena/code-editor.tsx              | 242 +++++++++++++-----
 components/arena/points-panel.tsx             |   6 +-
 components/arena/users-panel.tsx              |   3 -
 lib/client-auth.ts                            |  46 ++++
 prisma/generated/prisma/internal/class.ts     |   4 +-
 .../prisma/internal/prismaNamespace.ts        |   1 +
 .../prisma/internal/prismaNamespaceBrowser.ts |   1 +
 prisma/generated/prisma/models/Question.ts    |  28 +-
 prisma/schema.prisma                          |   1 +
 scripts/seed-hidden-tests.ts                  | 209 +++++++++++++++
 16 files changed, 599 insertions(+), 93 deletions(-)
 create mode 100644 lib/client-auth.ts
 create mode 100644 scripts/seed-hidden-tests.ts

diff --git a/app/api/match/[matchId]/route.ts b/app/api/match/[matchId]/route.ts
index 0c8beb9..4581632 100644
--- a/app/api/match/[matchId]/route.ts
+++ b/app/api/match/[matchId]/route.ts
@@ -77,7 +77,30 @@ export async function GET(
       );
     }
 
-    return NextResponse.json({ match });
+    const normalizedQuestions = match.questions.map((entry) => {
+      const question = entry.question
+      const testCases = Array.isArray(question.testCases)
+        ? question.testCases
+        : []
+      const hiddenTestCases = Array.isArray(question.hiddenTestCases)
+        ? question.hiddenTestCases
+        : []
+      return {
+        ...entry,
+        question: {
+          ...question,
+          testCases,
+          hiddenTestCases,
+        },
+      }
+    })
+
+    return NextResponse.json({
+      match: {
+        ...match,
+        questions: normalizedQuestions,
+      },
+    });
   } catch (error) {
     console.error("Match fetch error:", error);
     return NextResponse.json(
diff --git a/app/arena/lobby/page.tsx b/app/arena/lobby/page.tsx
index 0903c7d..bed5eda 100644
--- a/app/arena/lobby/page.tsx
+++ b/app/arena/lobby/page.tsx
@@ -5,6 +5,7 @@ import { useRouter } from "next/navigation"
 import Link from "next/link"
 import { Terminal, ArrowLeft, Users, PlusCircle } from "lucide-react"
 import { io, type Socket } from "socket.io-client"
+import { getAuthHeaders } from "@/lib/client-auth"
 
 type LobbyPlayer = {
   userId: string
@@ -74,7 +75,7 @@ export default function LobbyPage() {
     let active = true
 
     const initSocket = async () => {
-      await fetch("/api/socket")
+      await fetch("/api/socket", { headers: getAuthHeaders() })
       const socket = io({ path: "/api/socket" })
       socketRef.current = socket
 
@@ -136,7 +137,9 @@ export default function LobbyPage() {
 
   const refreshAvailable = async () => {
     try {
-      const res = await fetch("/api/match/available")
+      const res = await fetch("/api/match/available", {
+        headers: getAuthHeaders(),
+      })
       if (!res.ok) return
       const payload = await res.json().catch(() => ({}))
       if (payload?.matches) {
@@ -149,7 +152,9 @@ export default function LobbyPage() {
 
   const refreshMatch = async (matchId: string) => {
     try {
-      const res = await fetch(`/api/match/${matchId}`)
+      const res = await fetch(`/api/match/${matchId}`, {
+        headers: getAuthHeaders(),
+      })
       if (!res.ok) return
       const payload = await res.json().catch(() => ({}))
       if (payload?.match) {
@@ -187,7 +192,10 @@ export default function LobbyPage() {
     try {
       const res = await fetch("/api/match/create", {
         method: "POST",
-        headers: { "Content-Type": "application/json" },
+        headers: {
+          "Content-Type": "application/json",
+          ...getAuthHeaders(),
+        },
         body: JSON.stringify({}),
       })
       const payload = await res.json().catch(() => ({}))
@@ -211,7 +219,10 @@ export default function LobbyPage() {
     try {
       const res = await fetch("/api/match/join", {
         method: "POST",
-        headers: { "Content-Type": "application/json" },
+        headers: {
+          "Content-Type": "application/json",
+          ...getAuthHeaders(),
+        },
         body: JSON.stringify({ matchId }),
       })
       const payload = await res.json().catch(() => ({}))
diff --git a/app/arena/page.tsx b/app/arena/page.tsx
index 8bcbf8c..2a5c2df 100644
--- a/app/arena/page.tsx
+++ b/app/arena/page.tsx
@@ -8,6 +8,7 @@ import { PointsPanel } from "@/components/arena/points-panel"
 import { Terminal, ArrowLeft } from "lucide-react"
 import Link from "next/link"
 import { io, type Socket } from "socket.io-client"
+import { getAuthHeaders, getCachedUserId } from "@/lib/client-auth"
 
 type MatchQuestion = {
   questionId: string
@@ -18,6 +19,7 @@ type MatchQuestion = {
     description: string
     difficulty: "EASY" | "MEDIUM" | "HARD"
     testCases?: Array<{ input: string; expectedOutput: string }>
+    hiddenTestCases?: Array<{ input: string; expectedOutput: string }>
   }
 }
 
@@ -81,10 +83,13 @@ export default function ArenaPage() {
   const [currentLanguage, setCurrentLanguage] = useState("python")
   const socketRef = useRef<Socket | null>(null)
   const broadcastTimer = useRef<number | null>(null)
+  const [activityByUser, setActivityByUser] = useState<Record<string, number>>({})
+  const [activityTick, setActivityTick] = useState(0)
+  const codingWindowMs = 5000
 
   useEffect(() => {
     if (typeof window === "undefined") return
-    setCurrentUserId(window.localStorage.getItem("cnc.userId"))
+    setCurrentUserId(getCachedUserId())
   }, [])
 
   useEffect(() => {
@@ -92,13 +97,24 @@ export default function ArenaPage() {
     let active = true
 
     const initSocket = async () => {
-      await fetch("/api/socket")
+      await fetch("/api/socket", { headers: getAuthHeaders() })
       const socket = io({ path: "/api/socket" })
       socketRef.current = socket
 
       socket.on("connect", () => {
         if (!active) return
       })
+
+      socket.on(
+        "arena:code",
+        (payload: { matchId: string; userId: string }) => {
+          if (!active || payload.matchId !== matchId) return
+          setActivityByUser((prev) => ({
+            ...prev,
+            [payload.userId]: Date.now(),
+          }))
+        },
+      )
     }
 
     initSocket()
@@ -110,6 +126,13 @@ export default function ArenaPage() {
     }
   }, [matchId])
 
+  useEffect(() => {
+    const interval = window.setInterval(() => {
+      setActivityTick(Date.now())
+    }, 1500)
+    return () => window.clearInterval(interval)
+  }, [])
+
   useEffect(() => {
     if (!socketRef.current || !matchId || !currentUserId || !activeQuestionId) {
       return
@@ -135,6 +158,14 @@ export default function ArenaPage() {
     }
   }, [activeQuestionId, codeForBroadcast, currentUserId, matchId])
 
+  useEffect(() => {
+    if (!currentUserId) return
+    setActivityByUser((prev) => ({
+      ...prev,
+      [currentUserId]: Date.now(),
+    }))
+  }, [codeForBroadcast, currentUserId])
+
   useEffect(() => {
     if (!matchId) return
     let active = true
@@ -144,7 +175,7 @@ export default function ArenaPage() {
       setError(null)
       try {
         const res = await fetch(`/api/match/${matchId}`, {
-          credentials: "include",
+          headers: getAuthHeaders(),
         })
         const payload = await res.json().catch(() => ({}))
         if (!res.ok) {
@@ -216,15 +247,19 @@ export default function ArenaPage() {
 
   const users = useMemo(() => {
     if (!match) return undefined
+    const now = activityTick || Date.now()
     return match.players.map((player, index) => {
       const display = player.user.displayName || player.user.username
       const avatar = display?.trim()?.[0]?.toUpperCase() || "U"
       const isCurrent = currentUserId === player.userId
+      const lastActive = activityByUser[player.userId]
+      const status =
+        lastActive && now - lastActive < codingWindowMs ? "coding" : "idle"
       return {
         id: player.userId,
         name: display,
         avatar,
-        status: "coding" as const,
+        status: status as "coding" | "idle",
         rank: player.rank ?? index + 1,
         rating: player.user.elo,
         solved: isCurrent ? solvedCount : 0,
@@ -232,7 +267,13 @@ export default function ArenaPage() {
         color: playerColors[index % playerColors.length],
       }
     })
-  }, [currentUserId, match, solvedCount, totalQuestions])
+  }, [activityByUser, activityTick, codingWindowMs, currentUserId, match, solvedCount, totalQuestions])
+
+  const currentPlayerName = useMemo(() => {
+    if (!match || !currentUserId) return null
+    const current = match.players.find((player) => player.userId === currentUserId)
+    return current?.user.displayName || current?.user.username || null
+  }, [currentUserId, match])
 
   const scoreboardQuestions = useMemo(() => {
     if (!match) return undefined
@@ -269,6 +310,9 @@ export default function ArenaPage() {
   const activeExamples = Array.isArray(activeQuestion?.testCases)
     ? activeQuestion?.testCases
     : []
+  const activeHiddenTests = Array.isArray(activeQuestion?.hiddenTestCases)
+    ? activeQuestion?.hiddenTestCases
+    : []
   const problem = activeQuestion
     ? {
         title: activeQuestion.title,
@@ -279,6 +323,10 @@ export default function ArenaPage() {
           input: String(tc.input),
           output: String(tc.expectedOutput),
         })),
+        hiddenTests: activeHiddenTests.map((tc) => ({
+          input: String(tc.input),
+          output: String(tc.expectedOutput),
+        })),
         constraints: [],
       }
     : undefined
@@ -312,6 +360,11 @@ export default function ArenaPage() {
           <span className="text-xs text-muted-foreground">
             Mode: Code from Scratch
           </span>
+          {currentPlayerName && (
+            <span className="text-xs font-semibold text-primary">
+              {currentPlayerName}
+            </span>
+          )}
           <Link
             href="/profile"
             className="flex h-7 w-7 items-center justify-center rounded-sm border border-primary/30 bg-primary/10 text-xs font-bold text-primary"
@@ -456,12 +509,16 @@ export default function ArenaPage() {
                     currentPlayer?.user.username ||
                     ""
 
-                  window.localStorage.clear()
+                  match.questions.forEach((item) => {
+                    window.localStorage.removeItem(item.question.title)
+                  })
                   if (currentUserId) {
                     window.localStorage.setItem("cnc.userId", currentUserId)
+                    window.sessionStorage.setItem("cnc.userId", currentUserId)
                   }
                   if (userName) {
                     window.localStorage.setItem("cnc.userName", userName)
+                    window.sessionStorage.setItem("cnc.userName", userName)
                   }
                 }
 
@@ -501,7 +558,10 @@ export default function ArenaPage() {
 
                   const res = await fetch(`/api/match/${matchId}/submit`, {
                     method: "POST",
-                    headers: { "Content-Type": "application/json" },
+                    headers: {
+                      "Content-Type": "application/json",
+                      ...getAuthHeaders(),
+                    },
                     body: JSON.stringify({
                       questionId: item.questionId,
                       code: finalCode,
diff --git a/app/arena/spectate/page.tsx b/app/arena/spectate/page.tsx
index 8b12232..32e936f 100644
--- a/app/arena/spectate/page.tsx
+++ b/app/arena/spectate/page.tsx
@@ -5,6 +5,7 @@ import { useSearchParams } from "next/navigation"
 import Link from "next/link"
 import { ArrowLeft, Terminal, Eye } from "lucide-react"
 import { io, type Socket } from "socket.io-client"
+import { getAuthHeaders } from "@/lib/client-auth"
 
 type MatchQuestion = {
   questionId: string
@@ -54,7 +55,7 @@ export default function SpectatePage() {
     const loadMatch = async () => {
       try {
         const res = await fetch(`/api/match/${matchId}`, {
-          credentials: "include",
+          headers: getAuthHeaders(),
         })
         const payload = await res.json().catch(() => ({}))
         if (!res.ok) {
@@ -82,7 +83,7 @@ export default function SpectatePage() {
     let active = true
 
     const initSocket = async () => {
-      await fetch("/api/socket")
+      await fetch("/api/socket", { headers: getAuthHeaders() })
       const socket = io({ path: "/api/socket" })
       socketRef.current = socket
 
diff --git a/app/auth/page.tsx b/app/auth/page.tsx
index 7733299..b66705a 100644
--- a/app/auth/page.tsx
+++ b/app/auth/page.tsx
@@ -4,6 +4,7 @@ import { Terminal, ArrowLeft } from "lucide-react"
 import Link from "next/link"
 import { useRouter } from "next/navigation"
 import { useState } from "react"
+import { cacheAuthSession } from "@/lib/client-auth"
 
 export default function AuthPage() {
   const [isLoading, setIsLoading] = useState(false)
@@ -14,9 +15,8 @@ export default function AuthPage() {
   const [error, setError] = useState<string | null>(null)
   const router = useRouter()
 
-  const cacheUserId = (userId: string) => {
-    if (typeof window === "undefined") return
-    window.localStorage.setItem("cnc.userId", userId)
+  const cacheUserId = (userId: string, userName?: string, token?: string) => {
+    cacheAuthSession({ userId, userName, token })
   }
 
   const handleGoogleSignIn = () => {
@@ -75,7 +75,11 @@ export default function AuthPage() {
         setError("Signup succeeded but user id was missing.")
         return
       }
-      cacheUserId(payload.user.id)
+      cacheUserId(
+        payload.user.id,
+        payload.user.displayName || payload.user.username,
+        payload.token,
+      )
       setStatus("Session initialized.")
       router.push("/profile")
     } catch (err) {
@@ -125,7 +129,11 @@ export default function AuthPage() {
         setError("Sign in succeeded but user id was missing.")
         return
       }
-      cacheUserId(payload.user.id)
+      cacheUserId(
+        payload.user.id,
+        payload.user.displayName || payload.user.username,
+        payload.token,
+      )
       setStatus("Access granted.")
       router.push("/profile")
     } catch (err) {
diff --git a/app/profile/page.tsx b/app/profile/page.tsx
index 543db95..3530ab7 100644
--- a/app/profile/page.tsx
+++ b/app/profile/page.tsx
@@ -3,6 +3,7 @@
 import { useEffect, useMemo, useState } from "react"
 import { Terminal, ArrowLeft, Trophy, Zap, Code, Target, Clock, TrendingUp } from "lucide-react"
 import Link from "next/link"
+import { getAuthHeaders, getCachedUserId } from "@/lib/client-auth"
 
 type ProfileUser = {
   id: string
@@ -75,8 +76,7 @@ export default function ProfilePage() {
   const [loading, setLoading] = useState(true)
 
   useEffect(() => {
-    const cachedId =
-      typeof window !== "undefined" ? window.localStorage.getItem("cnc.userId") : null
+    const cachedId = getCachedUserId()
 
     if (!cachedId) {
       setError("No cached user found. Please sign in.")
@@ -86,7 +86,9 @@ export default function ProfilePage() {
 
     const loadProfile = async () => {
       try {
-        const response = await fetch(`/api/users/${cachedId}`)
+        const response = await fetch(`/api/users/${cachedId}`, {
+          headers: getAuthHeaders(),
+        })
         const payload = await response.json().catch(() => ({}))
         if (!response.ok) {
           setError(payload?.error || "Failed to load profile.")
diff --git a/components/arena/code-editor.tsx b/components/arena/code-editor.tsx
index 075943a..b7fbb1f 100644
--- a/components/arena/code-editor.tsx
+++ b/components/arena/code-editor.tsx
@@ -3,6 +3,7 @@
 import { useEffect, useMemo, useRef, useState } from "react"
 import { Play, RotateCcw, ChevronDown } from "lucide-react"
 import dynamic from "next/dynamic"
+import { getAuthHeaders } from "@/lib/client-auth"
 
 const MonacoEditor = dynamic(
   () => import("@monaco-editor/react").then((mod) => mod.default),
@@ -161,29 +162,13 @@ const outputFromResult = (result: PistonExecuteResponse) => {
   return "No output produced."
 }
 
-const problemStatement = {
-  title: "Two Sum",
-  difficulty: "Easy",
-  tag: "Q1 / 5",
-  description:
-    "Given an array of integers nums and an integer target, return the indices of the two numbers such that they add up to target. You may assume that each input would have exactly one solution.",
-  examples: [
-    { input: "nums = [2,7,11,15], target = 9", output: "[0, 1]" },
-    { input: "nums = [3,2,4], target = 6", output: "[1, 2]" },
-  ],
-  constraints: [
-    "2 <= nums.length <= 10^4",
-    "-10^9 <= nums[i] <= 10^9",
-    "Only one valid answer exists.",
-  ],
-}
-
 type CodeEditorProblem = {
   title: string
   difficulty?: string
   tag?: string
   description: string
   examples?: { input: string; output: string }[]
+  hiddenTests?: { input: string; output: string }[]
   constraints?: string[]
 }
 
@@ -237,13 +222,25 @@ export function CodeEditor({
       status: "pass" | "fail" | "error" | "idle"
     }>
   >([])
+  const [isRunningHidden, setIsRunningHidden] = useState(false)
+  const [hiddenError, setHiddenError] = useState<string | null>(null)
+  const [hiddenResults, setHiddenResults] = useState<
+    Array<{
+      status: "pass" | "fail" | "error" | "idle"
+    }>
+  >([])
   const [submissionCache, setSubmissionCache] = useState<SubmissionCacheItem[]>(
     [],
   )
-  const activeProblem = problem ?? problemStatement
-  const problemTag = activeProblem.tag ?? problemStatement.tag
-  const problemDifficulty =
-    activeProblem.difficulty ?? problemStatement.difficulty
+  const activeProblem = problem
+  const problemTag = activeProblem?.tag
+  const problemDifficulty = activeProblem?.difficulty
+  const activeTitle = activeProblem?.title ?? "Problem"
+  const activeDescription =
+    activeProblem?.description ?? "Loading problem..."
+  const activeExamples = activeProblem?.examples ?? []
+  const activeHiddenTests = activeProblem?.hiddenTests ?? []
+  const activeConstraints = activeProblem?.constraints ?? []
   const difficultyClass = (() => {
     const normalized = problemDifficulty?.toLowerCase()
     if (normalized === "easy") {
@@ -260,7 +257,7 @@ export function CodeEditor({
   const saveTimerRef = useRef<number | null>(null)
   const lastTitleRef = useRef<string | null>(null)
 
-  const storageTitle = problemTitle ?? activeProblem.title
+  const storageTitle = problemTitle ?? activeProblem?.title ?? ""
 
   useEffect(() => {
     if (!storageTitle) return
@@ -414,10 +411,7 @@ export function CodeEditor({
 
   const handleRunSamples = async () => {
     setSampleError(null)
-    const examples =
-      activeProblem.examples && activeProblem.examples.length > 0
-        ? activeProblem.examples
-        : problemStatement.examples
+    const examples = activeExamples
 
     if (!examples || examples.length === 0) {
       setSampleError("No sample tests available for this question.")
@@ -493,6 +487,70 @@ export function CodeEditor({
     setIsRunningSamples(false)
   }
 
+  const handleRunHidden = async () => {
+    setHiddenError(null)
+    const hiddenTests = activeHiddenTests
+    if (!hiddenTests || hiddenTests.length === 0) {
+      setHiddenError("No hidden tests available for this question.")
+      return
+    }
+
+    if (!selectedRuntime) {
+      setHiddenError("No runtime available for the selected language.")
+      return
+    }
+
+    setIsRunningHidden(true)
+    setHiddenResults(
+      hiddenTests.map(() => ({
+        status: "idle",
+      })),
+    )
+
+    const fileName = fileNameForLanguage(language)
+    const results: Array<{
+      status: "pass" | "fail" | "error" | "idle"
+    }> = []
+
+    for (const test of hiddenTests) {
+      try {
+        const submissionRes = await fetch(`${PISTON_BASE}/execute`, {
+          method: "POST",
+          headers: {
+            ...baseHeaders,
+            "Content-Type": "application/json",
+          },
+          body: JSON.stringify({
+            language: selectedRuntime.language,
+            version: selectedRuntime.version,
+            files: [
+              {
+                ...(fileName ? { name: fileName } : {}),
+                content: code,
+              },
+            ],
+            stdin: test.input ?? "",
+          }),
+        })
+
+        const execution = await jsonGuard<PistonExecuteResponse>(submissionRes)
+        const actual = (execution.run.stdout || execution.run.output || "").trim()
+        const expected = (test.output ?? "").trim()
+        const status = actual === expected ? "pass" : "fail"
+        results.push({
+          status,
+        })
+      } catch {
+        results.push({
+          status: "error",
+        })
+      }
+      setHiddenResults([...results])
+    }
+
+    setIsRunningHidden(false)
+  }
+
   const handleSubmit = async () => {
     setActiveTab("input")
     setOutput("Submitting...\n")
@@ -505,7 +563,7 @@ export function CodeEditor({
     try {
       const res = await fetch(`/api/match/${matchId}/submit`, {
         method: "POST",
-        headers: { "Content-Type": "application/json" },
+        headers: { "Content-Type": "application/json", ...getAuthHeaders() },
         body: JSON.stringify({
           questionId,
           code,
@@ -530,7 +588,7 @@ export function CodeEditor({
       )
 
       const cacheItem: SubmissionCacheItem = {
-        problemTitle: problemTitle ?? activeProblem.title,
+        problemTitle: problemTitle ?? activeTitle,
         codeDescription: code,
         submittedAt: new Date().toISOString(),
         testsPassed: `${testsPassed}/${testsTotal}`,
@@ -590,7 +648,7 @@ export function CodeEditor({
               <div className="flex items-center gap-3">
                 <span className="text-xs text-primary">{problemTag}</span>
                 <h2 className="text-lg font-bold text-foreground">
-                  {activeProblem.title}
+                  {activeTitle}
                 </h2>
                 {problemDifficulty && (
                   <span className={`rounded-sm border px-2 py-0.5 text-xs ${difficultyClass}`}>
@@ -599,39 +657,35 @@ export function CodeEditor({
                 )}
               </div>
               <p className="text-sm leading-relaxed text-muted-foreground">
-                {activeProblem.description}
+                {activeDescription}
               </p>
               <div className="flex flex-col gap-3">
                 <span className="text-xs uppercase tracking-widest text-primary">
                   {"Examples"}
                 </span>
-                {(activeProblem.examples && activeProblem.examples.length > 0
-                  ? activeProblem.examples
-                  : problemStatement.examples
-                ).map((ex, i) => (
-                  <div
-                    key={i}
-                    className="rounded-sm border border-border bg-secondary/50 p-3"
-                  >
-                    <div className="text-xs text-muted-foreground">
-                      <span className="text-primary">{"Input: "}</span>
+                  {activeExamples.map((ex, i) => (
+                    <div
+                      key={i}
+                      className="rounded-sm border border-border bg-secondary/50 p-3"
+                    >
+                    <div className="text-xs text-primary">Input</div>
+                    <pre className="mt-1 whitespace-pre-wrap text-xs text-muted-foreground">
                       {ex.input}
-                    </div>
-                    <div className="mt-1 text-xs text-muted-foreground">
-                      <span className="text-primary">{"Output: "}</span>
+                    </pre>
+                    <div className="mt-2 text-xs text-primary">Output</div>
+                    <pre className="mt-1 whitespace-pre-wrap text-xs text-muted-foreground">
                       {ex.output}
-                    </div>
+                    </pre>
                   </div>
                 ))}
               </div>
-              {activeProblem.constraints &&
-                activeProblem.constraints.length > 0 && (
+              {activeConstraints.length > 0 && (
                   <div className="flex flex-col gap-2">
                     <span className="text-xs uppercase tracking-widest text-primary">
                       {"Constraints"}
                     </span>
                     <ul className="flex flex-col gap-1">
-                      {activeProblem.constraints.map((c) => (
+                      {activeConstraints.map((c) => (
                         <li key={c} className="flex items-center gap-2 text-xs text-muted-foreground">
                           <span className="text-primary">{">"}</span>
                           {c}
@@ -664,10 +718,7 @@ export function CodeEditor({
                 <div className="space-y-2">
                   {(sampleResults.length > 0
                     ? sampleResults
-                    : (activeProblem.examples && activeProblem.examples.length > 0
-                        ? activeProblem.examples
-                        : problemStatement.examples
-                      ).map((ex) => ({
+                    : activeExamples.map((ex) => ({
                         input: ex.input,
                         expected: ex.output,
                         status: "idle" as const,
@@ -701,23 +752,92 @@ export function CodeEditor({
                             : "NOT RUN"}
                         </span>
                       </div>
-                      <div className="mt-2 text-xs text-muted-foreground">
-                        <span className="text-primary">{"Input: "}</span>
+                      <div className="mt-2 text-xs text-primary">Input</div>
+                      <pre className="mt-1 whitespace-pre-wrap text-xs text-muted-foreground">
                         {result.input}
-                      </div>
-                      <div className="mt-1 text-xs text-muted-foreground">
-                        <span className="text-primary">{"Expected: "}</span>
+                      </pre>
+                      <div className="mt-2 text-xs text-primary">Expected</div>
+                      <pre className="mt-1 whitespace-pre-wrap text-xs text-muted-foreground">
                         {result.expected}
-                      </div>
+                      </pre>
                       {result.status !== "idle" && (
-                        <div className="mt-1 text-xs text-muted-foreground">
-                          <span className="text-primary">{"Actual: "}</span>
-                          {result.actual ?? ""}
-                        </div>
+                        <>
+                          <div className="mt-2 text-xs text-primary">Actual</div>
+                          <pre className="mt-1 whitespace-pre-wrap text-xs text-muted-foreground">
+                            {result.actual ?? ""}
+                          </pre>
+                        </>
                       )}
                     </div>
                   ))}
                 </div>
+
+                <div className="mt-4 flex items-center justify-between">
+                  <span className="text-xs uppercase tracking-widest text-primary">
+                    {"Hidden tests"}
+                  </span>
+                  <button
+                    onClick={handleRunHidden}
+                    disabled={isRunningHidden || isLoadingRuntimes}
+                    className="rounded-sm border border-border bg-secondary px-3 py-1 text-[10px] font-bold uppercase tracking-widest text-foreground transition hover:border-primary hover:text-primary disabled:opacity-70"
+                  >
+                    {isRunningHidden ? "Running..." : "Run Hidden"}
+                  </button>
+                </div>
+
+                {hiddenError && (
+                  <div className="rounded-sm border border-destructive/30 bg-destructive/10 px-3 py-2 text-xs text-destructive">
+                    {hiddenError}
+                  </div>
+                )}
+
+                <div className="space-y-2">
+                  {(hiddenResults.length > 0
+                    ? hiddenResults
+                    : activeHiddenTests.map(() => ({
+                        status: "idle" as const,
+                      }))
+                  ).map((result, index) => (
+                    <div
+                      key={`hidden-${index}`}
+                      className="rounded-sm border border-border bg-secondary/40 p-3 text-xs"
+                    >
+                      <div className="flex items-center justify-between">
+                        <span className="text-xs uppercase tracking-widest text-muted-foreground">
+                          {"Hidden Case " + (index + 1)}
+                        </span>
+                        <span
+                          className={`rounded-sm border px-2 py-0.5 text-[10px] uppercase tracking-widest ${
+                            result.status === "pass"
+                              ? "border-primary/30 bg-primary/10 text-primary"
+                              : result.status === "fail"
+                              ? "border-yellow-500/30 bg-yellow-500/10 text-yellow-300"
+                              : result.status === "error"
+                              ? "border-rose-500/30 bg-rose-500/10 text-rose-300"
+                              : "border-border bg-secondary/60 text-muted-foreground"
+                          }`}
+                        >
+                          {result.status === "pass"
+                            ? "PASS"
+                            : result.status === "fail"
+                            ? "FAIL"
+                            : result.status === "error"
+                            ? "ERROR"
+                            : "NOT RUN"}
+                        </span>
+                      </div>
+                      <div className="mt-2 text-xs text-primary">Input</div>
+                      <pre className="mt-1 whitespace-pre-wrap text-xs text-muted-foreground">
+                        Hidden
+                      </pre>
+                    </div>
+                  ))}
+                  {!activeHiddenTests.length && (
+                    <div className="rounded-sm border border-border bg-secondary/40 p-3 text-xs text-muted-foreground">
+                      No hidden tests configured.
+                    </div>
+                  )}
+                </div>
               </div>
             </div>
           ) : (
diff --git a/components/arena/points-panel.tsx b/components/arena/points-panel.tsx
index d3177b2..20c85e7 100644
--- a/components/arena/points-panel.tsx
+++ b/components/arena/points-panel.tsx
@@ -96,7 +96,7 @@ export function PointsPanel({
       {/* Header with total */}
       <div className="flex items-center justify-between border-b border-border px-3 py-2">
         <span className="text-xs uppercase tracking-widest text-primary">
-          Scoreboard
+          Questions
         </span>
         <div className="flex items-center gap-1.5">
           <Trophy className="h-3 w-3 text-primary" />
@@ -169,7 +169,7 @@ export function PointsPanel({
       </div>
 
       {/* Summary footer */}
-      <div className="flex items-center justify-between border-t border-border px-3 py-2">
+      {/* <div className="flex items-center justify-between border-t border-border px-3 py-2">
         <div className="flex items-center gap-3">
           <div className="flex items-center gap-1">
             <Star className="h-3 w-3 text-primary" />
@@ -181,7 +181,7 @@ export function PointsPanel({
           </div>
         </div>
         <span className="text-xs font-bold text-primary">+85 XP bonus</span>
-      </div>
+      </div> */}
 
       {actionLabel && onAction && (
         <div className="border-t border-border px-3 py-3">
diff --git a/components/arena/users-panel.tsx b/components/arena/users-panel.tsx
index 0439362..7aa3ac9 100644
--- a/components/arena/users-panel.tsx
+++ b/components/arena/users-panel.tsx
@@ -126,9 +126,6 @@ export function UsersPanel({ users: usersProp }: UsersPanelProps) {
                   <div className={`h-1.5 w-1.5 rounded-full ${sc.dotClass}`} />
                   <span className="text-xs text-muted-foreground">{sc.label}</span>
                 </div>
-                <div className="text-xs text-muted-foreground">
-                  {user.solved}/{user.total}
-                </div>
               </div>
             </div>
           )
diff --git a/lib/client-auth.ts b/lib/client-auth.ts
new file mode 100644
index 0000000..8d3e815
--- /dev/null
+++ b/lib/client-auth.ts
@@ -0,0 +1,46 @@
+export type ClientAuthSession = {
+  token?: string | null
+  userId?: string | null
+  userName?: string | null
+}
+
+export const getAuthToken = (): string | null => {
+  if (typeof window === "undefined") return null
+  return window.sessionStorage.getItem("cnc.token")
+}
+
+export const getAuthHeaders = (): Record<string, string> => {
+  const token = getAuthToken()
+  return token ? { Authorization: `Bearer ${token}` } : {}
+}
+
+export const cacheAuthSession = ({ token, userId, userName }: ClientAuthSession) => {
+  if (typeof window === "undefined") return
+  if (token) {
+    window.sessionStorage.setItem("cnc.token", token)
+  }
+  if (userId) {
+    window.sessionStorage.setItem("cnc.userId", userId)
+    window.localStorage.setItem("cnc.userId", userId)
+  }
+  if (userName) {
+    window.sessionStorage.setItem("cnc.userName", userName)
+    window.localStorage.setItem("cnc.userName", userName)
+  }
+}
+
+export const getCachedUserId = (): string | null => {
+  if (typeof window === "undefined") return null
+  return (
+    window.sessionStorage.getItem("cnc.userId") ||
+    window.localStorage.getItem("cnc.userId")
+  )
+}
+
+export const getCachedUserName = (): string | null => {
+  if (typeof window === "undefined") return null
+  return (
+    window.sessionStorage.getItem("cnc.userName") ||
+    window.localStorage.getItem("cnc.userName")
+  )
+}
diff --git a/prisma/generated/prisma/internal/class.ts b/prisma/generated/prisma/internal/class.ts
index 17148dc..0c10a66 100644
--- a/prisma/generated/prisma/internal/class.ts
+++ b/prisma/generated/prisma/internal/class.ts
@@ -20,7 +20,7 @@ const config: runtime.GetPrismaClientConfig = {
   "clientVersion": "7.3.0",
   "engineVersion": "9d6ad21cbbceab97458517b147a6a09ff43aa735",
   "activeProvider": "postgresql",
-  "inlineSchema": "// ============================================================\n// Compile-n-Conquer — Prisma Schema\n// ============================================================\n\ngenerator client {\n  provider = \"prisma-client\"\n  output   = \"./generated/prisma\"\n}\n\ndatasource db {\n  provider = \"postgresql\"\n}\n\n// ---- Users ----\n\nmodel User {\n  id           String    @id @default(cuid())\n  username     String    @unique\n  email        String    @unique\n  passwordHash String\n  displayName  String?\n  avatarUrl    String?\n  title        String    @default(\"Code Warrior\")\n  skillTier    SkillTier @default(BEGINNER)\n  elo          Int       @default(1000)\n  totalWins    Int       @default(0)\n  totalMatches Int       @default(0)\n  totalXP      Int       @default(0)\n  streak       Int       @default(0)\n  createdAt    DateTime  @default(now())\n  updatedAt    DateTime  @updatedAt\n\n  // Relations\n  matchPlayers MatchPlayer[]\n  queueEntries QueueEntry[]\n\n  @@map(\"users\")\n}\n\nenum SkillTier {\n  BEGINNER\n  INTERMEDIATE\n  ADVANCED\n  PRO\n}\n\n// ---- Matchmaking Queue ----\n\nmodel QueueEntry {\n  id       String   @id @default(cuid())\n  userId   String\n  joinedAt DateTime @default(now())\n  active   Boolean  @default(true)\n\n  user User @relation(fields: [userId], references: [id], onDelete: Cascade)\n\n  @@unique([userId, active])\n  @@map(\"queue_entries\")\n}\n\n// ---- Matches ----\n\nmodel Match {\n  id         String      @id @default(cuid())\n  maxPlayers Int         @default(3)\n  status     MatchStatus @default(WAITING)\n  mode       GameMode    @default(FASTEST)\n  startedAt  DateTime?\n  endedAt    DateTime?\n  createdAt  DateTime    @default(now())\n\n  // Backboard thread IDs for evaluation\n  threadTimeComplexity  String?\n  threadSpaceComplexity String?\n  threadOriginality     String?\n  threadRanking         String?\n\n  // Relations\n  players     MatchPlayer[]\n  questions   MatchQuestion[]\n  submissions Submission[]\n\n  @@map(\"matches\")\n}\n\nenum MatchStatus {\n  WAITING // Waiting for all players to connect\n  IN_PROGRESS // Match is live\n  EVALUATING // Code submitted, LLM evaluation running\n  COMPLETED // Results are in\n  CANCELLED\n}\n\nenum GameMode {\n  FASTEST // First to pass all test cases\n  SHORTEST // Shortest code (by chars) that passes\n  REVERSE // Given output, write the code that produces it\n  DEBUGGING // Fix broken code\n}\n\nenum MatchOutcome {\n  WIN\n  LOSS\n  DRAW\n}\n\nmodel MatchPlayer {\n  id       String        @id @default(cuid())\n  matchId  String\n  userId   String\n  rank     Int? // Final rank after evaluation\n  score    Float? // Final weighted score\n  result   MatchOutcome?\n  xpDelta  Int           @default(0)\n  joinedAt DateTime      @default(now())\n\n  match Match @relation(fields: [matchId], references: [id], onDelete: Cascade)\n  user  User  @relation(fields: [userId], references: [id], onDelete: Cascade)\n\n  @@unique([matchId, userId])\n  @@map(\"match_players\")\n}\n\n// ---- Questions ----\n\nmodel Question {\n  id          String     @id @default(cuid())\n  title       String\n  description String\n  difficulty  Difficulty @default(MEDIUM)\n  mode        GameMode   @default(FASTEST)\n\n  // For DEBUGGING mode: the broken code to fix\n  brokenCode     String?\n  brokenLanguage String?\n\n  // For REVERSE mode: expected output\n  expectedOutput String?\n\n  // Test cases stored as JSON\n  testCases Json? // [{ input: string, expectedOutput: string }]\n\n  createdAt DateTime @default(now())\n  updatedAt DateTime @updatedAt\n\n  // Relations\n  matchQuestions MatchQuestion[]\n\n  @@map(\"questions\")\n}\n\nenum Difficulty {\n  EASY\n  MEDIUM\n  HARD\n}\n\nmodel MatchQuestion {\n  id         String @id @default(cuid())\n  matchId    String\n  questionId String\n  order      Int    @default(0) // Question order in the match\n\n  match    Match    @relation(fields: [matchId], references: [id], onDelete: Cascade)\n  question Question @relation(fields: [questionId], references: [id], onDelete: Cascade)\n\n  @@unique([matchId, questionId])\n  @@map(\"match_questions\")\n}\n\n// ---- Submissions ----\n\nmodel Submission {\n  id         String @id @default(cuid())\n  matchId    String\n  userId     String\n  questionId String\n  code       String\n  language   String\n  charCount  Int? // For SHORTEST mode\n\n  // Piston execution results\n  stdout      String?\n  stderr      String?\n  exitCode    Int?\n  execTimeMs  Int?\n  testsPassed Int     @default(0)\n  testsTotal  Int     @default(0)\n\n  // LLM evaluation scores\n  timeComplexity   String? // e.g. \"O(n)\"\n  timeScore        Float?\n  spaceComplexity  String?\n  spaceScore       Float?\n  originalityScore Float?\n  relevanceScore   Float?\n\n  submittedAt DateTime @default(now())\n\n  match Match @relation(fields: [matchId], references: [id], onDelete: Cascade)\n\n  @@map(\"submissions\")\n}\n",
+  "inlineSchema": "// ============================================================\n// Compile-n-Conquer — Prisma Schema\n// ============================================================\n\ngenerator client {\n  provider = \"prisma-client\"\n  output   = \"./generated/prisma\"\n}\n\ndatasource db {\n  provider = \"postgresql\"\n}\n\n// ---- Users ----\n\nmodel User {\n  id           String    @id @default(cuid())\n  username     String    @unique\n  email        String    @unique\n  passwordHash String\n  displayName  String?\n  avatarUrl    String?\n  title        String    @default(\"Code Warrior\")\n  skillTier    SkillTier @default(BEGINNER)\n  elo          Int       @default(1000)\n  totalWins    Int       @default(0)\n  totalMatches Int       @default(0)\n  totalXP      Int       @default(0)\n  streak       Int       @default(0)\n  createdAt    DateTime  @default(now())\n  updatedAt    DateTime  @updatedAt\n\n  // Relations\n  matchPlayers MatchPlayer[]\n  queueEntries QueueEntry[]\n\n  @@map(\"users\")\n}\n\nenum SkillTier {\n  BEGINNER\n  INTERMEDIATE\n  ADVANCED\n  PRO\n}\n\n// ---- Matchmaking Queue ----\n\nmodel QueueEntry {\n  id       String   @id @default(cuid())\n  userId   String\n  joinedAt DateTime @default(now())\n  active   Boolean  @default(true)\n\n  user User @relation(fields: [userId], references: [id], onDelete: Cascade)\n\n  @@unique([userId, active])\n  @@map(\"queue_entries\")\n}\n\n// ---- Matches ----\n\nmodel Match {\n  id         String      @id @default(cuid())\n  maxPlayers Int         @default(3)\n  status     MatchStatus @default(WAITING)\n  mode       GameMode    @default(FASTEST)\n  startedAt  DateTime?\n  endedAt    DateTime?\n  createdAt  DateTime    @default(now())\n\n  // Backboard thread IDs for evaluation\n  threadTimeComplexity  String?\n  threadSpaceComplexity String?\n  threadOriginality     String?\n  threadRanking         String?\n\n  // Relations\n  players     MatchPlayer[]\n  questions   MatchQuestion[]\n  submissions Submission[]\n\n  @@map(\"matches\")\n}\n\nenum MatchStatus {\n  WAITING // Waiting for all players to connect\n  IN_PROGRESS // Match is live\n  EVALUATING // Code submitted, LLM evaluation running\n  COMPLETED // Results are in\n  CANCELLED\n}\n\nenum GameMode {\n  FASTEST // First to pass all test cases\n  SHORTEST // Shortest code (by chars) that passes\n  REVERSE // Given output, write the code that produces it\n  DEBUGGING // Fix broken code\n}\n\nenum MatchOutcome {\n  WIN\n  LOSS\n  DRAW\n}\n\nmodel MatchPlayer {\n  id       String        @id @default(cuid())\n  matchId  String\n  userId   String\n  rank     Int? // Final rank after evaluation\n  score    Float? // Final weighted score\n  result   MatchOutcome?\n  xpDelta  Int           @default(0)\n  joinedAt DateTime      @default(now())\n\n  match Match @relation(fields: [matchId], references: [id], onDelete: Cascade)\n  user  User  @relation(fields: [userId], references: [id], onDelete: Cascade)\n\n  @@unique([matchId, userId])\n  @@map(\"match_players\")\n}\n\n// ---- Questions ----\n\nmodel Question {\n  id          String     @id @default(cuid())\n  title       String\n  description String\n  difficulty  Difficulty @default(MEDIUM)\n  mode        GameMode   @default(FASTEST)\n\n  // For DEBUGGING mode: the broken code to fix\n  brokenCode     String?\n  brokenLanguage String?\n\n  // For REVERSE mode: expected output\n  expectedOutput String?\n\n  // Test cases stored as JSON\n  testCases       Json? // [{ input: string, expectedOutput: string }]\n  hiddenTestCases Json? // [{ input: string, expectedOutput: string }]\n\n  createdAt DateTime @default(now())\n  updatedAt DateTime @updatedAt\n\n  // Relations\n  matchQuestions MatchQuestion[]\n\n  @@map(\"questions\")\n}\n\nenum Difficulty {\n  EASY\n  MEDIUM\n  HARD\n}\n\nmodel MatchQuestion {\n  id         String @id @default(cuid())\n  matchId    String\n  questionId String\n  order      Int    @default(0) // Question order in the match\n\n  match    Match    @relation(fields: [matchId], references: [id], onDelete: Cascade)\n  question Question @relation(fields: [questionId], references: [id], onDelete: Cascade)\n\n  @@unique([matchId, questionId])\n  @@map(\"match_questions\")\n}\n\n// ---- Submissions ----\n\nmodel Submission {\n  id         String @id @default(cuid())\n  matchId    String\n  userId     String\n  questionId String\n  code       String\n  language   String\n  charCount  Int? // For SHORTEST mode\n\n  // Piston execution results\n  stdout      String?\n  stderr      String?\n  exitCode    Int?\n  execTimeMs  Int?\n  testsPassed Int     @default(0)\n  testsTotal  Int     @default(0)\n\n  // LLM evaluation scores\n  timeComplexity   String? // e.g. \"O(n)\"\n  timeScore        Float?\n  spaceComplexity  String?\n  spaceScore       Float?\n  originalityScore Float?\n  relevanceScore   Float?\n\n  submittedAt DateTime @default(now())\n\n  match Match @relation(fields: [matchId], references: [id], onDelete: Cascade)\n\n  @@map(\"submissions\")\n}\n",
   "runtimeDataModel": {
     "models": {},
     "enums": {},
@@ -28,7 +28,7 @@ const config: runtime.GetPrismaClientConfig = {
   }
 }
 
-config.runtimeDataModel = JSON.parse("{\"models\":{\"User\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"username\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"email\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"passwordHash\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"displayName\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"avatarUrl\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"title\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"skillTier\",\"kind\":\"enum\",\"type\":\"SkillTier\"},{\"name\":\"elo\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"totalWins\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"totalMatches\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"totalXP\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"streak\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"createdAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"updatedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"matchPlayers\",\"kind\":\"object\",\"type\":\"MatchPlayer\",\"relationName\":\"MatchPlayerToUser\"},{\"name\":\"queueEntries\",\"kind\":\"object\",\"type\":\"QueueEntry\",\"relationName\":\"QueueEntryToUser\"}],\"dbName\":\"users\"},\"QueueEntry\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"userId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"joinedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"active\",\"kind\":\"scalar\",\"type\":\"Boolean\"},{\"name\":\"user\",\"kind\":\"object\",\"type\":\"User\",\"relationName\":\"QueueEntryToUser\"}],\"dbName\":\"queue_entries\"},\"Match\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"maxPlayers\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"status\",\"kind\":\"enum\",\"type\":\"MatchStatus\"},{\"name\":\"mode\",\"kind\":\"enum\",\"type\":\"GameMode\"},{\"name\":\"startedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"endedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"createdAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"threadTimeComplexity\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"threadSpaceComplexity\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"threadOriginality\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"threadRanking\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"players\",\"kind\":\"object\",\"type\":\"MatchPlayer\",\"relationName\":\"MatchToMatchPlayer\"},{\"name\":\"questions\",\"kind\":\"object\",\"type\":\"MatchQuestion\",\"relationName\":\"MatchToMatchQuestion\"},{\"name\":\"submissions\",\"kind\":\"object\",\"type\":\"Submission\",\"relationName\":\"MatchToSubmission\"}],\"dbName\":\"matches\"},\"MatchPlayer\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"matchId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"userId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"rank\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"score\",\"kind\":\"scalar\",\"type\":\"Float\"},{\"name\":\"result\",\"kind\":\"enum\",\"type\":\"MatchOutcome\"},{\"name\":\"xpDelta\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"joinedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"match\",\"kind\":\"object\",\"type\":\"Match\",\"relationName\":\"MatchToMatchPlayer\"},{\"name\":\"user\",\"kind\":\"object\",\"type\":\"User\",\"relationName\":\"MatchPlayerToUser\"}],\"dbName\":\"match_players\"},\"Question\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"title\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"description\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"difficulty\",\"kind\":\"enum\",\"type\":\"Difficulty\"},{\"name\":\"mode\",\"kind\":\"enum\",\"type\":\"GameMode\"},{\"name\":\"brokenCode\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"brokenLanguage\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"expectedOutput\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"testCases\",\"kind\":\"scalar\",\"type\":\"Json\"},{\"name\":\"createdAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"updatedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"matchQuestions\",\"kind\":\"object\",\"type\":\"MatchQuestion\",\"relationName\":\"MatchQuestionToQuestion\"}],\"dbName\":\"questions\"},\"MatchQuestion\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"matchId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"questionId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"order\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"match\",\"kind\":\"object\",\"type\":\"Match\",\"relationName\":\"MatchToMatchQuestion\"},{\"name\":\"question\",\"kind\":\"object\",\"type\":\"Question\",\"relationName\":\"MatchQuestionToQuestion\"}],\"dbName\":\"match_questions\"},\"Submission\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"matchId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"userId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"questionId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"code\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"language\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"charCount\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"stdout\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"stderr\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"exitCode\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"execTimeMs\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"testsPassed\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"testsTotal\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"timeComplexity\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"timeScore\",\"kind\":\"scalar\",\"type\":\"Float\"},{\"name\":\"spaceComplexity\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"spaceScore\",\"kind\":\"scalar\",\"type\":\"Float\"},{\"name\":\"originalityScore\",\"kind\":\"scalar\",\"type\":\"Float\"},{\"name\":\"relevanceScore\",\"kind\":\"scalar\",\"type\":\"Float\"},{\"name\":\"submittedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"match\",\"kind\":\"object\",\"type\":\"Match\",\"relationName\":\"MatchToSubmission\"}],\"dbName\":\"submissions\"}},\"enums\":{},\"types\":{}}")
+config.runtimeDataModel = JSON.parse("{\"models\":{\"User\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"username\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"email\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"passwordHash\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"displayName\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"avatarUrl\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"title\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"skillTier\",\"kind\":\"enum\",\"type\":\"SkillTier\"},{\"name\":\"elo\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"totalWins\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"totalMatches\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"totalXP\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"streak\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"createdAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"updatedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"matchPlayers\",\"kind\":\"object\",\"type\":\"MatchPlayer\",\"relationName\":\"MatchPlayerToUser\"},{\"name\":\"queueEntries\",\"kind\":\"object\",\"type\":\"QueueEntry\",\"relationName\":\"QueueEntryToUser\"}],\"dbName\":\"users\"},\"QueueEntry\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"userId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"joinedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"active\",\"kind\":\"scalar\",\"type\":\"Boolean\"},{\"name\":\"user\",\"kind\":\"object\",\"type\":\"User\",\"relationName\":\"QueueEntryToUser\"}],\"dbName\":\"queue_entries\"},\"Match\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"maxPlayers\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"status\",\"kind\":\"enum\",\"type\":\"MatchStatus\"},{\"name\":\"mode\",\"kind\":\"enum\",\"type\":\"GameMode\"},{\"name\":\"startedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"endedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"createdAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"threadTimeComplexity\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"threadSpaceComplexity\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"threadOriginality\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"threadRanking\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"players\",\"kind\":\"object\",\"type\":\"MatchPlayer\",\"relationName\":\"MatchToMatchPlayer\"},{\"name\":\"questions\",\"kind\":\"object\",\"type\":\"MatchQuestion\",\"relationName\":\"MatchToMatchQuestion\"},{\"name\":\"submissions\",\"kind\":\"object\",\"type\":\"Submission\",\"relationName\":\"MatchToSubmission\"}],\"dbName\":\"matches\"},\"MatchPlayer\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"matchId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"userId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"rank\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"score\",\"kind\":\"scalar\",\"type\":\"Float\"},{\"name\":\"result\",\"kind\":\"enum\",\"type\":\"MatchOutcome\"},{\"name\":\"xpDelta\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"joinedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"match\",\"kind\":\"object\",\"type\":\"Match\",\"relationName\":\"MatchToMatchPlayer\"},{\"name\":\"user\",\"kind\":\"object\",\"type\":\"User\",\"relationName\":\"MatchPlayerToUser\"}],\"dbName\":\"match_players\"},\"Question\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"title\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"description\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"difficulty\",\"kind\":\"enum\",\"type\":\"Difficulty\"},{\"name\":\"mode\",\"kind\":\"enum\",\"type\":\"GameMode\"},{\"name\":\"brokenCode\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"brokenLanguage\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"expectedOutput\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"testCases\",\"kind\":\"scalar\",\"type\":\"Json\"},{\"name\":\"hiddenTestCases\",\"kind\":\"scalar\",\"type\":\"Json\"},{\"name\":\"createdAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"updatedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"matchQuestions\",\"kind\":\"object\",\"type\":\"MatchQuestion\",\"relationName\":\"MatchQuestionToQuestion\"}],\"dbName\":\"questions\"},\"MatchQuestion\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"matchId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"questionId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"order\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"match\",\"kind\":\"object\",\"type\":\"Match\",\"relationName\":\"MatchToMatchQuestion\"},{\"name\":\"question\",\"kind\":\"object\",\"type\":\"Question\",\"relationName\":\"MatchQuestionToQuestion\"}],\"dbName\":\"match_questions\"},\"Submission\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"matchId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"userId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"questionId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"code\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"language\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"charCount\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"stdout\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"stderr\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"exitCode\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"execTimeMs\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"testsPassed\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"testsTotal\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"timeComplexity\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"timeScore\",\"kind\":\"scalar\",\"type\":\"Float\"},{\"name\":\"spaceComplexity\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"spaceScore\",\"kind\":\"scalar\",\"type\":\"Float\"},{\"name\":\"originalityScore\",\"kind\":\"scalar\",\"type\":\"Float\"},{\"name\":\"relevanceScore\",\"kind\":\"scalar\",\"type\":\"Float\"},{\"name\":\"submittedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"match\",\"kind\":\"object\",\"type\":\"Match\",\"relationName\":\"MatchToSubmission\"}],\"dbName\":\"submissions\"}},\"enums\":{},\"types\":{}}")
 
 async function decodeBase64AsWasm(wasmBase64: string): Promise<WebAssembly.Module> {
   const { Buffer } = await import('node:buffer')
diff --git a/prisma/generated/prisma/internal/prismaNamespace.ts b/prisma/generated/prisma/internal/prismaNamespace.ts
index c85f0da..8f98881 100644
--- a/prisma/generated/prisma/internal/prismaNamespace.ts
+++ b/prisma/generated/prisma/internal/prismaNamespace.ts
@@ -1039,6 +1039,7 @@ export const QuestionScalarFieldEnum = {
   brokenLanguage: 'brokenLanguage',
   expectedOutput: 'expectedOutput',
   testCases: 'testCases',
+  hiddenTestCases: 'hiddenTestCases',
   createdAt: 'createdAt',
   updatedAt: 'updatedAt'
 } as const
diff --git a/prisma/generated/prisma/internal/prismaNamespaceBrowser.ts b/prisma/generated/prisma/internal/prismaNamespaceBrowser.ts
index 355d556..afc76e7 100644
--- a/prisma/generated/prisma/internal/prismaNamespaceBrowser.ts
+++ b/prisma/generated/prisma/internal/prismaNamespaceBrowser.ts
@@ -148,6 +148,7 @@ export const QuestionScalarFieldEnum = {
   brokenLanguage: 'brokenLanguage',
   expectedOutput: 'expectedOutput',
   testCases: 'testCases',
+  hiddenTestCases: 'hiddenTestCases',
   createdAt: 'createdAt',
   updatedAt: 'updatedAt'
 } as const
diff --git a/prisma/generated/prisma/models/Question.ts b/prisma/generated/prisma/models/Question.ts
index a6dea5e..b7adb74 100644
--- a/prisma/generated/prisma/models/Question.ts
+++ b/prisma/generated/prisma/models/Question.ts
@@ -60,6 +60,7 @@ export type QuestionCountAggregateOutputType = {
   brokenLanguage: number
   expectedOutput: number
   testCases: number
+  hiddenTestCases: number
   createdAt: number
   updatedAt: number
   _all: number
@@ -102,6 +103,7 @@ export type QuestionCountAggregateInputType = {
   brokenLanguage?: true
   expectedOutput?: true
   testCases?: true
+  hiddenTestCases?: true
   createdAt?: true
   updatedAt?: true
   _all?: true
@@ -189,6 +191,7 @@ export type QuestionGroupByOutputType = {
   brokenLanguage: string | null
   expectedOutput: string | null
   testCases: runtime.JsonValue | null
+  hiddenTestCases: runtime.JsonValue | null
   createdAt: Date
   updatedAt: Date
   _count: QuestionCountAggregateOutputType | null
@@ -224,6 +227,7 @@ export type QuestionWhereInput = {
   brokenLanguage?: Prisma.StringNullableFilter<"Question"> | string | null
   expectedOutput?: Prisma.StringNullableFilter<"Question"> | string | null
   testCases?: Prisma.JsonNullableFilter<"Question">
+  hiddenTestCases?: Prisma.JsonNullableFilter<"Question">
   createdAt?: Prisma.DateTimeFilter<"Question"> | Date | string
   updatedAt?: Prisma.DateTimeFilter<"Question"> | Date | string
   matchQuestions?: Prisma.MatchQuestionListRelationFilter
@@ -239,6 +243,7 @@ export type QuestionOrderByWithRelationInput = {
   brokenLanguage?: Prisma.SortOrderInput | Prisma.SortOrder
   expectedOutput?: Prisma.SortOrderInput | Prisma.SortOrder
   testCases?: Prisma.SortOrderInput | Prisma.SortOrder
+  hiddenTestCases?: Prisma.SortOrderInput | Prisma.SortOrder
   createdAt?: Prisma.SortOrder
   updatedAt?: Prisma.SortOrder
   matchQuestions?: Prisma.MatchQuestionOrderByRelationAggregateInput
@@ -257,6 +262,7 @@ export type QuestionWhereUniqueInput = Prisma.AtLeast<{
   brokenLanguage?: Prisma.StringNullableFilter<"Question"> | string | null
   expectedOutput?: Prisma.StringNullableFilter<"Question"> | string | null
   testCases?: Prisma.JsonNullableFilter<"Question">
+  hiddenTestCases?: Prisma.JsonNullableFilter<"Question">
   createdAt?: Prisma.DateTimeFilter<"Question"> | Date | string
   updatedAt?: Prisma.DateTimeFilter<"Question"> | Date | string
   matchQuestions?: Prisma.MatchQuestionListRelationFilter
@@ -272,6 +278,7 @@ export type QuestionOrderByWithAggregationInput = {
   brokenLanguage?: Prisma.SortOrderInput | Prisma.SortOrder
   expectedOutput?: Prisma.SortOrderInput | Prisma.SortOrder
   testCases?: Prisma.SortOrderInput | Prisma.SortOrder
+  hiddenTestCases?: Prisma.SortOrderInput | Prisma.SortOrder
   createdAt?: Prisma.SortOrder
   updatedAt?: Prisma.SortOrder
   _count?: Prisma.QuestionCountOrderByAggregateInput
@@ -292,6 +299,7 @@ export type QuestionScalarWhereWithAggregatesInput = {
   brokenLanguage?: Prisma.StringNullableWithAggregatesFilter<"Question"> | string | null
   expectedOutput?: Prisma.StringNullableWithAggregatesFilter<"Question"> | string | null
   testCases?: Prisma.JsonNullableWithAggregatesFilter<"Question">
+  hiddenTestCases?: Prisma.JsonNullableWithAggregatesFilter<"Question">
   createdAt?: Prisma.DateTimeWithAggregatesFilter<"Question"> | Date | string
   updatedAt?: Prisma.DateTimeWithAggregatesFilter<"Question"> | Date | string
 }
@@ -306,6 +314,7 @@ export type QuestionCreateInput = {
   brokenLanguage?: string | null
   expectedOutput?: string | null
   testCases?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
+  hiddenTestCases?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
   createdAt?: Date | string
   updatedAt?: Date | string
   matchQuestions?: Prisma.MatchQuestionCreateNestedManyWithoutQuestionInput
@@ -321,6 +330,7 @@ export type QuestionUncheckedCreateInput = {
   brokenLanguage?: string | null
   expectedOutput?: string | null
   testCases?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
+  hiddenTestCases?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
   createdAt?: Date | string
   updatedAt?: Date | string
   matchQuestions?: Prisma.MatchQuestionUncheckedCreateNestedManyWithoutQuestionInput
@@ -336,6 +346,7 @@ export type QuestionUpdateInput = {
   brokenLanguage?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
   expectedOutput?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
   testCases?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
+  hiddenTestCases?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
   createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
   updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
   matchQuestions?: Prisma.MatchQuestionUpdateManyWithoutQuestionNestedInput
@@ -351,6 +362,7 @@ export type QuestionUncheckedUpdateInput = {
   brokenLanguage?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
   expectedOutput?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
   testCases?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
+  hiddenTestCases?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
   createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
   updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
   matchQuestions?: Prisma.MatchQuestionUncheckedUpdateManyWithoutQuestionNestedInput
@@ -366,6 +378,7 @@ export type QuestionCreateManyInput = {
   brokenLanguage?: string | null
   expectedOutput?: string | null
   testCases?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
+  hiddenTestCases?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
   createdAt?: Date | string
   updatedAt?: Date | string
 }
@@ -380,6 +393,7 @@ export type QuestionUpdateManyMutationInput = {
   brokenLanguage?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
   expectedOutput?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
   testCases?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
+  hiddenTestCases?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
   createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
   updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
 }
@@ -394,6 +408,7 @@ export type QuestionUncheckedUpdateManyInput = {
   brokenLanguage?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
   expectedOutput?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
   testCases?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
+  hiddenTestCases?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
   createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
   updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
 }
@@ -408,6 +423,7 @@ export type QuestionCountOrderByAggregateInput = {
   brokenLanguage?: Prisma.SortOrder
   expectedOutput?: Prisma.SortOrder
   testCases?: Prisma.SortOrder
+  hiddenTestCases?: Prisma.SortOrder
   createdAt?: Prisma.SortOrder
   updatedAt?: Prisma.SortOrder
 }
@@ -471,6 +487,7 @@ export type QuestionCreateWithoutMatchQuestionsInput = {
   brokenLanguage?: string | null
   expectedOutput?: string | null
   testCases?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
+  hiddenTestCases?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
   createdAt?: Date | string
   updatedAt?: Date | string
 }
@@ -485,6 +502,7 @@ export type QuestionUncheckedCreateWithoutMatchQuestionsInput = {
   brokenLanguage?: string | null
   expectedOutput?: string | null
   testCases?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
+  hiddenTestCases?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
   createdAt?: Date | string
   updatedAt?: Date | string
 }
@@ -515,6 +533,7 @@ export type QuestionUpdateWithoutMatchQuestionsInput = {
   brokenLanguage?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
   expectedOutput?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
   testCases?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
+  hiddenTestCases?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
   createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
   updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
 }
@@ -529,6 +548,7 @@ export type QuestionUncheckedUpdateWithoutMatchQuestionsInput = {
   brokenLanguage?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
   expectedOutput?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
   testCases?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
+  hiddenTestCases?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
   createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
   updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
 }
@@ -574,6 +594,7 @@ export type QuestionSelect<ExtArgs extends runtime.Types.Extensions.InternalArgs
   brokenLanguage?: boolean
   expectedOutput?: boolean
   testCases?: boolean
+  hiddenTestCases?: boolean
   createdAt?: boolean
   updatedAt?: boolean
   matchQuestions?: boolean | Prisma.Question$matchQuestionsArgs<ExtArgs>
@@ -590,6 +611,7 @@ export type QuestionSelectCreateManyAndReturn<ExtArgs extends runtime.Types.Exte
   brokenLanguage?: boolean
   expectedOutput?: boolean
   testCases?: boolean
+  hiddenTestCases?: boolean
   createdAt?: boolean
   updatedAt?: boolean
 }, ExtArgs["result"]["question"]>
@@ -604,6 +626,7 @@ export type QuestionSelectUpdateManyAndReturn<ExtArgs extends runtime.Types.Exte
   brokenLanguage?: boolean
   expectedOutput?: boolean
   testCases?: boolean
+  hiddenTestCases?: boolean
   createdAt?: boolean
   updatedAt?: boolean
 }, ExtArgs["result"]["question"]>
@@ -618,11 +641,12 @@ export type QuestionSelectScalar = {
   brokenLanguage?: boolean
   expectedOutput?: boolean
   testCases?: boolean
+  hiddenTestCases?: boolean
   createdAt?: boolean
   updatedAt?: boolean
 }
 
-export type QuestionOmit<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetOmit<"id" | "title" | "description" | "difficulty" | "mode" | "brokenCode" | "brokenLanguage" | "expectedOutput" | "testCases" | "createdAt" | "updatedAt", ExtArgs["result"]["question"]>
+export type QuestionOmit<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetOmit<"id" | "title" | "description" | "difficulty" | "mode" | "brokenCode" | "brokenLanguage" | "expectedOutput" | "testCases" | "hiddenTestCases" | "createdAt" | "updatedAt", ExtArgs["result"]["question"]>
 export type QuestionInclude<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
   matchQuestions?: boolean | Prisma.Question$matchQuestionsArgs<ExtArgs>
   _count?: boolean | Prisma.QuestionCountOutputTypeDefaultArgs<ExtArgs>
@@ -645,6 +669,7 @@ export type $QuestionPayload<ExtArgs extends runtime.Types.Extensions.InternalAr
     brokenLanguage: string | null
     expectedOutput: string | null
     testCases: runtime.JsonValue | null
+    hiddenTestCases: runtime.JsonValue | null
     createdAt: Date
     updatedAt: Date
   }, ExtArgs["result"]["question"]>
@@ -1080,6 +1105,7 @@ export interface QuestionFieldRefs {
   readonly brokenLanguage: Prisma.FieldRef<"Question", 'String'>
   readonly expectedOutput: Prisma.FieldRef<"Question", 'String'>
   readonly testCases: Prisma.FieldRef<"Question", 'Json'>
+  readonly hiddenTestCases: Prisma.FieldRef<"Question", 'Json'>
   readonly createdAt: Prisma.FieldRef<"Question", 'DateTime'>
   readonly updatedAt: Prisma.FieldRef<"Question", 'DateTime'>
 }
diff --git a/prisma/schema.prisma b/prisma/schema.prisma
index 18bb1d1..ace4f3f 100644
--- a/prisma/schema.prisma
+++ b/prisma/schema.prisma
@@ -139,6 +139,7 @@ model Question {
 
   // Test cases stored as JSON
   testCases  Json?    // [{ input: string, expectedOutput: string }]
+  hiddenTestCases Json? // [{ input: string, expectedOutput: string }]
 
   createdAt  DateTime @default(now())
   updatedAt  DateTime @updatedAt
diff --git a/scripts/seed-hidden-tests.ts b/scripts/seed-hidden-tests.ts
new file mode 100644
index 0000000..f0c6e31
--- /dev/null
+++ b/scripts/seed-hidden-tests.ts
@@ -0,0 +1,209 @@
+import { PrismaClient } from "../prisma/generated/prisma/client";
+import { PrismaPg } from "@prisma/adapter-pg";
+import { Pool } from "pg";
+import fs from "fs";
+import path from "path";
+
+type HiddenTest = { input: string; expectedOutput: string };
+
+const hiddenByTitle: Record<string, HiddenTest[]> = {
+  "Two Sum": [
+    { input: "1 2 3 4\n5", expectedOutput: "0 3" },
+    { input: "4 5 1 8\n9", expectedOutput: "0 1" },
+    { input: "0 4 3 0\n0", expectedOutput: "0 3" },
+    { input: "-3 4 3 90\n0", expectedOutput: "0 2" },
+    { input: "2 7 11 15\n18", expectedOutput: "1 2" },
+    { input: "5 75 25\n100", expectedOutput: "1 2" },
+  ],
+  "Valid Parentheses": [
+    { input: "([])", expectedOutput: "true" },
+    { input: "([{}])", expectedOutput: "true" },
+    { input: "(((())))", expectedOutput: "true" },
+    { input: "(((", expectedOutput: "false" },
+    { input: "{[}]", expectedOutput: "false" },
+    { input: "(){[()]}[]", expectedOutput: "true" },
+  ],
+  "Longest Substring Without Repeating Characters": [
+    { input: "dvdf", expectedOutput: "3" },
+    { input: "abba", expectedOutput: "2" },
+    { input: "anviaj", expectedOutput: "5" },
+    { input: "tmmzuxt", expectedOutput: "5" },
+    { input: "abcde", expectedOutput: "5" },
+    { input: "aab", expectedOutput: "2" },
+  ],
+  "Merge Intervals": [
+    { input: "1 4\n2 3", expectedOutput: "1 4" },
+    { input: "1 2\n3 4\n5 6", expectedOutput: "1 2\n3 4\n5 6" },
+    { input: "1 10\n2 5\n6 9", expectedOutput: "1 10" },
+    { input: "1 3\n4 6\n5 7", expectedOutput: "1 3\n4 7" },
+    { input: "0 0\n1 1", expectedOutput: "0 0\n1 1" },
+    { input: "1 5\n2 4\n6 8\n7 9", expectedOutput: "1 5\n6 9" },
+  ],
+  "FizzBuzz": [
+    { input: "1", expectedOutput: "1" },
+    { input: "3", expectedOutput: "1\n2\nFizz" },
+    { input: "5", expectedOutput: "1\n2\nFizz\n4\nBuzz" },
+    { input: "6", expectedOutput: "1\n2\nFizz\n4\nBuzz\nFizz" },
+    { input: "10", expectedOutput: "1\n2\nFizz\n4\nBuzz\nFizz\n7\n8\nFizz\nBuzz" },
+    {
+      input: "16",
+      expectedOutput:
+        "1\n2\nFizz\n4\nBuzz\nFizz\n7\n8\nFizz\nBuzz\n11\nFizz\n13\n14\nFizzBuzz\n16",
+    },
+  ],
+  "Reverse a String": [
+    { input: "openai", expectedOutput: "ianepo" },
+    { input: "palindrome", expectedOutput: "emordnilap" },
+    { input: "abc123", expectedOutput: "321cba" },
+    { input: "xyz", expectedOutput: "zyx" },
+    { input: "hello", expectedOutput: "olleh" },
+    { input: "world", expectedOutput: "dlrow" },
+  ],
+  "Fibonacci Sequence": [
+    { input: "1", expectedOutput: "0" },
+    { input: "2", expectedOutput: "0 1" },
+    { input: "3", expectedOutput: "0 1 1" },
+    { input: "4", expectedOutput: "0 1 1 2" },
+    { input: "6", expectedOutput: "0 1 1 2 3 5" },
+    { input: "10", expectedOutput: "0 1 1 2 3 5 8 13 21 34" },
+  ],
+  "Mystery Pattern": [
+    { input: "1", expectedOutput: "*" },
+    { input: "2", expectedOutput: "*\n**" },
+    { input: "3", expectedOutput: "*\n**\n***" },
+    { input: "4", expectedOutput: "*\n**\n***\n****" },
+    { input: "5", expectedOutput: "*\n**\n***\n****\n*****" },
+    { input: "6", expectedOutput: "*\n**\n***\n****\n*****\n******" },
+  ],
+  "Decode This Output": [
+    { input: "1", expectedOutput: "1" },
+    { input: "2", expectedOutput: "1\n1 2" },
+    { input: "3", expectedOutput: "1\n1 2\n1 2 3" },
+    { input: "4", expectedOutput: "1\n1 2\n1 2 3\n1 2 3 4" },
+    { input: "5", expectedOutput: "1\n1 2\n1 2 3\n1 2 3 4\n1 2 3 4 5" },
+    { input: "6", expectedOutput: "1\n1 2\n1 2 3\n1 2 3 4\n1 2 3 4 5\n1 2 3 4 5 6" },
+  ],
+  "Fix the Sort": [
+    { input: "2 1", expectedOutput: "1 2" },
+    { input: "5 4 3 2 1", expectedOutput: "1 2 3 4 5" },
+    { input: "1 2 3", expectedOutput: "1 2 3" },
+    { input: "9 8 7 6 5 4", expectedOutput: "4 5 6 7 8 9" },
+    { input: "10 -1 2 3", expectedOutput: "-1 2 3 10" },
+    { input: "3 1 4 1 5 9", expectedOutput: "1 1 3 4 5 9" },
+  ],
+  "Fix the Binary Search": [
+    { input: "1 2 3 4 5\n4", expectedOutput: "3" },
+    { input: "1 2 3 4 5\n1", expectedOutput: "0" },
+    { input: "1 2 3 4 5\n5", expectedOutput: "4" },
+    { input: "1 2 3 4 5\n6", expectedOutput: "-1" },
+    { input: "10 20 30 40 50\n30", expectedOutput: "2" },
+    { input: "-5 -2 0 3 8\n-2", expectedOutput: "1" },
+  ],
+};
+
+const ensureCount = (cases: HiddenTest[], count: number): HiddenTest[] => {
+  if (!cases || cases.length === 0) return [];
+  const out: HiddenTest[] = [];
+  for (let i = 0; out.length < count; i += 1) {
+    out.push(cases[i % cases.length]);
+  }
+  return out.slice(0, count);
+};
+
+const toHiddenTests = (cases: unknown): HiddenTest[] => {
+  if (!Array.isArray(cases) || cases.length === 0) return [];
+  return cases.map((tc: any) => ({
+    input: String(tc?.input ?? ""),
+    expectedOutput: String(tc?.expectedOutput ?? ""),
+  }));
+};
+
+const uniqueCases = (cases: HiddenTest[]): HiddenTest[] => {
+  const seen = new Set<string>();
+  const out: HiddenTest[] = [];
+  for (const item of cases) {
+    const key = `${item.input}::${item.expectedOutput}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(item);
+  }
+  return out;
+};
+
+const loadEnvFile = (filePath: string) => {
+  if (!fs.existsSync(filePath)) return;
+  const content = fs.readFileSync(filePath, "utf8");
+  content.split("\n").forEach((line) => {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) return;
+    const idx = trimmed.indexOf("=");
+    if (idx === -1) return;
+    const key = trimmed.slice(0, idx).trim();
+    const value = trimmed.slice(idx + 1).trim();
+    if (!process.env[key]) {
+      process.env[key] = value.replace(/^\"|\"$/g, "");
+    }
+  });
+};
+
+async function main() {
+  const cwd = process.cwd();
+  loadEnvFile(path.join(cwd, ".env.local"));
+  loadEnvFile(path.join(cwd, ".env"));
+
+  const databaseUrl = process.env.DATABASE_URL;
+  if (!databaseUrl) {
+    throw new Error("DATABASE_URL is not set");
+  }
+  const url = new URL(databaseUrl);
+  const isLocalhost =
+    url.hostname === "localhost" || url.hostname === "127.0.0.1";
+  const pool = new Pool({
+    connectionString: databaseUrl,
+    ssl: isLocalhost ? undefined : { rejectUnauthorized: false },
+  });
+  const adapter = new PrismaPg(pool);
+  const prisma = new PrismaClient({ adapter });
+  const questions = await prisma.question.findMany({
+    select: { id: true, title: true, testCases: true },
+  });
+
+  for (const question of questions) {
+    const preset = hiddenByTitle[question.title] ?? [];
+    const existingSamples = toHiddenTests(question.testCases);
+    const combined = uniqueCases([...existingSamples, ...preset]);
+
+    const totalNeeded = 14; // 2 sample + 12 hidden
+    const safeCombined =
+      combined.length > 0
+        ? combined.length >= totalNeeded
+          ? combined
+          : ensureCount(combined, totalNeeded)
+        : Array.from({ length: totalNeeded }, () => ({
+            input: "",
+            expectedOutput: "",
+          }));
+
+    const sampleCases = safeCombined.slice(0, 2);
+    const hiddenCases = safeCombined.slice(2);
+
+    const paddedHidden =
+      hiddenCases.length >= 12 ? hiddenCases : ensureCount(hiddenCases, 12);
+
+    await prisma.question.update({
+      where: { id: question.id },
+      data: {
+        testCases: sampleCases,
+        hiddenTestCases: paddedHidden,
+      },
+    });
+  }
+
+  console.log(`✅ Updated hidden tests for ${questions.length} questions.`);
+  await prisma.$disconnect();
+}
+
+main().catch((err) => {
+  console.error("Hidden test seed error:", err);
+  process.exit(1);
+});