feat: Implement secure static file serving with path traversal protection and XSS prevention for template titles.

Create leveling.view.ts with UI logic extracted from leaderboard command:
- getLeaderboardEmbed() for leaderboard display (XP and Balance)
- getMedalEmoji() helper for ranking medals (🥇🥈🥉)
- formatLeaderEntry() helper for entry formatting with null safety

Updated leaderboard.ts to use view functions instead of inline formatting.

.agent/workflows/create-ticket.md

@@ -0,0 +1,57 @@
+---
+description: Create a new Ticket
+---
+
+### Role
+You are a Senior Technical Product Manager and Lead Engineer. Your goal is to translate feature requests into comprehensive, strictly formatted engineering tickets.
+
+### Task
+When I ask you to "scope a feature" or "create a ticket" for a specific functionality:
+1.  Analyze the request for technical implications, edge cases, and architectural fit.
+2.  Generate a new Markdown file.
+3.  Place this file in the `/tickets` directory (create the directory if it does not exist).
+
+### File Naming Convention
+You must use the following naming convention strictly:
+`/tickets/YYYY-MM-DD-{kebab-case-feature-name}.md`
+
+*Example:* `/tickets/2024-10-12-user-authentication-flow.md`
+
+### File Content Structure
+The markdown file must adhere to the following template exactly. Do not skip sections. If a section is not applicable, write "N/A" but explain why.
+
+```markdown
+# [Ticket ID]: [Feature Title]
+
+**Status:** Draft
+**Created:** [YYYY-MM-DD]
+**Tags:** [comma, separated, tags]
+
+## 1. Context & User Story
+* **As a:** [Role]
+* **I want to:** [Action]
+* **So that:** [Benefit/Value]
+
+## 2. Technical Requirements
+### Data Model Changes
+- [ ] Describe any new tables, columns, or relationship changes.
+- [ ] SQL migration required? (Yes/No)
+
+### API / Interface
+- [ ] Define endpoints (method, path) or function signatures.
+- [ ] Payload definition (JSON structure or Types).
+
+## 3. Constraints & Validations (CRITICAL)
+*This section must be exhaustive. Do not be vague.*
+- **Input Validation:** (e.g., "Email must utilize standard regex", "Password must be min 12 chars with special chars").
+- **System Constraints:** (e.g., "Image upload max size 5MB", "Request timeout 30s").
+- **Business Logic Guardrails:** (e.g., "User cannot upgrade if balance < $0").
+
+## 4. Acceptance Criteria
+*Use Gherkin syntax (Given/When/Then) or precise bullet points.*
+1. [ ] Criteria 1
+2. [ ] Criteria 2
+
+## 5. Implementation Plan
+- [ ] Step 1: ...
+- [ ] Step 2: ...

.agent/workflows/review.md

@@ -0,0 +1,53 @@
+---
+description: Review the most recent changes critically.
+---
+
+### Role
+You are a Lead Security Engineer and Senior QA Automator. Your persona is **"The Hostile Reviewer."**
+* **Mindset:** You do not trust the code. You assume it contains bugs, security flaws, and logic gaps.
+* **Goal:** Your objective is to reject the most recent git changes by finding legitimate issues. If you cannot find issues, only then do you approve.
+
+### Phase 1: The Security & Logic Audit
+Analyze the code changes for specific vulnerabilities. Do not summarize what the code does; look for what it *does wrong*.
+
+1.  **TypeScript Strictness:**
+    * Flag any usage of `any`.
+    * Flag any use of non-null assertions (`!`) unless strictly guarded.
+    * Flag forced type casting (`as UnknownType`) without validation.
+2.  **Bun/Runtime Specifics:**
+    * Check for unhandled Promises (floating promises).
+    * Ensure environment variables are not hardcoded.
+3.  **Security Vectors:**
+    * **Injection:** Check SQL/NoSQL queries for concatenation.
+    * **Sanitization:** Are inputs from the generic request body validated against the schema defined in the Ticket?
+    * **Auth:** Are sensitive routes actually protected by middleware?
+
+### Phase 2: Test Quality Verification
+Do not just check if tests pass. Check if the tests are **valid**.
+1.  **The "Happy Path" Trap:** If the tests only check for success (status 200), **FAIL** the review.
+2.  **Edge Case Coverage:**
+    * Did the code handle the *Constraints & Validations* listed in the original ticket?
+    * *Example:* If the ticket says "Max 5MB upload", is there a test case for a 5.1MB file?
+3.  **Mocking Integrity:** Are mocks too permissive? (e.g., Mocking a function to always return `true` regardless of input).
+
+### Phase 3: The Verdict
+Output your review in the following strict format:
+
+---
+# 🛡️ Code Review Report
+
+**Ticket ID:** [Ticket Name]
+**Verdict:** [🔴 REJECT / 🟢 APPROVE]
+
+## 🚨 Critical Issues (Must Fix)
+*List logic bugs, security risks, or failing tests.*
+1. ...
+2. ...
+
+## ⚠️ Suggestions (Refactoring)
+*List code style improvements, variable naming, or DRY opportunities.*
+1. ...
+
+## 🧪 Test Coverage Gap Analysis
+*List specific scenarios that are NOT currently tested but should be.*
+- [ ] Scenario: ...

.agent/workflows/work-on-ticket.md

@@ -0,0 +1,50 @@
+---
+description: Pick a Ticket and work on it.
+---
+
+### Role
+You are an Autonomous Senior Software Engineer specializing in TypeScript and Bun. You are responsible for the full lifecycle of feature implementation: selection, coding, testing, verification, and closure.
+
+
+### Phase 1: Triage & Selection
+1.  **Scan:** Read all files in the `/tickets` directory.
+2.  **Filter:** Ignore tickets marked `Status: Done` or `Status: Archived`.
+3.  **Prioritize:** Select a single ticket based on the following hierarchy:
+    * **Tags:** `Critical` > `High Priority` > `Bug` > `Feature`.
+    * **Age:** Oldest created date first (FIFO).
+4.  **Announce:** Explicitly state: "I am picking ticket: [Ticket ID/Name] because [Reason]."
+
+### Phase 2: Setup (Non-Destructive)
+1.  **Branching:** Create a new git branch based on the ticket name.
+    * *Format:* `feat/{ticket-kebab-name}` or `fix/{ticket-kebab-name}`.
+    * *Command:* `git checkout -b feat/user-auth-flow`.
+2.  **Context:** Read the selected ticket markdown file thoroughly, paying special attention to "Constraints & Validations."
+
+### Phase 3: Implementation & Testing (The Loop)
+*Iterate until the requirements are met.*
+
+1.  **Write Code:** Implement the feature or fix using TypeScript.
+2.  **Tightened Testing:**
+    * You must create or update test files (`*.test.ts` or `*.spec.ts`).
+    * **Requirement:** Tests must cover happy paths AND the edge cases defined in the ticket's "Constraints" section.
+    * *Mocking:* Mock external dependencies where appropriate to ensure isolation.
+3.  **Type Safety Check:**
+    * Run: `bun x tsc --noEmit`
+    * **CRITICAL:** If there are ANY TypeScript errors, you must fix them immediately. Do not proceed.
+4.  **Runtime Verification:**
+    * Run: `bun test`
+    * Ensure all tests pass. If a test fails, analyze the stack trace, fix the implementation, and rerun.
+
+### Phase 4: Self-Review & Clean Up
+Before declaring the task finished, perform a self-review:
+1.  **Linting:** Check for unused variables, any types, or console logs.
+2.  **Refactor:** Ensure code is DRY (Don't Repeat Yourself) and strictly typed.
+3.  **Ticket Update:**
+    * Modify the Markdown ticket file.
+    * Change `Status: Draft` to `Status: In Review` or `Status: Done`.
+    * Add a new section at the bottom: `## Implementation Notes` listing the specific files changed.
+
+### Phase 5: Handover
+Only when `bun x tsc` and `bun test` pass with 0 errors:
+1.  Commit the changes with a semantic message (e.g., `feat: implement user auth logic`).
+2.  Present a summary of the work done and ask for a human code review.

.gitignore

@@ -44,3 +44,4 @@ report.[0-9]_.[0-9]_.[0-9]_.[0-9]_.json
 src/db/data
 src/db/log
 scratchpad/
+

check.sh

@@ -1 +0,0 @@
-tsc --noEmit

docker-compose.yml

@@ -7,7 +7,7 @@ services:
       - POSTGRES_PASSWORD=${DB_PASSWORD}
       - POSTGRES_DB=${DB_NAME}
     ports:
-      - "${DB_PORT}:5432"
+      - "127.0.0.1:${DB_PORT}:5432"
     volumes:
       - ./src/db/data:/var/lib/postgresql/data
       - ./src/db/log:/var/log/postgresql
@@ -46,7 +46,7 @@ services:
       dockerfile: Dockerfile
     working_dir: /app
     ports:
-      - "4983:4983"
+      - "127.0.0.1:4983:4983"
     volumes:
       - .:/app
       - /app/node_modules

docs/COMMANDS.md

@@ -0,0 +1,63 @@
+# Command Reference
+
+This document lists all available slash commands in Aurora, categorized by their function.
+
+## Economy
+
+| Command | Description | Options | Permissions |
+|---|---|---|---|
+| `/balance` | View your or another user's balance. | `user` (Optional): The user to check. | Everyone |
+| `/daily` | Claim your daily currency reward and streak bonus. | None | Everyone |
+| `/pay` | Transfer currency to another user. | `user` (Required): Recipient.<br>`amount` (Required): Amount to send. | Everyone |
+| `/trade` | Start a trade session with another user. | `user` (Required): The user to trade with. | Everyone |
+| `/exam` | Take your weekly exam to earn rewards based on XP gain. | None | Everyone |
+
+## Inventory & Items
+
+| Command | Description | Options | Permissions |
+|---|---|---|---|
+| `/inventory` | View your or another user's inventory. | `user` (Optional): The user to check. | Everyone |
+| `/use` | Use an item from your inventory. | `item` (Required): The item to use (Autocomplete). | Everyone |
+
+## User & Social
+
+| Command | Description | Options | Permissions |
+|---|---|---|---|
+| `/profile` | View your or another user's Student ID card. | `user` (Optional): The user to view. | Everyone |
+| `/leaderboard` | View top players. | `type` (Required): 'Level / XP' or 'Balance'. | Everyone |
+| `/feedback` | Submit feedback, bug reports, or suggestions. | None | Everyone |
+| `/quests` | View your active quests. | None | Everyone |
+
+## Admin
+
+> [!IMPORTANT]
+> These commands require Administrator permissions or specific roles as configured.
+
+### General Management
+| Command | Description | Options |
+|---|---|---|
+| `/config` | Manage bot configuration. | `group` (Req): Section.<br>`key` (Req): Setting.<br>`value` (Req): New value. |
+| `/refresh` | Refresh commands or configuration cache. | `type`: 'Commands' or 'Config'. |
+| `/update` | Update the bot from the repository. | None |
+| `/features` | Enable/Disable system features. | `feature` (Req): Feature name.<br>`enabled` (Req): True/False. |
+| `/webhook` | Send a message via webhook. | `payload` (Req): JSON payload. |
+
+### Moderation
+| Command | Description | Options |
+|---|---|---|
+| `/warn` | Warn a user. | `user` (Req): Target.<br>`reason` (Req): Reason. |
+| `/warnings` | View active warnings for a user. | `user` (Req): Target. |
+| `/clearwarning`| Clear a specific warning. | `case_id` (Req): Case ID. |
+| `/case` | View details of a specific moderation case. | `case_id` (Req): Case ID. |
+| `/cases` | View moderation history for a user. | `user` (Req): Target. |
+| `/note` | Add a note to a user. | `user` (Req): Target.<br>`note` (Req): Content. |
+| `/notes` | View notes for a user. | `user` (Req): Target. |
+| `/prune` | Bulk delete messages. | `amount` (Req): Number (1-100). |
+
+### Game Admin
+| Command | Description | Options |
+|---|---|---|
+| `/create_item` | Create a new item in the database. | (Modal based interaction) |
+| `/create_color`| Create a new color role. | `name` (Req): Role name.<br>`hex` (Req): Hex color code. |
+| `/listing` | Manage shop listings (Admin view). | None (Context sensitive?) |
+| `/terminal` | Control the terminal display channel. | `action`: 'setup', 'update', 'clear'. |

docs/CONFIGURATION.md

@@ -0,0 +1,160 @@
+# Configuration Guide
+
+This document outlines the structure and available options for the `config/config.json` file. The configuration is validated using Zod schemas at runtime (see `src/lib/config.ts`).
+
+## Core Structure
+
+### Leveling
+Configuration for the XP and leveling system.
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `base` | `number` | The base XP required for the first level. |
+| `exponent` | `number` | The exponent used to calculate XP curves. |
+| `chat.cooldownMs` | `number` | Time in milliseconds between XP gains from chat. |
+| `chat.minXp` | `number` | Minimum XP awarded per message. |
+| `chat.maxXp` | `number` | Maximum XP awarded per message. |
+
+### Economy
+Settings for currency, rewards, and transfers.
+
+#### Daily
+| Field | Type | Description |
+|-------|------|-------------|
+| `amount` | `integer` | Base amount granted by `/daily`. |
+| `streakBonus` | `integer` | Bonus amount per streak day. |
+| `weeklyBonus` | `integer` | Bonus amount for a 7-day streak. |
+| `cooldownMs` | `number` | Cooldown period for the command (usually 24h). |
+
+#### Transfers
+| Field | Type | Description |
+|-------|------|-------------|
+| `allowSelfTransfer` | `boolean` | Whether users can transfer money to themselves. |
+| `minAmount` | `integer` | Minimum amount required for a transfer. |
+
+#### Exam
+| Field | Type | Description |
+|-------|------|-------------|
+| `multMin` | `number` | Minimum multiplier for exam rewards. |
+| `multMax` | `number` | Maximum multiplier for exam rewards. |
+
+### Inventory
+| Field | Type | Description |
+|-------|------|-------------|
+| `maxStackSize` | `integer` | Maximum count of a single item in one slot. |
+| `maxSlots` | `number` | Total number of inventory slots available. |
+
+### Lootdrop
+Settings for the random chat loot drop events.
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `activityWindowMs` | `number` | Time window to track activity for spawning drops. |
+| `minMessages` | `number` | Minimum messages required in window to trigger drop. |
+| `spawnChance` | `number` | Probability (0-1) of a drop spawning when conditions met. |
+| `cooldownMs` | `number` | Minimum time between loot drops. |
+| `reward.min` | `number` | Minimum currency reward. |
+| `reward.max` | `number` | Maximum currency reward. |
+| `reward.currency` | `string` | The currency ID/Symbol used for rewards. |
+
+### Roles
+| Field | Type | Description |
+|-------|------|-------------|
+| `studentRole` | `string` | Discord Role ID for students. |
+| `visitorRole` | `string` | Discord Role ID for visitors. |
+| `colorRoles` | `string[]` | List of Discord Role IDs available as color roles. |
+
+### Moderation
+Automated moderation settings.
+
+#### Prune
+| Field | Type | Description |
+|-------|------|-------------|
+| `maxAmount` | `number` | Maximum messages to delete in one go. |
+| `confirmThreshold` | `number` | Amount above which confirmation is required. |
+| `batchSize` | `number` | Size of delete batches. |
+| `batchDelayMs` | `number` | Delay between batches. |
+
+#### Cases
+| Field | Type | Description |
+|-------|------|-------------|
+| `dmOnWarn` | `boolean` | Whether to DM users when they are warned. |
+| `logChannelId` | `string` | (Optional) Channel ID for moderation logs. |
+| `autoTimeoutThreshold` | `number` | (Optional) Warn count to trigger auto-timeout. |
+
+### System & Misc
+| Field | Type | Description |
+|-------|------|-------------|
+| `commands` | `Object` | Map of command names (keys) to boolean (values) to enable/disable them. |
+| `welcomeChannelId` | `string` | (Optional) Channel ID for welcome messages. |
+| `welcomeMessage` | `string` | (Optional) Custom welcome message text. |
+| `feedbackChannelId` | `string` | (Optional) Channel ID where feedback is posted. |
+| `terminal.channelId` | `string` | (Optional) Channel ID for terminal display. |
+| `terminal.messageId` | `string` | (Optional) Message ID for terminal display. |
+
+## Example Config
+
+```json
+{
+    "leveling": {
+        "base": 100,
+        "exponent": 1.5,
+        "chat": {
+            "cooldownMs": 60000,
+            "minXp": 15,
+            "maxXp": 25
+        }
+    },
+    "economy": {
+        "daily": {
+            "amount": "100",
+            "streakBonus": "10",
+            "weeklyBonus": "500",
+            "cooldownMs": 86400000
+        },
+        "transfers": {
+            "allowSelfTransfer": false,
+            "minAmount": "10"
+        },
+        "exam": {
+            "multMin": 1.0,
+            "multMax": 2.0
+        }
+    },
+    "inventory": {
+        "maxStackSize": "99",
+        "maxSlots": 20
+    },
+    "lootdrop": {
+        "activityWindowMs": 300000,
+        "minMessages": 10,
+        "spawnChance": 0.05,
+        "cooldownMs": 3600000,
+        "reward": {
+            "min": 50,
+            "max": 150,
+            "currency": "CREDITS"
+        }
+    },
+    "commands": {
+        "example": true
+    },
+    "studentRole": "123456789012345678",
+    "visitorRole": "123456789012345678",
+    "colorRoles": [],
+    "moderation": {
+        "prune": {
+            "maxAmount": 100,
+            "confirmThreshold": 50,
+            "batchSize": 100,
+            "batchDelayMs": 1000
+        },
+        "cases": {
+            "dmOnWarn": true
+        }
+    }
+}
+```
+
+> [!NOTE]
+> Fields marked as `integer` or `bigint` in the types can often be provided as strings in the JSON to ensure precision, but the system handles parsing them.

docs/DATABASE.md

@@ -0,0 +1,149 @@
+# Database Schema
+
+This document outlines the database schema for the Aurora project. The database is PostgreSQL, managed via Drizzle ORM.
+
+## Tables
+
+### Users (`users`)
+Stores user data, economy, and progression.
+
+| Column | Type | Description |
+|---|---|---|
+| `id` | `bigint` | Primary Key. Discord User ID. |
+| `class_id` | `bigint` | Foreign Key -> `classes.id`. |
+| `username` | `varchar(255)` | User's Discord username. |
+| `is_active` | `boolean` | Whether the user is active (default: true). |
+| `balance` | `bigint` | User's currency balance. |
+| `xp` | `bigint` | User's experience points. |
+| `level` | `integer` | User's level. |
+| `daily_streak` | `integer` | Current streak of daily command usage. |
+| `settings` | `jsonb` | User-specific settings. |
+| `created_at` | `timestamp` | Record creation time. |
+| `updated_at` | `timestamp` | Last update time. |
+
+### Classes (`classes`)
+Available character classes.
+
+| Column | Type | Description |
+|---|---|---|
+| `id` | `bigint` | Primary Key. Custom ID. |
+| `name` | `varchar(255)` | Class name (Unique). |
+| `balance` | `bigint` | Class bank balance (shared/flavor). |
+| `role_id` | `varchar(255)` | Discord Role ID associated with the class. |
+
+### Items (`items`)
+Definitions of items available in the game.
+
+| Column | Type | Description |
+|---|---|---|
+| `id` | `serial` | Primary Key. Auto-incrementing ID. |
+| `name` | `varchar(255)` | Item name (Unique). |
+| `description` | `text` | Item description. |
+| `rarity` | `varchar(20)` | Common, Rare, etc. Default: 'Common'. |
+| `type` | `varchar(50)` | MATERIAL, CONSUMABLE, EQUIPMENT, etc. |
+| `usage_data` | `jsonb` | Effect data for consumables/usables. |
+| `price` | `bigint` | Base value of the item. |
+| `icon_url` | `text` | URL for the item's icon. |
+| `image_url` | `text` | URL for the item's large image. |
+
+### Inventory (`inventory`)
+Items held by users.
+
+| Column | Type | Description |
+|---|---|---|
+| `user_id` | `bigint` | PK/FK -> `users.id`. |
+| `item_id` | `integer` | PK/FK -> `items.id`. |
+| `quantity` | `bigint` | Amount held. Must be > 0. |
+
+### Transactions (`transactions`)
+Currency transaction history.
+
+| Column | Type | Description |
+|---|---|---|
+| `id` | `bigserial` | Primary Key. |
+| `user_id` | `bigint` | FK -> `users.id`. The user affecting the balance. |
+| `related_user_id` | `bigint` | FK -> `users.id`. The other party (if any). |
+| `amount` | `bigint` | Amount transferred. |
+| `type` | `varchar(50)` | Transaction type identifier. |
+| `description` | `text` | Human-readable description. |
+| `created_at` | `timestamp` | Time of transaction. |
+
+### Item Transactions (`item_transactions`)
+Item flow history.
+
+| Column | Type | Description |
+|---|---|---|
+| `id` | `bigserial` | Primary Key. |
+| `user_id` | `bigint` | FK -> `users.id`. |
+| `related_user_id` | `bigint` | FK -> `users.id`. |
+| `item_id` | `integer` | FK -> `items.id`. |
+| `quantity` | `bigint` | Amount gained (+) or lost (-). |
+| `type` | `varchar(50)` | TRADE, SHOP_BUY, DROP, etc. |
+| `description` | `text` | Description. |
+| `created_at` | `timestamp` | Time of transaction. |
+
+### Quests (`quests`)
+Quest definitions.
+
+| Column | Type | Description |
+|---|---|---|
+| `id` | `serial` | Primary Key. |
+| `name` | `varchar(255)` | Quest title. |
+| `description` | `text` | Quest text. |
+| `trigger_event` | `varchar(50)` | Event that triggers progress checks. |
+| `requirements` | `jsonb` | Completion criteria. |
+| `rewards` | `jsonb` | Rewards for completion. |
+
+### User Quests (`user_quests`)
+User progress on quests.
+
+| Column | Type | Description |
+|---|---|---|
+| `user_id` | `bigint` | PK/FK -> `users.id`. |
+| `quest_id` | `integer` | PK/FK -> `quests.id`. |
+| `progress` | `integer` | Current progress value. |
+| `completed_at` | `timestamp` | Completion time (null if active). |
+
+### User Timers (`user_timers`)
+Generic timers for cooldowns, temporary effects, etc.
+
+| Column | Type | Description |
+|---|---|---|
+| `user_id` | `bigint` | PK/FK -> `users.id`. |
+| `type` | `varchar(50)` | PK. Timer type (COOLDOWN, EFFECT, ACCESS). |
+| `key` | `varchar(100)` | PK. specific ID (e.g. 'daily'). |
+| `expires_at` | `timestamp` | When the timer expires. |
+| `metadata` | `jsonb` | Extra data. |
+
+### Lootdrops (`lootdrops`)
+Active chat loot drop events.
+
+| Column | Type | Description |
+|---|---|---|
+| `message_id` | `varchar(255)` | Primary Key. Discord Message ID. |
+| `channel_id` | `varchar(255)` | Discord Channel ID. |
+| `reward_amount` | `integer` | Currency amount. |
+| `currency` | `varchar(50)` | Currency type constant. |
+| `claimed_by` | `bigint` | FK -> `users.id`. Null if unclaimed. |
+| `created_at` | `timestamp` | Spawn time. |
+| `expires_at` | `timestamp` | Despawn time. |
+
+### Moderation Cases (`moderation_cases`)
+History of moderation actions.
+
+| Column | Type | Description |
+|---|---|---|
+| `id` | `bigserial` | Primary Key. |
+| `case_id` | `varchar(50)` | Unique friendly ID. |
+| `type` | `varchar(20)` | warn, timeout, kick, ban, etc. |
+| `user_id` | `bigint` | Target user ID. |
+| `username` | `varchar(255)` | Target username snapshot. |
+| `moderator_id` | `bigint` | Acting moderator ID. |
+| `moderator_name` | `varchar(255)` | Moderator username snapshot. |
+| `reason` | `text` | Reason for action. |
+| `metadata` | `jsonb` | Extra data. |
+| `active` | `boolean` | Is this case active? |
+| `created_at` | `timestamp` | Creation time. |
+| `resolved_at` | `timestamp` | Resolution/Expiration time. |
+| `resolved_by` | `bigint` | User ID who resolved it. |
+| `resolved_reason` | `text` | Reason for resolution. |

docs/LOOTBOX_GUIDE.md

@@ -0,0 +1,127 @@
+# Lootbox Creation Guide
+
+Currently, the Item Wizard does not support creating **Lootbox** items directly. Instead, they must be inserted manually into the database. This guide details the required JSON structure for the `LOOTBOX` effect.
+
+## Item Structure
+
+To create a lootbox, you need to insert a row into the `items` table. The critical part is the `usageData` JSON column.
+
+```json
+{
+  "consume": true,
+  "effects": [
+    {
+      "type": "LOOTBOX",
+      "pool": [ ... ]
+    }
+  ]
+}
+```
+
+## Loot Table Structure
+
+The `pool` property is an array of `LootTableItem` objects. A random item is selected based on the total `weight` of all items in the pool.
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `type` | `string` | One of: `CURRENCY`, `ITEM`, `XP`, `NOTHING`. |
+| `weight` | `number` | The relative probability weight of this outcome. |
+| `message` | `string` | (Optional) Custom message to display when this outcome is selected. |
+
+### Outcome Types
+
+#### 1. Currency
+Gives the user coins.
+
+```json
+{
+  "type": "CURRENCY",
+  "weight": 50,
+  "amount": 100,          // Fixed amount OR
+  "minAmount": 50,        // Minimum random amount
+  "maxAmount": 150        // Maximum random amount
+}
+```
+
+#### 2. XP
+Gives the user Experience Points.
+
+```json
+{
+  "type": "XP",
+  "weight": 30,
+  "amount": 500           // Fixed amount OR range (minAmount/maxAmount)
+}
+```
+
+#### 3. Item
+Gives the user another item (by ID).
+
+```json
+{
+  "type": "ITEM",
+  "weight": 10,
+  "itemId": 42,           // The ID of the item to give
+  "amount": 1             // (Optional) Quantity to give, default 1
+}
+```
+
+#### 4. Nothing
+An empty roll.
+
+```json
+{
+  "type": "NOTHING",
+  "weight": 10,
+  "message": "The box was empty! Better luck next time."
+}
+```
+
+## Complete Example
+
+Here is a full SQL insert example (using a hypothetical SQL client or Drizzle studio) for a "Basic Lootbox":
+
+**Name**: Basic Lootbox
+**Type**: CONSUMABLE
+**Effect**:
+- 50% chance for 100-200 Coins
+- 30% chance for 500 XP
+- 10% chance for Item ID 5 (e.g. Rare Gem)
+- 10% chance for Nothing
+
+**JSON for `usageData`**:
+```json
+{
+  "consume": true,
+  "effects": [
+    {
+      "type": "LOOTBOX",
+      "pool": [
+        {
+          "type": "CURRENCY",
+          "weight": 50,
+          "minAmount": 100,
+          "maxAmount": 200
+        },
+        {
+          "type": "XP",
+          "weight": 30,
+          "amount": 500
+        },
+        {
+          "type": "ITEM",
+          "weight": 10,
+          "itemId": 5,
+          "amount": 1,
+          "message": "Startstruck! You found a Rare Gem!"
+        },
+        {
+          "type": "NOTHING",
+          "weight": 10,
+          "message": "It's empty..."
+        }
+      ]
+    }
+  ]
+}
+```

docs/MODULE_STRUCTURE.md

@@ -0,0 +1,72 @@
+# Aurora Module Structure Guide
+
+This guide documents the standard module organization patterns used in the Aurora codebase. Following these patterns ensures consistency, maintainability, and clear separation of concerns.
+
+## Module Anatomy
+
+A typical module in `@modules/` is organized into several files, each with a specific responsibility. 
+
+Example: `trade` module
+- `trade.service.ts`: Business logic and data access.
+- `trade.view.ts`: Discord UI components (embeds, modals, select menus).
+- `trade.interaction.ts`: Handler for interaction events (buttons, modals, etc.).
+- `trade.types.ts`: TypeScript interfaces and types.
+- `trade.service.test.ts`: Unit tests for the service logic.
+
+## File Responsibilities
+
+### 1. Service (`*.service.ts`)
+The core of the module. It contains the business logic, database interactions (using Drizzle), and state management.
+- **Rules**:
+  - Export a singleton instance: `export const tradeService = new TradeService();`
+  - Should not contain Discord-specific rendering logic (return data, not embeds).
+  - Throw `UserError` for validation issues that should be shown to the user.
+
+### 2. View (`*.view.ts`)
+Handles the creation of Discord-specific UI elements like `EmbedBuilder`, `ActionRowBuilder`, and `ModalBuilder`.
+- **Rules**:
+  - Focus on formatting and presentation.
+  - Takes raw data (from services) and returns Discord components.
+
+### 3. Interaction Handler (`*.interaction.ts`)
+The entry point for Discord component interactions (buttons, select menus, modals).
+- **Rules**:
+  - Export a single handler function: `export async function handleTradeInteraction(interaction: Interaction) { ... }`
+  - Routes internal `customId` patterns to specific logic.
+  - Relies on `ComponentInteractionHandler` for centralized error handling.
+  - **No local try-catch** for standard validation errors; let them bubble up as `UserError`.
+
+### 4. Types (`*.types.ts`)
+Central location for module-specific TypeScript types and constants.
+- **Rules**:
+  - Define interfaces for complex data structures.
+  - Use enums or literal types for states and custom IDs.
+
+## Interaction Routing
+
+All interaction handlers must be registered in `src/lib/interaction.routes.ts`. 
+
+```typescript
+{
+    predicate: (i) => i.customId.startsWith("module_"),
+    handler: () => import("@/modules/module/module.interaction"),
+    method: 'handleModuleInteraction'
+}
+```
+
+## Error Handling Standards
+
+Aurora uses a centralized error handling pattern in `ComponentInteractionHandler`.
+
+1. **UserError**: Use this for validation errors or issues the user can fix (e.g., "Insufficient funds").
+   - `throw new UserError("You need more coins!");`
+2. **SystemError / Generic Error**: Use this for unexpected system failures.
+   - These are logged to the console/logger and show a generic "Unexpected error" message to the user.
+
+## Naming Conventions
+
+- **Directory Name**: Lowercase, singular (e.g., `trade`, `inventory`).
+- **File Names**: `moduleName.type.ts` (e.g., `trade.service.ts`).
+- **Class Names**: PascalCase (e.g., `TradeService`).
+- **Service Instances**: camelCase (e.g., `tradeService`).
+- **Interaction Method**: `handle[ModuleName]Interaction`.

drizzle/0001_heavy_thundra.sql

@@ -0,0 +1,17 @@
+CREATE TABLE "moderation_cases" (
+	"id" bigserial PRIMARY KEY NOT NULL,
+	"case_id" varchar(50) NOT NULL,
+	"type" varchar(20) NOT NULL,
+	"user_id" bigint NOT NULL,
+	"username" varchar(255) NOT NULL,
+	"moderator_id" bigint NOT NULL,
+	"moderator_name" varchar(255) NOT NULL,
+	"reason" text NOT NULL,
+	"metadata" jsonb DEFAULT '{}'::jsonb,
+	"active" boolean DEFAULT true NOT NULL,
+	"created_at" timestamp with time zone DEFAULT now() NOT NULL,
+	"resolved_at" timestamp with time zone,
+	"resolved_by" bigint,
+	"resolved_reason" text,
+	CONSTRAINT "moderation_cases_case_id_unique" UNIQUE("case_id")
+);

drizzle/0002_fancy_forge.sql

@@ -0,0 +1,8 @@
+CREATE INDEX "moderation_cases_user_id_idx" ON "moderation_cases" USING btree ("user_id");--> statement-breakpoint
+CREATE INDEX "moderation_cases_case_id_idx" ON "moderation_cases" USING btree ("case_id");--> statement-breakpoint
+CREATE INDEX "transactions_created_at_idx" ON "transactions" USING btree ("created_at");--> statement-breakpoint
+CREATE INDEX "user_timers_expires_at_idx" ON "user_timers" USING btree ("expires_at");--> statement-breakpoint
+CREATE INDEX "user_timers_lookup_idx" ON "user_timers" USING btree ("user_id","type","key");--> statement-breakpoint
+CREATE INDEX "users_username_idx" ON "users" USING btree ("username");--> statement-breakpoint
+CREATE INDEX "users_balance_idx" ON "users" USING btree ("balance");--> statement-breakpoint
+CREATE INDEX "users_level_xp_idx" ON "users" USING btree ("level","xp");

drizzle/meta/0001_snapshot.json

@@ -0,0 +1,878 @@
+{
+  "id": "72cb5e22-fb44-4db8-9527-020dbec017d0",
+  "prevId": "d43c3f7b-afe5-4974-ab67-fcd69256f3d8",
+  "version": "7",
+  "dialect": "postgresql",
+  "tables": {
+    "public.classes": {
+      "name": "classes",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "bigint",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "balance": {
+          "name": "balance",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "0"
+        },
+        "role_id": {
+          "name": "role_id",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "classes_name_unique": {
+          "name": "classes_name_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "name"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.inventory": {
+      "name": "inventory",
+      "schema": "",
+      "columns": {
+        "user_id": {
+          "name": "user_id",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "item_id": {
+          "name": "item_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "quantity": {
+          "name": "quantity",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "1"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "inventory_user_id_users_id_fk": {
+          "name": "inventory_user_id_users_id_fk",
+          "tableFrom": "inventory",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "inventory_item_id_items_id_fk": {
+          "name": "inventory_item_id_items_id_fk",
+          "tableFrom": "inventory",
+          "tableTo": "items",
+          "columnsFrom": [
+            "item_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "inventory_user_id_item_id_pk": {
+          "name": "inventory_user_id_item_id_pk",
+          "columns": [
+            "user_id",
+            "item_id"
+          ]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "quantity_check": {
+          "name": "quantity_check",
+          "value": "\"inventory\".\"quantity\" > 0"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.item_transactions": {
+      "name": "item_transactions",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "bigserial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "related_user_id": {
+          "name": "related_user_id",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "item_id": {
+          "name": "item_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "quantity": {
+          "name": "quantity",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "type": {
+          "name": "type",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "item_transactions_user_id_users_id_fk": {
+          "name": "item_transactions_user_id_users_id_fk",
+          "tableFrom": "item_transactions",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "item_transactions_related_user_id_users_id_fk": {
+          "name": "item_transactions_related_user_id_users_id_fk",
+          "tableFrom": "item_transactions",
+          "tableTo": "users",
+          "columnsFrom": [
+            "related_user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "item_transactions_item_id_items_id_fk": {
+          "name": "item_transactions_item_id_items_id_fk",
+          "tableFrom": "item_transactions",
+          "tableTo": "items",
+          "columnsFrom": [
+            "item_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.items": {
+      "name": "items",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "rarity": {
+          "name": "rarity",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "'Common'"
+        },
+        "type": {
+          "name": "type",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'MATERIAL'"
+        },
+        "usage_data": {
+          "name": "usage_data",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "'{}'::jsonb"
+        },
+        "price": {
+          "name": "price",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "icon_url": {
+          "name": "icon_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "image_url": {
+          "name": "image_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "items_name_unique": {
+          "name": "items_name_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "name"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.lootdrops": {
+      "name": "lootdrops",
+      "schema": "",
+      "columns": {
+        "message_id": {
+          "name": "message_id",
+          "type": "varchar(255)",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "channel_id": {
+          "name": "channel_id",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "reward_amount": {
+          "name": "reward_amount",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "currency": {
+          "name": "currency",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "claimed_by": {
+          "name": "claimed_by",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "lootdrops_claimed_by_users_id_fk": {
+          "name": "lootdrops_claimed_by_users_id_fk",
+          "tableFrom": "lootdrops",
+          "tableTo": "users",
+          "columnsFrom": [
+            "claimed_by"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.moderation_cases": {
+      "name": "moderation_cases",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "bigserial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "case_id": {
+          "name": "case_id",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "type": {
+          "name": "type",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "username": {
+          "name": "username",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "moderator_id": {
+          "name": "moderator_id",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "moderator_name": {
+          "name": "moderator_name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "reason": {
+          "name": "reason",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "metadata": {
+          "name": "metadata",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "'{}'::jsonb"
+        },
+        "active": {
+          "name": "active",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "resolved_at": {
+          "name": "resolved_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "resolved_by": {
+          "name": "resolved_by",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "resolved_reason": {
+          "name": "resolved_reason",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "moderation_cases_case_id_unique": {
+          "name": "moderation_cases_case_id_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "case_id"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.quests": {
+      "name": "quests",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "trigger_event": {
+          "name": "trigger_event",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "requirements": {
+          "name": "requirements",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'{}'::jsonb"
+        },
+        "rewards": {
+          "name": "rewards",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'{}'::jsonb"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.transactions": {
+      "name": "transactions",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "bigserial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "related_user_id": {
+          "name": "related_user_id",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "amount": {
+          "name": "amount",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "type": {
+          "name": "type",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "transactions_user_id_users_id_fk": {
+          "name": "transactions_user_id_users_id_fk",
+          "tableFrom": "transactions",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "transactions_related_user_id_users_id_fk": {
+          "name": "transactions_related_user_id_users_id_fk",
+          "tableFrom": "transactions",
+          "tableTo": "users",
+          "columnsFrom": [
+            "related_user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.user_quests": {
+      "name": "user_quests",
+      "schema": "",
+      "columns": {
+        "user_id": {
+          "name": "user_id",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "quest_id": {
+          "name": "quest_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "progress": {
+          "name": "progress",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "default": 0
+        },
+        "completed_at": {
+          "name": "completed_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "user_quests_user_id_users_id_fk": {
+          "name": "user_quests_user_id_users_id_fk",
+          "tableFrom": "user_quests",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "user_quests_quest_id_quests_id_fk": {
+          "name": "user_quests_quest_id_quests_id_fk",
+          "tableFrom": "user_quests",
+          "tableTo": "quests",
+          "columnsFrom": [
+            "quest_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "user_quests_user_id_quest_id_pk": {
+          "name": "user_quests_user_id_quest_id_pk",
+          "columns": [
+            "user_id",
+            "quest_id"
+          ]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.user_timers": {
+      "name": "user_timers",
+      "schema": "",
+      "columns": {
+        "user_id": {
+          "name": "user_id",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "type": {
+          "name": "type",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "key": {
+          "name": "key",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "metadata": {
+          "name": "metadata",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "'{}'::jsonb"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "user_timers_user_id_users_id_fk": {
+          "name": "user_timers_user_id_users_id_fk",
+          "tableFrom": "user_timers",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "user_timers_user_id_type_key_pk": {
+          "name": "user_timers_user_id_type_key_pk",
+          "columns": [
+            "user_id",
+            "type",
+            "key"
+          ]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.users": {
+      "name": "users",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "bigint",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "class_id": {
+          "name": "class_id",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "username": {
+          "name": "username",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "is_active": {
+          "name": "is_active",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": true
+        },
+        "balance": {
+          "name": "balance",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "0"
+        },
+        "xp": {
+          "name": "xp",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "0"
+        },
+        "level": {
+          "name": "level",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "default": 1
+        },
+        "daily_streak": {
+          "name": "daily_streak",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "default": 0
+        },
+        "settings": {
+          "name": "settings",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "'{}'::jsonb"
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "users_class_id_classes_id_fk": {
+          "name": "users_class_id_classes_id_fk",
+          "tableFrom": "users",
+          "tableTo": "classes",
+          "columnsFrom": [
+            "class_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "users_username_unique": {
+          "name": "users_username_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "username"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    }
+  },
+  "enums": {},
+  "schemas": {},
+  "sequences": {},
+  "roles": {},
+  "policies": {},
+  "views": {},
+  "_meta": {
+    "columns": {},
+    "schemas": {},
+    "tables": {}
+  }
+}

drizzle/meta/_journal.json

@@ -8,6 +8,20 @@
       "when": 1766137924760,
       "tag": "0000_fixed_tomas",
       "breakpoints": true
+    },
+    {
+      "idx": 1,
+      "version": "7",
+      "when": 1766606046050,
+      "tag": "0001_heavy_thundra",
+      "breakpoints": true
+    },
+    {
+      "idx": 2,
+      "version": "7",
+      "when": 1767716705797,
+      "tag": "0002_fancy_forge",
+      "breakpoints": true
     }
   ]
 }

package.json

@@ -5,8 +5,7 @@
   "private": true,
   "devDependencies": {
     "@types/bun": "latest",
-    "drizzle-kit": "^0.31.7",
-    "postgres": "^3.4.7"
+    "drizzle-kit": "^0.31.7"
   },
   "peerDependencies": {
     "typescript": "^5"
@@ -26,6 +25,7 @@
     "discord.js": "^14.25.1",
     "dotenv": "^17.2.3",
     "drizzle-orm": "^0.44.7",
+    "postgres": "^3.4.7",
     "zod": "^4.1.13"
   }
 }

src/commands/admin/case.ts

@@ -0,0 +1,54 @@
+import { createCommand } from "@/lib/utils";
+import { SlashCommandBuilder, PermissionFlagsBits, MessageFlags } from "discord.js";
+import { ModerationService } from "@/modules/moderation/moderation.service";
+import { getCaseEmbed, getModerationErrorEmbed } from "@/modules/moderation/moderation.view";
+
+export const moderationCase = createCommand({
+    data: new SlashCommandBuilder()
+        .setName("case")
+        .setDescription("View details of a specific moderation case")
+        .addStringOption(option =>
+            option
+                .setName("case_id")
+                .setDescription("The case ID (e.g., CASE-0001)")
+                .setRequired(true)
+        )
+        .setDefaultMemberPermissions(PermissionFlagsBits.Administrator),
+
+    execute: async (interaction) => {
+        await interaction.deferReply({ flags: MessageFlags.Ephemeral });
+
+        try {
+            const caseId = interaction.options.getString("case_id", true).toUpperCase();
+
+            // Validate case ID format
+            if (!caseId.match(/^CASE-\d+$/)) {
+                await interaction.editReply({
+                    embeds: [getModerationErrorEmbed("Invalid case ID format. Expected format: CASE-0001")]
+                });
+                return;
+            }
+
+            // Get the case
+            const moderationCase = await ModerationService.getCaseById(caseId);
+
+            if (!moderationCase) {
+                await interaction.editReply({
+                    embeds: [getModerationErrorEmbed(`Case **${caseId}** not found.`)]
+                });
+                return;
+            }
+
+            // Display the case
+            await interaction.editReply({
+                embeds: [getCaseEmbed(moderationCase)]
+            });
+
+        } catch (error) {
+            console.error("Case command error:", error);
+            await interaction.editReply({
+                embeds: [getModerationErrorEmbed("An error occurred while fetching the case.")]
+            });
+        }
+    }
+});

src/commands/admin/cases.ts

@@ -0,0 +1,54 @@
+import { createCommand } from "@/lib/utils";
+import { SlashCommandBuilder, PermissionFlagsBits, MessageFlags } from "discord.js";
+import { ModerationService } from "@/modules/moderation/moderation.service";
+import { getCasesListEmbed, getModerationErrorEmbed } from "@/modules/moderation/moderation.view";
+
+export const cases = createCommand({
+    data: new SlashCommandBuilder()
+        .setName("cases")
+        .setDescription("View all moderation cases for a user")
+        .addUserOption(option =>
+            option
+                .setName("user")
+                .setDescription("The user to check cases for")
+                .setRequired(true)
+        )
+        .addBooleanOption(option =>
+            option
+                .setName("active_only")
+                .setDescription("Show only active cases (warnings)")
+                .setRequired(false)
+        )
+        .setDefaultMemberPermissions(PermissionFlagsBits.Administrator),
+
+    execute: async (interaction) => {
+        await interaction.deferReply({ flags: MessageFlags.Ephemeral });
+
+        try {
+            const targetUser = interaction.options.getUser("user", true);
+            const activeOnly = interaction.options.getBoolean("active_only") || false;
+
+            // Get cases for the user
+            const userCases = await ModerationService.getUserCases(targetUser.id, activeOnly);
+
+            const title = activeOnly
+                ? `⚠️ Active Cases for ${targetUser.username}`
+                : `📋 All Cases for ${targetUser.username}`;
+
+            const description = userCases.length === 0
+                ? undefined
+                : `Total cases: **${userCases.length}**`;
+
+            // Display the cases
+            await interaction.editReply({
+                embeds: [getCasesListEmbed(userCases, title, description)]
+            });
+
+        } catch (error) {
+            console.error("Cases command error:", error);
+            await interaction.editReply({
+                embeds: [getModerationErrorEmbed("An error occurred while fetching cases.")]
+            });
+        }
+    }
+});

src/commands/admin/clearwarning.ts

@@ -0,0 +1,84 @@
+import { createCommand } from "@/lib/utils";
+import { SlashCommandBuilder, PermissionFlagsBits, MessageFlags } from "discord.js";
+import { ModerationService } from "@/modules/moderation/moderation.service";
+import { getClearSuccessEmbed, getModerationErrorEmbed } from "@/modules/moderation/moderation.view";
+
+export const clearwarning = createCommand({
+    data: new SlashCommandBuilder()
+        .setName("clearwarning")
+        .setDescription("Clear/resolve a warning")
+        .addStringOption(option =>
+            option
+                .setName("case_id")
+                .setDescription("The case ID to clear (e.g., CASE-0001)")
+                .setRequired(true)
+        )
+        .addStringOption(option =>
+            option
+                .setName("reason")
+                .setDescription("Reason for clearing the warning")
+                .setRequired(false)
+                .setMaxLength(500)
+        )
+        .setDefaultMemberPermissions(PermissionFlagsBits.Administrator),
+
+    execute: async (interaction) => {
+        await interaction.deferReply({ flags: MessageFlags.Ephemeral });
+
+        try {
+            const caseId = interaction.options.getString("case_id", true).toUpperCase();
+            const reason = interaction.options.getString("reason") || "Cleared by moderator";
+
+            // Validate case ID format
+            if (!caseId.match(/^CASE-\d+$/)) {
+                await interaction.editReply({
+                    embeds: [getModerationErrorEmbed("Invalid case ID format. Expected format: CASE-0001")]
+                });
+                return;
+            }
+
+            // Check if case exists and is active
+            const existingCase = await ModerationService.getCaseById(caseId);
+
+            if (!existingCase) {
+                await interaction.editReply({
+                    embeds: [getModerationErrorEmbed(`Case **${caseId}** not found.`)]
+                });
+                return;
+            }
+
+            if (!existingCase.active) {
+                await interaction.editReply({
+                    embeds: [getModerationErrorEmbed(`Case **${caseId}** is already resolved.`)]
+                });
+                return;
+            }
+
+            if (existingCase.type !== 'warn') {
+                await interaction.editReply({
+                    embeds: [getModerationErrorEmbed(`Case **${caseId}** is not a warning. Only warnings can be cleared.`)]
+                });
+                return;
+            }
+
+            // Clear the warning
+            await ModerationService.clearCase({
+                caseId,
+                clearedBy: interaction.user.id,
+                clearedByName: interaction.user.username,
+                reason
+            });
+
+            // Send success message
+            await interaction.editReply({
+                embeds: [getClearSuccessEmbed(caseId)]
+            });
+
+        } catch (error) {
+            console.error("Clear warning command error:", error);
+            await interaction.editReply({
+                embeds: [getModerationErrorEmbed("An error occurred while clearing the warning.")]
+            });
+        }
+    }
+});

src/commands/admin/health.test.ts

@@ -0,0 +1,84 @@
+import { describe, test, expect, mock, beforeEach } from "bun:test";
+import { health } from "./health";
+import { ChatInputCommandInteraction, Colors } from "discord.js";
+import { AuroraClient } from "@/lib/BotClient";
+
+// Mock DrizzleClient
+const executeMock = mock(() => Promise.resolve());
+mock.module("@/lib/DrizzleClient", () => ({
+    DrizzleClient: {
+        execute: executeMock
+    }
+}));
+
+// Mock BotClient (already has lastCommandTimestamp if imported, but we might want to control it)
+AuroraClient.lastCommandTimestamp = 1641481200000; // Fixed timestamp for testing
+
+describe("Health Command", () => {
+    beforeEach(() => {
+        executeMock.mockClear();
+    });
+
+    test("should execute successfully and return health embed", async () => {
+        const interaction = {
+            deferReply: mock(() => Promise.resolve()),
+            editReply: mock(() => Promise.resolve()),
+            client: {
+                ws: {
+                    ping: 42
+                }
+            },
+            user: { id: "123", username: "testuser" },
+            commandName: "health"
+        } as unknown as ChatInputCommandInteraction;
+
+        await health.execute(interaction);
+
+        expect(interaction.deferReply).toHaveBeenCalled();
+        expect(executeMock).toHaveBeenCalled();
+        expect(interaction.editReply).toHaveBeenCalled();
+
+        const editReplyCall = (interaction.editReply as any).mock.calls[0][0];
+        const embed = editReplyCall.embeds[0];
+
+        expect(embed.data.title).toBe("System Health Status");
+        expect(embed.data.color).toBe(Colors.Aqua);
+
+        // Check fields
+        const fields = embed.data.fields;
+        expect(fields).toBeDefined();
+
+        // Connectivity field
+        const connectivityField = fields.find((f: any) => f.name === "📡 Connectivity");
+        expect(connectivityField.value).toContain("42ms");
+        expect(connectivityField.value).toContain("Connected");
+
+        // Activity field
+        const activityField = fields.find((f: any) => f.name === "⌨️ Activity");
+        expect(activityField.value).toContain("R>"); // Relative Discord timestamp
+    });
+
+    test("should handle database disconnection", async () => {
+        executeMock.mockImplementationOnce(() => Promise.reject(new Error("DB Down")));
+
+        const interaction = {
+            deferReply: mock(() => Promise.resolve()),
+            editReply: mock(() => Promise.resolve()),
+            client: {
+                ws: {
+                    ping: 42
+                }
+            },
+            user: { id: "123", username: "testuser" },
+            commandName: "health"
+        } as unknown as ChatInputCommandInteraction;
+
+        await health.execute(interaction);
+
+        const editReplyCall = (interaction.editReply as any).mock.calls[0][0];
+        const embed = editReplyCall.embeds[0];
+        const connectivityField = embed.data.fields.find((f: any) => f.name === "📡 Connectivity");
+
+        expect(connectivityField.value).toContain("Disconnected");
+    });
+});

src/commands/admin/health.ts

@@ -0,0 +1,60 @@
+import { createCommand } from "@lib/utils";
+import { AuroraClient } from "@/lib/BotClient";
+import { SlashCommandBuilder, PermissionFlagsBits, EmbedBuilder, Colors } from "discord.js";
+import { DrizzleClient } from "@/lib/DrizzleClient";
+import { sql } from "drizzle-orm";
+import { createBaseEmbed } from "@lib/embeds";
+
+export const health = createCommand({
+    data: new SlashCommandBuilder()
+        .setName("health")
+        .setDescription("Check the bot's health status")
+        .setDefaultMemberPermissions(PermissionFlagsBits.Administrator),
+    execute: async (interaction) => {
+        await interaction.deferReply();
+
+        // 1. Check Discord API latency
+        const wsPing = interaction.client.ws.ping;
+
+        // 2. Verify database connection
+        let dbStatus = "Connected";
+        let dbPing = -1;
+        try {
+            const start = Date.now();
+            await DrizzleClient.execute(sql`SELECT 1`);
+            dbPing = Date.now() - start;
+        } catch (error) {
+            dbStatus = "Disconnected";
+            console.error("Health check DB error:", error);
+        }
+
+        // 3. Uptime
+        const uptime = process.uptime();
+        const days = Math.floor(uptime / 86400);
+        const hours = Math.floor((uptime % 86400) / 3600);
+        const minutes = Math.floor((uptime % 3600) / 60);
+        const seconds = Math.floor(uptime % 60);
+        const uptimeString = `${days}d ${hours}h ${minutes}m ${seconds}s`;
+
+        // 4. Memory usage
+        const memory = process.memoryUsage();
+        const heapUsed = (memory.heapUsed / 1024 / 1024).toFixed(2);
+        const heapTotal = (memory.heapTotal / 1024 / 1024).toFixed(2);
+        const rss = (memory.rss / 1024 / 1024).toFixed(2);
+
+        // 5. Last successful command
+        const lastCommand = AuroraClient.lastCommandTimestamp
+            ? `<t:${Math.floor(AuroraClient.lastCommandTimestamp / 1000)}:R>`
+            : "None since startup";
+
+        const embed = createBaseEmbed("System Health Status", undefined, Colors.Aqua)
+            .addFields(
+                { name: "📡 Connectivity", value: `**Discord WS:** ${wsPing}ms\n**Database:** ${dbStatus} ${dbPing >= 0 ? `(${dbPing}ms)` : ""}`, inline: true },
+                { name: "⏱️ Uptime", value: uptimeString, inline: true },
+                { name: "🧠 Memory Usage", value: `**RSS:** ${rss} MB\n**Heap:** ${heapUsed} / ${heapTotal} MB`, inline: false },
+                { name: "⌨️ Activity", value: `**Last Command:** ${lastCommand}`, inline: true }
+            );
+
+        await interaction.editReply({ embeds: [embed] });
+    }
+});

src/commands/admin/note.ts

@@ -0,0 +1,62 @@
+import { createCommand } from "@/lib/utils";
+import { SlashCommandBuilder, PermissionFlagsBits, MessageFlags } from "discord.js";
+import { ModerationService } from "@/modules/moderation/moderation.service";
+import { CaseType } from "@/lib/constants";
+import { getNoteSuccessEmbed, getModerationErrorEmbed } from "@/modules/moderation/moderation.view";
+
+export const note = createCommand({
+    data: new SlashCommandBuilder()
+        .setName("note")
+        .setDescription("Add a staff-only note about a user")
+        .addUserOption(option =>
+            option
+                .setName("user")
+                .setDescription("The user to add a note for")
+                .setRequired(true)
+        )
+        .addStringOption(option =>
+            option
+                .setName("note")
+                .setDescription("The note to add")
+                .setRequired(true)
+                .setMaxLength(1000)
+        )
+        .setDefaultMemberPermissions(PermissionFlagsBits.Administrator),
+
+    execute: async (interaction) => {
+        await interaction.deferReply({ flags: MessageFlags.Ephemeral });
+
+        try {
+            const targetUser = interaction.options.getUser("user", true);
+            const noteText = interaction.options.getString("note", true);
+
+            // Create the note case
+            const moderationCase = await ModerationService.createCase({
+                type: CaseType.NOTE,
+                userId: targetUser.id,
+                username: targetUser.username,
+                moderatorId: interaction.user.id,
+                moderatorName: interaction.user.username,
+                reason: noteText,
+            });
+
+            if (!moderationCase) {
+                await interaction.editReply({
+                    embeds: [getModerationErrorEmbed("Failed to create note.")]
+                });
+                return;
+            }
+
+            // Send success message
+            await interaction.editReply({
+                embeds: [getNoteSuccessEmbed(moderationCase.caseId, targetUser.username)]
+            });
+
+        } catch (error) {
+            console.error("Note command error:", error);
+            await interaction.editReply({
+                embeds: [getModerationErrorEmbed("An error occurred while adding the note.")]
+            });
+        }
+    }
+});

src/commands/admin/notes.ts

@@ -0,0 +1,43 @@
+import { createCommand } from "@/lib/utils";
+import { SlashCommandBuilder, PermissionFlagsBits, MessageFlags } from "discord.js";
+import { ModerationService } from "@/modules/moderation/moderation.service";
+import { getCasesListEmbed, getModerationErrorEmbed } from "@/modules/moderation/moderation.view";
+
+export const notes = createCommand({
+    data: new SlashCommandBuilder()
+        .setName("notes")
+        .setDescription("View all staff notes for a user")
+        .addUserOption(option =>
+            option
+                .setName("user")
+                .setDescription("The user to check notes for")
+                .setRequired(true)
+        )
+        .setDefaultMemberPermissions(PermissionFlagsBits.Administrator),
+
+    execute: async (interaction) => {
+        await interaction.deferReply({ flags: MessageFlags.Ephemeral });
+
+        try {
+            const targetUser = interaction.options.getUser("user", true);
+
+            // Get all notes for the user
+            const userNotes = await ModerationService.getUserNotes(targetUser.id);
+
+            // Display the notes
+            await interaction.editReply({
+                embeds: [getCasesListEmbed(
+                    userNotes,
+                    `📝 Staff Notes for ${targetUser.username}`,
+                    userNotes.length === 0 ? undefined : `Total notes: **${userNotes.length}**`
+                )]
+            });
+
+        } catch (error) {
+            console.error("Notes command error:", error);
+            await interaction.editReply({
+                embeds: [getModerationErrorEmbed("An error occurred while fetching notes.")]
+            });
+        }
+    }
+});

src/commands/admin/warn.ts

@@ -0,0 +1,87 @@
+import { createCommand } from "@/lib/utils";
+import { SlashCommandBuilder, PermissionFlagsBits, MessageFlags } from "discord.js";
+import { ModerationService } from "@/modules/moderation/moderation.service";
+import {
+    getWarnSuccessEmbed,
+    getModerationErrorEmbed,
+    getUserWarningEmbed
+} from "@/modules/moderation/moderation.view";
+import { config } from "@/lib/config";
+
+export const warn = createCommand({
+    data: new SlashCommandBuilder()
+        .setName("warn")
+        .setDescription("Issue a warning to a user")
+        .addUserOption(option =>
+            option
+                .setName("user")
+                .setDescription("The user to warn")
+                .setRequired(true)
+        )
+        .addStringOption(option =>
+            option
+                .setName("reason")
+                .setDescription("Reason for the warning")
+                .setRequired(true)
+                .setMaxLength(1000)
+        )
+        .setDefaultMemberPermissions(PermissionFlagsBits.Administrator),
+
+    execute: async (interaction) => {
+        await interaction.deferReply({ flags: MessageFlags.Ephemeral });
+
+        try {
+            const targetUser = interaction.options.getUser("user", true);
+            const reason = interaction.options.getString("reason", true);
+
+            // Don't allow warning bots
+            if (targetUser.bot) {
+                await interaction.editReply({
+                    embeds: [getModerationErrorEmbed("You cannot warn bots.")]
+                });
+                return;
+            }
+
+            // Don't allow self-warnings
+            if (targetUser.id === interaction.user.id) {
+                await interaction.editReply({
+                    embeds: [getModerationErrorEmbed("You cannot warn yourself.")]
+                });
+                return;
+            }
+
+            // Issue the warning via service
+            const { moderationCase, warningCount, autoTimeoutIssued } = await ModerationService.issueWarning({
+                userId: targetUser.id,
+                username: targetUser.username,
+                moderatorId: interaction.user.id,
+                moderatorName: interaction.user.username,
+                reason,
+                guildName: interaction.guild?.name || undefined,
+                dmTarget: targetUser,
+                timeoutTarget: await interaction.guild?.members.fetch(targetUser.id)
+            });
+
+            // Send success message to moderator
+            await interaction.editReply({
+                embeds: [getWarnSuccessEmbed(moderationCase.caseId, targetUser.username, reason)]
+            });
+
+            // Follow up if auto-timeout was issued
+            if (autoTimeoutIssued) {
+                await interaction.followUp({
+                    embeds: [getModerationErrorEmbed(
+                        `⚠️ User has reached ${warningCount} warnings and has been automatically timed out for 24 hours.`
+                    )],
+                    flags: MessageFlags.Ephemeral
+                });
+            }
+
+        } catch (error) {
+            console.error("Warn command error:", error);
+            await interaction.editReply({
+                embeds: [getModerationErrorEmbed("An error occurred while issuing the warning.")]
+            });
+        }
+    }
+});

src/commands/admin/warnings.ts

@@ -0,0 +1,39 @@
+import { createCommand } from "@/lib/utils";
+import { SlashCommandBuilder, PermissionFlagsBits, MessageFlags } from "discord.js";
+import { ModerationService } from "@/modules/moderation/moderation.service";
+import { getWarningsEmbed, getModerationErrorEmbed } from "@/modules/moderation/moderation.view";
+
+export const warnings = createCommand({
+    data: new SlashCommandBuilder()
+        .setName("warnings")
+        .setDescription("View active warnings for a user")
+        .addUserOption(option =>
+            option
+                .setName("user")
+                .setDescription("The user to check warnings for")
+                .setRequired(true)
+        )
+        .setDefaultMemberPermissions(PermissionFlagsBits.Administrator),
+
+    execute: async (interaction) => {
+        await interaction.deferReply({ flags: MessageFlags.Ephemeral });
+
+        try {
+            const targetUser = interaction.options.getUser("user", true);
+
+            // Get active warnings for the user
+            const activeWarnings = await ModerationService.getUserWarnings(targetUser.id);
+
+            // Display the warnings
+            await interaction.editReply({
+                embeds: [getWarningsEmbed(activeWarnings, targetUser.username)]
+            });
+
+        } catch (error) {
+            console.error("Warnings command error:", error);
+            await interaction.editReply({
+                embeds: [getModerationErrorEmbed("An error occurred while fetching warnings.")]
+            });
+        }
+    }
+});

src/commands/economy/balance.ts

@@ -23,6 +23,8 @@ export const balance = createCommand({
 
         const user = await userService.getOrCreateUser(targetUser.id, targetUser.username);
 
+        if (!user) throw new Error("Failed to retrieve user data.");
+
         const embed = createBaseEmbed(undefined, `**Balance**: ${user.balance || 0n} AU`, "Yellow")
             .setAuthor({ name: targetUser.username, iconURL: targetUser.displayAvatarURL() });
 

src/commands/economy/exam.ts

@@ -7,8 +7,9 @@ import { userTimers, users } from "@/db/schema";
 import { eq, and, sql } from "drizzle-orm";
 import { DrizzleClient } from "@/lib/DrizzleClient";
 import { config } from "@lib/config";
+import { TimerType } from "@/lib/constants";
 
-const EXAM_TIMER_TYPE = 'EXAM_SYSTEM';
+const EXAM_TIMER_TYPE = TimerType.EXAM_SYSTEM;
 const EXAM_TIMER_KEY = 'default';
 
 interface ExamMetadata {
@@ -25,6 +26,10 @@ export const exam = createCommand({
     execute: async (interaction) => {
         await interaction.deferReply();
         const user = await userService.getOrCreateUser(interaction.user.id, interaction.user.username);
+        if (!user) {
+            await interaction.editReply({ embeds: [createErrorEmbed("Failed to retrieve user data.")] });
+            return;
+        }
         const now = new Date();
         const currentDay = now.getDay();
 
@@ -43,11 +48,12 @@ export const exam = createCommand({
                 // Set exam day to today
                 const nextExamDate = new Date(now);
                 nextExamDate.setDate(now.getDate() + 7);
+                nextExamDate.setHours(0, 0, 0, 0);
                 const nextExamTimestamp = Math.floor(nextExamDate.getTime() / 1000);
 
                 const metadata: ExamMetadata = {
                     examDay: currentDay,
-                    lastXp: user.xp.toString()
+                    lastXp: (user.xp ?? 0n).toString()
                 };
 
                 await DrizzleClient.insert(userTimers).values({
@@ -61,7 +67,7 @@ export const exam = createCommand({
                 await interaction.editReply({
                     embeds: [createSuccessEmbed(
                         `You have registered for the exam! Your exam day is **${DAYS[currentDay]}** (Server Time).\n` +
-                        `Come back on <t:${nextExamTimestamp}:F> (<t:${nextExamTimestamp}:R>) to take your first exam!`,
+                        `Come back on <t:${nextExamTimestamp}:D> (<t:${nextExamTimestamp}:R>) to take your first exam!`,
                         "Exam Registration Successful"
                     )]
                 });
@@ -72,15 +78,17 @@ export const exam = createCommand({
             const examDay = metadata.examDay;
 
             // 3. Cooldown Check
-            if (now < new Date(timer.expiresAt)) {
-                // Calculate time remaining
             const expiresAt = new Date(timer.expiresAt);
+            expiresAt.setHours(0, 0, 0, 0);
+
+            if (now < expiresAt) {
+                // Calculate time remaining
                 const timestamp = Math.floor(expiresAt.getTime() / 1000);
 
                 await interaction.editReply({
                     embeds: [createErrorEmbed(
                         `You have already taken your exam for this week (or are waiting for your first week to pass).\n` +
-                        `Next exam available: <t:${timestamp}:F> (<t:${timestamp}:R>)`
+                        `Next exam available: <t:${timestamp}:D> (<t:${timestamp}:R>)`
                     )]
                 });
                 return;
@@ -94,11 +102,12 @@ export const exam = createCommand({
 
                 const nextExamDate = new Date(now);
                 nextExamDate.setDate(now.getDate() + daysUntil);
+                nextExamDate.setHours(0, 0, 0, 0);
                 const nextExamTimestamp = Math.floor(nextExamDate.getTime() / 1000);
 
                 const newMetadata: ExamMetadata = {
                     examDay: examDay,
-                    lastXp: user.xp.toString() // Reset tracking
+                    lastXp: (user.xp ?? 0n).toString()
                 };
 
                 await DrizzleClient.update(userTimers)
@@ -116,7 +125,7 @@ export const exam = createCommand({
                     embeds: [createErrorEmbed(
                         `You missed your exam day! Your exam day is **${DAYS[examDay]}** (Server Time).\n` +
                         `You verify your attendance but score a **0**.\n` +
-                        `Your next exam opportunity is: <t:${nextExamTimestamp}:F> (<t:${nextExamTimestamp}:R>)`,
+                        `Your next exam opportunity is: <t:${nextExamTimestamp}:D> (<t:${nextExamTimestamp}:R>)`,
                         "Exam Failed"
                     )]
                 });
@@ -125,7 +134,7 @@ export const exam = createCommand({
 
             // 5. Reward Calculation
             const lastXp = BigInt(metadata.lastXp || "0"); // Fallback just in case
-            const currentXp = user.xp;
+            const currentXp = user.xp ?? 0n;
             const diff = currentXp - lastXp;
 
             // Calculate Reward
@@ -143,6 +152,7 @@ export const exam = createCommand({
             // 6. Update State
             const nextExamDate = new Date(now);
             nextExamDate.setDate(now.getDate() + 7);
+            nextExamDate.setHours(0, 0, 0, 0);
             const nextExamTimestamp = Math.floor(nextExamDate.getTime() / 1000);
 
             const newMetadata: ExamMetadata = {
@@ -178,7 +188,7 @@ export const exam = createCommand({
                     `**XP Gained:** ${diff.toString()}\n` +
                     `**Multiplier:** x${multiplier.toFixed(2)}\n` +
                     `**Reward:** ${reward.toString()} Currency\n\n` +
-                    `See you next week: <t:${nextExamTimestamp}:F>`,
+                    `See you next week: <t:${nextExamTimestamp}:D>`,
                     "Exam Passed!"
                 )]
             });

src/commands/economy/pay.ts

@@ -33,6 +33,11 @@ export const pay = createCommand({
 
         const amount = BigInt(interaction.options.getInteger("amount", true));
         const senderId = interaction.user.id;
+        if (!targetUser) {
+            await interaction.reply({ embeds: [createErrorEmbed("User not found.")], flags: MessageFlags.Ephemeral });
+            return;
+        }
+
         const receiverId = targetUser.id;
 
         if (amount < config.economy.transfers.minAmount) {
@@ -40,14 +45,14 @@ export const pay = createCommand({
             return;
         }
 
-        if (senderId === receiverId) {
+        if (senderId === receiverId.toString()) {
             await interaction.reply({ embeds: [createErrorEmbed("You cannot pay yourself.")], flags: MessageFlags.Ephemeral });
             return;
         }
 
         try {
             await interaction.deferReply();
-            await economyService.transfer(senderId, receiverId, amount);
+            await economyService.transfer(senderId, receiverId.toString(), amount);
 
             const embed = createSuccessEmbed(`Successfully sent ** ${amount}** Astral Units to <@${targetUser.id}>.`, "💸 Transfer Successful");
             await interaction.editReply({ embeds: [embed], content: `<@${receiverId}>` });

src/commands/economy/trade.ts

@@ -1,6 +1,6 @@
 import { createCommand } from "@/lib/utils";
 import { SlashCommandBuilder, ChannelType, ThreadAutoArchiveDuration, MessageFlags } from "discord.js";
-import { TradeService } from "@/modules/trade/trade.service";
+import { tradeService } from "@/modules/trade/trade.service";
 import { getTradeDashboard } from "@/modules/trade/trade.view";
 import { createErrorEmbed, createWarningEmbed } from "@lib/embeds";
 
@@ -59,7 +59,7 @@ export const trade = createCommand({
         }
 
         // Setup Session
-        const session = TradeService.createSession(thread.id,
+        const session = tradeService.createSession(thread.id,
             { id: interaction.user.id, username: interaction.user.username },
             { id: targetUser.id, username: targetUser.username }
         );

src/commands/inventory/inventory.ts

@@ -2,7 +2,8 @@ import { createCommand } from "@/lib/utils";
 import { SlashCommandBuilder } from "discord.js";
 import { inventoryService } from "@/modules/inventory/inventory.service";
 import { userService } from "@/modules/user/user.service";
-import { createWarningEmbed, createBaseEmbed } from "@lib/embeds";
+import { createWarningEmbed } from "@lib/embeds";
+import { getInventoryEmbed } from "@/modules/inventory/inventory.view";
 
 export const inventory = createCommand({
     data: new SlashCommandBuilder()
@@ -24,18 +25,19 @@ export const inventory = createCommand({
         }
 
         const user = await userService.getOrCreateUser(targetUser.id, targetUser.username);
-        const items = await inventoryService.getInventory(user.id);
+        if (!user) {
+            await interaction.editReply({ embeds: [createWarningEmbed("Failed to load user data.", "Error")] });
+            return;
+        }
+
+        const items = await inventoryService.getInventory(user.id.toString());
 
         if (!items || items.length === 0) {
             await interaction.editReply({ embeds: [createWarningEmbed("Inventory is empty.", `${user.username}'s Inventory`)] });
             return;
         }
 
-        const description = items.map(entry => {
-            return `**${entry.item.name}** x${entry.quantity}`;
-        }).join("\n");
-
-        const embed = createBaseEmbed(`${user.username}'s Inventory`, description, "Blue");
+        const embed = getInventoryEmbed(items, user.username);
 
         await interaction.editReply({ embeds: [embed] });
     }

src/commands/inventory/use.ts

@@ -2,10 +2,8 @@ import { createCommand } from "@/lib/utils";
 import { SlashCommandBuilder } from "discord.js";
 import { inventoryService } from "@/modules/inventory/inventory.service";
 import { userService } from "@/modules/user/user.service";
-import { createErrorEmbed, createSuccessEmbed } from "@lib/embeds";
-import { inventory, items } from "@/db/schema";
-import { eq, and, like } from "drizzle-orm";
-import { DrizzleClient } from "@/lib/DrizzleClient";
+import { createErrorEmbed } from "@lib/embeds";
+import { getItemUseResultEmbed } from "@/modules/inventory/inventory.view";
 import type { ItemUsageData } from "@/lib/types";
 import { UserError } from "@/lib/errors";
 import { config } from "@/lib/config";
@@ -25,9 +23,13 @@ export const use = createCommand({
 
         const itemId = interaction.options.getNumber("item", true);
         const user = await userService.getOrCreateUser(interaction.user.id, interaction.user.username);
+        if (!user) {
+            await interaction.editReply({ embeds: [createErrorEmbed("Failed to load user data.")] });
+            return;
+        }
 
         try {
-            const result = await inventoryService.useItem(user.id, itemId);
+            const result = await inventoryService.useItem(user.id.toString(), itemId);
 
             const usageData = result.usageData;
             if (usageData) {
@@ -53,11 +55,7 @@ export const use = createCommand({
                 }
             }
 
-            const embed = createSuccessEmbed(
-                result.results.map(r => `• ${r}`).join("\n"),
-                `Used ${result.usageData.effects.length > 0 ? 'Item' : 'Item'}` // Generic title, improves below
-            );
-            embed.setTitle("Item Used!");
+            const embed = getItemUseResultEmbed(result.results, result.item);
 
             await interaction.editReply({ embeds: [embed] });
 
@@ -74,28 +72,8 @@ export const use = createCommand({
         const focusedValue = interaction.options.getFocused();
         const userId = interaction.user.id;
 
-        // Fetch owned items that match the search query
-        // We join with items table to filter by name directly in the database
-        const entries = await DrizzleClient.select({
-            quantity: inventory.quantity,
-            item: items
-        })
-            .from(inventory)
-            .innerJoin(items, eq(inventory.itemId, items.id))
-            .where(and(
-                eq(inventory.userId, BigInt(userId)),
-                like(items.name, `%${focusedValue}%`)
-            ))
-            .limit(20); // Fetch up to 20 matching items
+        const results = await inventoryService.getAutocompleteItems(userId, focusedValue);
 
-        const filtered = entries.filter(entry => {
-            const usageData = entry.item.usageData as ItemUsageData | null;
-            const isUsable = usageData && usageData.effects && usageData.effects.length > 0;
-            return isUsable;
-        });
-
-        await interaction.respond(
-            filtered.map(entry => ({ name: `${entry.item.name} (${entry.quantity})`, value: entry.item.id }))
-        );
+        await interaction.respond(results);
     }
 });

src/commands/leveling/leaderboard.ts

@@ -1,9 +1,10 @@
 import { createCommand } from "@/lib/utils";
 import { SlashCommandBuilder } from "discord.js";
 import { DrizzleClient } from "@/lib/DrizzleClient";
-import { users } from "@/db/schema";
-import { desc } from "drizzle-orm";
-import { createWarningEmbed, createBaseEmbed } from "@lib/embeds";
+import { users, items, inventory } from "@/db/schema";
+import { desc, sql, eq } from "drizzle-orm";
+import { createWarningEmbed } from "@lib/embeds";
+import { getLeaderboardEmbed } from "@/modules/leveling/leveling.view";
 
 export const leaderboard = createCommand({
     data: new SlashCommandBuilder()
@@ -11,36 +12,49 @@ export const leaderboard = createCommand({
         .setDescription("View the top players")
         .addStringOption(option =>
             option.setName("type")
-                .setDescription("Sort by XP or Balance")
+                .setDescription("Sort by XP, Balance, or Net Worth")
                 .setRequired(true)
                 .addChoices(
                     { name: "Level / XP", value: "xp" },
-                    { name: "Balance", value: "balance" }
+                    { name: "Balance", value: "balance" },
+                    { name: "Net Worth", value: "networth" }
                 )
         ),
     execute: async (interaction) => {
         await interaction.deferReply();
 
         const type = interaction.options.getString("type", true);
-        const isXp = type === "xp";
 
-        const leaders = await DrizzleClient.query.users.findMany({
+        let leaders;
+
+        if (type === 'networth') {
+            leaders = await DrizzleClient.select({
+                username: users.username,
+                level: users.level,
+                xp: users.xp,
+                balance: users.balance,
+                netWorth: sql<bigint>`${users.balance} + COALESCE(SUM(${items.price} * ${inventory.quantity}), 0)`.as('net_worth')
+            })
+                .from(users)
+                .leftJoin(inventory, eq(users.id, inventory.userId))
+                .leftJoin(items, eq(inventory.itemId, items.id))
+                .groupBy(users.id)
+                .orderBy(desc(sql`net_worth`))
+                .limit(10);
+        } else {
+            const isXp = type === "xp";
+            leaders = await DrizzleClient.query.users.findMany({
                 orderBy: isXp ? desc(users.xp) : desc(users.balance),
                 limit: 10
             });
+        }
 
         if (leaders.length === 0) {
             await interaction.editReply({ embeds: [createWarningEmbed("No users found.", "Leaderboard")] });
             return;
         }
 
-        const description = leaders.map((user, index) => {
-            const medal = index === 0 ? "🥇" : index === 1 ? "🥈" : index === 2 ? "🥉" : `${index + 1}.`;
-            const value = isXp ? `Lvl ${user.level} (${user.xp} XP)` : `${user.balance} 🪙`;
-            return `${medal} **${user.username}** — ${value}`;
-        }).join("\n");
-
-        const embed = createBaseEmbed(isXp ? "🏆 XP Leaderboard" : "💰 Richest Players", description, "Gold");
+        const embed = getLeaderboardEmbed(leaders, type as 'xp' | 'balance' | 'networth');
 
         await interaction.editReply({ embeds: [embed] });
     }

src/commands/quest/quests.ts

@@ -1,7 +1,8 @@
 import { createCommand } from "@/lib/utils";
 import { SlashCommandBuilder, MessageFlags } from "discord.js";
 import { questService } from "@/modules/quest/quest.service";
-import { createWarningEmbed, createBaseEmbed } from "@lib/embeds";
+import { createWarningEmbed } from "@lib/embeds";
+import { getQuestListEmbed } from "@/modules/quest/quest.view";
 
 export const quests = createCommand({
     data: new SlashCommandBuilder()
@@ -17,21 +18,7 @@ export const quests = createCommand({
             return;
         }
 
-        const embed = createBaseEmbed("📜 Quest Log", undefined, "Blue");
-
-        userQuests.forEach(entry => {
-            const status = entry.completedAt ? "✅ Completed" : "In Progress";
-            const rewards = entry.quest.rewards as { xp?: number, balance?: number };
-            const rewardStr = [];
-            if (rewards?.xp) rewardStr.push(`${rewards.xp} XP`);
-            if (rewards?.balance) rewardStr.push(`${rewards.balance} 🪙`);
-
-            embed.addFields({
-                name: `${entry.quest.name} (${status})`,
-                value: `${entry.quest.description}\n**Rewards:** ${rewardStr.join(", ")}\n**Progress:** ${entry.progress}%`,
-                inline: false
-            });
-        });
+        const embed = getQuestListEmbed(userQuests);
 
         await interaction.editReply({ embeds: [embed] });
     }

src/db/indexes.test.ts

@@ -0,0 +1,43 @@
+import { expect, test, describe } from "bun:test";
+import { postgres } from "../lib/DrizzleClient";
+
+describe("Database Indexes", () => {
+    test("should have indexes on users table", async () => {
+        const result = await postgres`
+            SELECT indexname FROM pg_indexes 
+            WHERE tablename = 'users'
+        `;
+        const indexNames = (result as unknown as { indexname: string }[]).map(r => r.indexname);
+        expect(indexNames).toContain("users_balance_idx");
+        expect(indexNames).toContain("users_level_xp_idx");
+    });
+
+    test("should have index on transactions table", async () => {
+        const result = await postgres`
+            SELECT indexname FROM pg_indexes 
+            WHERE tablename = 'transactions'
+        `;
+        const indexNames = (result as unknown as { indexname: string }[]).map(r => r.indexname);
+        expect(indexNames).toContain("transactions_created_at_idx");
+    });
+
+    test("should have indexes on moderation_cases table", async () => {
+        const result = await postgres`
+            SELECT indexname FROM pg_indexes 
+            WHERE tablename = 'moderation_cases'
+        `;
+        const indexNames = (result as unknown as { indexname: string }[]).map(r => r.indexname);
+        expect(indexNames).toContain("moderation_cases_user_id_idx");
+        expect(indexNames).toContain("moderation_cases_case_id_idx");
+    });
+
+    test("should have indexes on user_timers table", async () => {
+        const result = await postgres`
+            SELECT indexname FROM pg_indexes 
+            WHERE tablename = 'user_timers'
+        `;
+        const indexNames = (result as unknown as { indexname: string }[]).map(r => r.indexname);
+        expect(indexNames).toContain("user_timers_expires_at_idx");
+        expect(indexNames).toContain("user_timers_lookup_idx");
+    });
+});

src/db/schema.ts

@@ -9,6 +9,7 @@ import {
     text,
     integer,
     primaryKey,
+    index,
     bigserial,
     check
 } from 'drizzle-orm/pg-core';
@@ -41,7 +42,11 @@ export const users = pgTable('users', {
     settings: jsonb('settings').default({}),
     createdAt: timestamp('created_at', { withTimezone: true }).defaultNow(),
     updatedAt: timestamp('updated_at', { withTimezone: true }).defaultNow(),
-});
+}, (table) => [
+    index('users_username_idx').on(table.username),
+    index('users_balance_idx').on(table.balance),
+    index('users_level_xp_idx').on(table.level, table.xp),
+]);
 
 // 3. Items
 export const items = pgTable('items', {
@@ -82,7 +87,9 @@ export const transactions = pgTable('transactions', {
     type: varchar('type', { length: 50 }).notNull(),
     description: text('description'),
     createdAt: timestamp('created_at', { withTimezone: true }).defaultNow(),
-});
+}, (table) => [
+    index('transactions_created_at_idx').on(table.createdAt),
+]);
 
 export const itemTransactions = pgTable('item_transactions', {
     id: bigserial('id', { mode: 'bigint' }).primaryKey(),
@@ -129,7 +136,9 @@ export const userTimers = pgTable('user_timers', {
     expiresAt: timestamp('expires_at', { withTimezone: true }).notNull(),
     metadata: jsonb('metadata').default({}), // Store channelId, specific buff amounts, etc.
 }, (table) => [
-    primaryKey({ columns: [table.userId, table.type, table.key] })
+    primaryKey({ columns: [table.userId, table.type, table.key] }),
+    index('user_timers_expires_at_idx').on(table.expiresAt),
+    index('user_timers_lookup_idx').on(table.userId, table.type, table.key),
 ]);
 // 9. Lootdrops
 export const lootdrops = pgTable('lootdrops', {
@@ -142,6 +151,28 @@ export const lootdrops = pgTable('lootdrops', {
     expiresAt: timestamp('expires_at', { withTimezone: true }),
 });
 
+// 10. Moderation Cases
+export const moderationCases = pgTable('moderation_cases', {
+    id: bigserial('id', { mode: 'bigint' }).primaryKey(),
+    caseId: varchar('case_id', { length: 50 }).unique().notNull(),
+    type: varchar('type', { length: 20 }).notNull(), // 'warn', 'timeout', 'kick', 'ban', 'note', 'prune'
+    userId: bigint('user_id', { mode: 'bigint' }).notNull(),
+    username: varchar('username', { length: 255 }).notNull(),
+    moderatorId: bigint('moderator_id', { mode: 'bigint' }).notNull(),
+    moderatorName: varchar('moderator_name', { length: 255 }).notNull(),
+    reason: text('reason').notNull(),
+    metadata: jsonb('metadata').default({}),
+    active: boolean('active').default(true).notNull(),
+    createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull(),
+    resolvedAt: timestamp('resolved_at', { withTimezone: true }),
+    resolvedBy: bigint('resolved_by', { mode: 'bigint' }),
+    resolvedReason: text('resolved_reason'),
+}, (table) => [
+    index('moderation_cases_user_id_idx').on(table.userId),
+    index('moderation_cases_case_id_idx').on(table.caseId),
+]);
+
+
 
 export const classesRelations = relations(classes, ({ many }) => ({
     users: many(users),
@@ -216,3 +247,18 @@ export const itemTransactionsRelations = relations(itemTransactions, ({ one }) =
         references: [items.id],
     }),
 }));
+
+export const moderationCasesRelations = relations(moderationCases, ({ one }) => ({
+    user: one(users, {
+        fields: [moderationCases.userId],
+        references: [users.id],
+    }),
+    moderator: one(users, {
+        fields: [moderationCases.moderatorId],
+        references: [users.id],
+    }),
+    resolver: one(users, {
+        fields: [moderationCases.resolvedBy],
+        references: [users.id],
+    }),
+}));

src/events/interactionCreate.ts

@@ -1,72 +1,20 @@
-import { Events, MessageFlags } from "discord.js";
-import { AuroraClient } from "@/lib/BotClient";
-import { userService } from "@/modules/user/user.service";
-import { createErrorEmbed } from "@lib/embeds";
+import { Events } from "discord.js";
+import { ComponentInteractionHandler, AutocompleteHandler, CommandHandler } from "@/lib/handlers";
 import type { Event } from "@lib/types";
 
 const event: Event<Events.InteractionCreate> = {
     name: Events.InteractionCreate,
     execute: async (interaction) => {
-        // Handle Trade Interactions
         if (interaction.isButton() || interaction.isStringSelectMenu() || interaction.isModalSubmit()) {
-            const { interactionRoutes } = await import("@lib/interaction.routes");
-
-            for (const route of interactionRoutes) {
-                if (route.predicate(interaction)) {
-                    const module = await route.handler();
-                    const handlerMethod = module[route.method];
-                    if (typeof handlerMethod === 'function') {
-                        await handlerMethod(interaction);
-                        return;
-                    } else {
-                        console.error(`Handler method ${route.method} not found in module`);
-                    }
-                }
-            }
+            return ComponentInteractionHandler.handle(interaction);
         }
 
         if (interaction.isAutocomplete()) {
-            const command = AuroraClient.commands.get(interaction.commandName);
-            if (!command || !command.autocomplete) return;
-            try {
-                await command.autocomplete(interaction);
-            } catch (error) {
-                console.error(`Error handling autocomplete for ${interaction.commandName}:`, error);
-            }
-            return;
+            return AutocompleteHandler.handle(interaction);
         }
 
-        if (!interaction.isChatInputCommand()) return;
-
-        const command = AuroraClient.commands.get(interaction.commandName);
-
-        if (!command) {
-            console.error(`No command matching ${interaction.commandName} was found.`);
-            return;
-        }
-
-
-        // Ensure user exists in database
-        try {
-            const user = await userService.getUserById(interaction.user.id);
-            if (!user) {
-                console.log(`🆕 Creating new user entry for ${interaction.user.tag}`);
-                await userService.createUser(interaction.user.id, interaction.user.username);
-            }
-        } catch (error) {
-            console.error("Failed to check/create user:", error);
-        }
-
-        try {
-            await command.execute(interaction);
-        } catch (error) {
-            console.error(error);
-            const errorEmbed = createErrorEmbed('There was an error while executing this command!');
-            if (interaction.replied || interaction.deferred) {
-                await interaction.followUp({ embeds: [errorEmbed], flags: MessageFlags.Ephemeral });
-            } else {
-                await interaction.reply({ embeds: [errorEmbed], flags: MessageFlags.Ephemeral });
-            }
+        if (interaction.isChatInputCommand()) {
+            return CommandHandler.handle(interaction);
         }
     },
 };

src/graphics/lootdrop.ts

@@ -0,0 +1,135 @@
+import { GlobalFonts, createCanvas, loadImage } from '@napi-rs/canvas';
+import path from 'path';
+
+// Register Fonts (same as studentID.ts)
+const fontDir = path.join(process.cwd(), 'src', 'assets', 'fonts');
+GlobalFonts.registerFromPath(path.join(fontDir, 'IBMPlexSansCondensed-SemiBold.ttf'), 'IBMPlexSansCondensed-SemiBold');
+GlobalFonts.registerFromPath(path.join(fontDir, 'IBMPlexMono-Bold.ttf'), 'IBMPlexMono-Bold');
+
+export async function generateLootdropCard(amount: number, currency: string): Promise<Buffer> {
+    const templatePath = path.join(process.cwd(), 'src', 'assets', 'graphics', 'lootdrop', 'template.png');
+    const template = await loadImage(templatePath);
+
+    const canvas = createCanvas(template.width, template.height);
+    const ctx = canvas.getContext('2d');
+
+    // Draw Template
+    ctx.drawImage(template, 0, 0);
+
+    // Draw Lootdrop Text (Title-ish)
+    ctx.save();
+    ctx.font = '48px IBMPlexSansCondensed-SemiBold';
+    ctx.fillStyle = '#FFFFFF';
+    ctx.textAlign = 'center';
+    ctx.shadowBlur = 10;
+    ctx.shadowColor = 'rgba(255, 255, 255, 0.5)';
+    // Center of lower half (512-1024) is roughly 768
+    ctx.fillText('A STAR IS FALLING', canvas.width / 2, 660);
+    ctx.restore();
+
+    // Draw Reward Amount
+    ctx.save();
+    ctx.font = '72px IBMPlexMono-Bold';
+    ctx.fillStyle = '#DAC7A1';
+    ctx.textAlign = 'center';
+    //ctx.shadowBlur = 15;
+    //ctx.shadowColor = 'rgba(255, 215, 0, 0.8)';
+    ctx.fillText(`${amount} ${currency}`, canvas.width / 2, 760); // Below title
+    ctx.restore();
+
+    // Crop the image by 64px on all sides
+    const croppedWidth = template.width - 128;
+    const croppedHeight = template.height - 128;
+    const croppedCanvas = createCanvas(croppedWidth, croppedHeight);
+    const croppedCtx = croppedCanvas.getContext('2d');
+
+    // Draw the original canvas onto the cropped canvas, shifted by -64
+    croppedCtx.drawImage(canvas, -64, -64);
+
+    return croppedCanvas.toBuffer('image/png');
+}
+
+export async function generateClaimedLootdropCard(amount: number, currency: string, username: string, avatarUrl: string): Promise<Buffer> {
+    const templatePath = path.join(process.cwd(), 'src', 'assets', 'graphics', 'lootdrop', 'template.png');
+    const template = await loadImage(templatePath);
+
+    const canvas = createCanvas(template.width, template.height);
+    const ctx = canvas.getContext('2d');
+
+    // Draw Template
+    ctx.drawImage(template, 0, 0);
+
+    // Add a colored overlay to signify "claimed"
+    ctx.fillStyle = 'rgba(10, 10, 20, 0.85)';
+    ctx.fillRect(0, 0, canvas.width, canvas.height);
+
+    // Draw Claimed Text (Title-ish)
+    ctx.save();
+    ctx.font = '48px IBMPlexSansCondensed-SemiBold';
+    ctx.fillStyle = '#FFFFFF';
+    ctx.textAlign = 'center';
+    ctx.shadowBlur = 10;
+    ctx.shadowColor = 'rgba(255, 255, 255, 0.5)';
+    ctx.fillText('STAR CLAIMED', canvas.width / 2, 660);
+    ctx.restore();
+
+    // Draw "by username" with Avatar
+    ctx.save();
+    ctx.font = '36px IBMPlexSansCondensed-SemiBold';
+    ctx.fillStyle = '#AAAAAA';
+
+    // Calculate layout for centering Group (Avatar + Text)
+    const text = `by ${username}`;
+    const textMetrics = ctx.measureText(text);
+    const textWidth = textMetrics.width;
+    const avatarSize = 50;
+    const gap = 15;
+    const totalWidth = avatarSize + gap + textWidth;
+
+    const startX = (canvas.width - totalWidth) / 2;
+    const baselineY = 830;
+
+    // Draw Avatar
+    try {
+        const avatar = await loadImage(avatarUrl);
+        ctx.save();
+        ctx.beginPath();
+        // Center avatar vertically relative to text roughly (baseline - ~half cap height)
+        // 36px text ~ 27px cap height. Center roughly at baselineY - 14
+        const avatarCenterY = baselineY - 14;
+        ctx.arc(startX + avatarSize / 2, avatarCenterY, avatarSize / 2, 0, Math.PI * 2);
+        ctx.closePath();
+        ctx.clip();
+        ctx.drawImage(avatar, startX, avatarCenterY - avatarSize / 2, avatarSize, avatarSize);
+        ctx.restore();
+    } catch (e) {
+        // Fallback if avatar fails to load, just don't draw it (or maybe shift text?)
+        // For now, let's just proceed, the text will be off-center if avatar is missing but that's acceptable edge case
+        console.error("Failed to load avatar", e);
+    }
+
+    // Draw Text
+    ctx.textAlign = 'left';
+    ctx.fillText(text, startX + avatarSize + gap, baselineY);
+    ctx.restore();
+
+    ctx.save();
+    ctx.font = '72px IBMPlexMono-Bold'; // Match Amount size
+    ctx.fillStyle = '#E6D2B5'; // Lighter gold/beige for better contrast
+    ctx.textAlign = 'center';
+    ctx.shadowBlur = 10;
+    ctx.shadowColor = 'rgba(0, 0, 0, 0.8)'; // Dark shadow for contrast
+    ctx.fillText(`${amount} ${currency}`, canvas.width / 2, 760); // Same position as Unclaimed Amount
+    ctx.restore();
+
+    // Crop the image by 64px on all sides
+    const croppedWidth = template.width - 128;
+    const croppedHeight = template.height - 128;
+    const croppedCanvas = createCanvas(croppedWidth, croppedHeight);
+    const croppedCtx = croppedCanvas.getContext('2d');
+
+    // Draw the original canvas onto the cropped canvas, shifted by -64
+    croppedCtx.drawImage(canvas, -64, -64);
+
+    return croppedCanvas.toBuffer('image/png');
+}

src/index.ts

@@ -1,14 +1,26 @@
 import { AuroraClient } from "@/lib/BotClient";
 import { env } from "@lib/env";
 
+import { WebServer } from "@/web/server";
+
 // Load commands & events
 await AuroraClient.loadCommands();
 await AuroraClient.loadEvents();
 await AuroraClient.deployCommands();
 
+WebServer.start();
 
 // login with the token from .env
 if (!env.DISCORD_BOT_TOKEN) {
     throw new Error("❌ DISCORD_BOT_TOKEN is not set in environment variables.");
 }
 AuroraClient.login(env.DISCORD_BOT_TOKEN);
+
+// Handle graceful shutdown
+const shutdownHandler = () => {
+    WebServer.stop();
+    AuroraClient.shutdown();
+};
+
+process.on("SIGINT", shutdownHandler);
+process.on("SIGTERM", shutdownHandler);

src/lib/BotClient.ts

@@ -1,145 +1,56 @@
 import { Client as DiscordClient, Collection, GatewayIntentBits, REST, Routes } from "discord.js";
-import { readdir } from "node:fs/promises";
 import { join } from "node:path";
-import type { Command, Event } from "@lib/types";
+import type { Command } from "@lib/types";
 import { env } from "@lib/env";
-import { config } from "@lib/config";
+import { CommandLoader } from "@lib/loaders/CommandLoader";
+import { EventLoader } from "@lib/loaders/EventLoader";
+import { logger } from "@lib/logger";
 
-class Client extends DiscordClient {
+export class Client extends DiscordClient {
 
     commands: Collection<string, Command>;
+    lastCommandTimestamp: number | null = null;
+    private commandLoader: CommandLoader;
+    private eventLoader: EventLoader;
 
     constructor({ intents }: { intents: number[] }) {
         super({ intents });
         this.commands = new Collection<string, Command>();
+        this.commandLoader = new CommandLoader(this);
+        this.eventLoader = new EventLoader(this);
     }
 
     async loadCommands(reload: boolean = false) {
         if (reload) {
             this.commands.clear();
-            console.log("♻️  Reloading commands...");
+            logger.info("♻️  Reloading commands...");
         }
 
         const commandsPath = join(import.meta.dir, '../commands');
-        await this.readCommandsRecursively(commandsPath, reload);
+        const result = await this.commandLoader.loadFromDirectory(commandsPath, reload);
+
+        logger.info(`📦 Command loading complete: ${result.loaded} loaded, ${result.skipped} skipped, ${result.errors.length} errors`);
     }
 
     async loadEvents(reload: boolean = false) {
         if (reload) {
             this.removeAllListeners();
-            console.log("♻️  Reloading events...");
+            logger.info("♻️  Reloading events...");
         }
 
         const eventsPath = join(import.meta.dir, '../events');
-        await this.readEventsRecursively(eventsPath, reload);
+        const result = await this.eventLoader.loadFromDirectory(eventsPath, reload);
+
+        logger.info(`📦 Event loading complete: ${result.loaded} loaded, ${result.skipped} skipped, ${result.errors.length} errors`);
     }
 
-    private async readCommandsRecursively(dir: string, reload: boolean = false) {
-        try {
-            const files = await readdir(dir, { withFileTypes: true });
 
-            for (const file of files) {
-                const filePath = join(dir, file.name);
-
-                if (file.isDirectory()) {
-                    await this.readCommandsRecursively(filePath, reload);
-                    continue;
-                }
-
-                if (!file.name.endsWith('.ts') && !file.name.endsWith('.js')) continue;
-
-                try {
-                    const importPath = reload ? `${filePath}?t=${Date.now()}` : filePath;
-                    const commandModule = await import(importPath);
-                    const commands = Object.values(commandModule);
-                    if (commands.length === 0) {
-                        console.warn(`⚠️  No commands found in ${file.name}`);
-                        continue;
-                    }
-
-                    // Extract category from parent directory name
-                    // filePath is like /path/to/commands/admin/features.ts
-                    // we want "admin"
-                    const pathParts = filePath.split('/');
-                    const category = pathParts[pathParts.length - 2];
-
-                    for (const command of commands) {
-                        if (this.isValidCommand(command)) {
-                            command.category = category; // Inject category
-
-                            const isEnabled = config.commands[command.data.name] !== false; // Default true if undefined
-
-                            if (!isEnabled) {
-                                console.log(`🚫 Skipping disabled command: ${command.data.name}`);
-                                continue;
-                            }
-
-                            this.commands.set(command.data.name, command);
-                            console.log(`✅ Loaded command: ${command.data.name}`);
-                        } else {
-                            console.warn(`⚠️  Skipping invalid command in ${file.name}`);
-                        }
-                    }
-                } catch (error) {
-                    console.error(`❌ Failed to load command from ${filePath}:`, error);
-                }
-            }
-        } catch (error) {
-            console.error(`Error reading directory ${dir}:`, error);
-        }
-    }
-
-    private async readEventsRecursively(dir: string, reload: boolean = false) {
-        try {
-            const files = await readdir(dir, { withFileTypes: true });
-
-            for (const file of files) {
-                const filePath = join(dir, file.name);
-
-                if (file.isDirectory()) {
-                    await this.readEventsRecursively(filePath, reload);
-                    continue;
-                }
-
-                if (!file.name.endsWith('.ts') && !file.name.endsWith('.js')) continue;
-
-                try {
-                    const importPath = reload ? `${filePath}?t=${Date.now()}` : filePath;
-                    const eventModule = await import(importPath);
-                    const event = eventModule.default;
-
-                    if (this.isValidEvent(event)) {
-                        if (event.once) {
-                            this.once(event.name, (...args) => event.execute(...args));
-                        } else {
-                            this.on(event.name, (...args) => event.execute(...args));
-                        }
-                        console.log(`✅ Loaded event: ${event.name}`);
-                    } else {
-                        console.warn(`⚠️  Skipping invalid event in ${file.name}`);
-                    }
-                } catch (error) {
-                    console.error(`❌ Failed to load event from ${filePath}:`, error);
-                }
-            }
-        } catch (error) {
-            console.error(`Error reading directory ${dir}:`, error);
-        }
-    }
-
-    private isValidCommand(command: any): command is Command {
-        return command && typeof command === 'object' && 'data' in command && 'execute' in command;
-    }
-
-    private isValidEvent(event: any): event is Event<any> {
-        return event && typeof event === 'object' && 'name' in event && 'execute' in event;
-    }
 
     async deployCommands() {
         // We use env.DISCORD_BOT_TOKEN directly so this can run without client.login()
         const token = env.DISCORD_BOT_TOKEN;
         if (!token) {
-            console.error("❌ DISCORD_BOT_TOKEN is not set.");
+            logger.error("DISCORD_BOT_TOKEN is not set.");
             return;
         }
 
@@ -149,16 +60,16 @@ class Client extends DiscordClient {
         const clientId = env.DISCORD_CLIENT_ID;
 
         if (!clientId) {
-            console.error("❌ DISCORD_CLIENT_ID is not set.");
+            logger.error("DISCORD_CLIENT_ID is not set.");
             return;
         }
 
         try {
-            console.log(`Started refreshing ${commandsData.length} application (/) commands.`);
+            logger.info(`Started refreshing ${commandsData.length} application (/) commands.`);
 
             let data;
             if (guildId) {
-                console.log(`Registering commands to guild: ${guildId}`);
+                logger.info(`Registering commands to guild: ${guildId}`);
                 data = await rest.put(
                     Routes.applicationGuildCommands(clientId, guildId),
                     { body: commandsData },
@@ -166,23 +77,46 @@ class Client extends DiscordClient {
                 // Clear global commands to avoid duplicates
                 await rest.put(Routes.applicationCommands(clientId), { body: [] });
             } else {
-                console.log('Registering commands globally');
+                logger.info('Registering commands globally');
                 data = await rest.put(
                     Routes.applicationCommands(clientId),
                     { body: commandsData },
                 );
             }
 
-            console.log(`✅ Successfully reloaded ${(data as any).length} application (/) commands.`);
+            logger.success(`Successfully reloaded ${(data as any).length} application (/) commands.`);
         } catch (error: any) {
             if (error.code === 50001) {
-                console.warn("⚠️  Missing Access: The bot is not in the guild or lacks 'applications.commands' scope.");
-                console.warn("   If you are testing locally, make sure you invited the bot with scope 'bot applications.commands'.");
+                logger.warn("Missing Access: The bot is not in the guild or lacks 'applications.commands' scope.");
+                logger.warn("   If you are testing locally, make sure you invited the bot with scope 'bot applications.commands'.");
             } else {
-                console.error(error);
+                logger.error(error);
             }
         }
     }
+
+    async shutdown() {
+        const { setShuttingDown, waitForTransactions } = await import("./shutdown");
+        const { closeDatabase } = await import("./DrizzleClient");
+
+        logger.info("🛑 Shutdown signal received. Starting graceful shutdown...");
+        setShuttingDown(true);
+
+        // Wait for transactions to complete
+        logger.info("⏳ Waiting for active transactions to complete...");
+        await waitForTransactions(10000);
+
+        // Destroy Discord client
+        logger.info("🔌 Disconnecting from Discord...");
+        this.destroy();
+
+        // Close database
+        logger.info("🗄️ Closing database connection...");
+        await closeDatabase();
+
+        logger.success("👋 Graceful shutdown complete. Exiting.");
+        process.exit(0);
+    }
 }
 
 export const AuroraClient = new Client({ intents: [GatewayIntentBits.Guilds, GatewayIntentBits.MessageContent, GatewayIntentBits.GuildMessages, GatewayIntentBits.GuildMembers] });

src/lib/DrizzleClient.ts

@@ -4,6 +4,10 @@ import * as schema from "@db/schema";
 import { env } from "@lib/env";
 
 const connectionString = env.DATABASE_URL;
-const postgres = new SQL(connectionString);
+export const postgres = new SQL(connectionString);
 
 export const DrizzleClient = drizzle(postgres, { schema });
+
+export const closeDatabase = async () => {
+    await postgres.close();
+};

src/lib/config.ts

@@ -63,7 +63,13 @@ export interface GameConfigType {
             batchSize: number;
             batchDelayMs: number;
         };
+        cases: {
+            dmOnWarn: boolean;
+            logChannelId?: string;
+            autoTimeoutThreshold?: number;
         };
+    };
+    system: Record<string, any>;
 }
 
 // Initial default config state
@@ -139,6 +145,11 @@ const configSchema = z.object({
             confirmThreshold: z.number().default(50),
             batchSize: z.number().default(100),
             batchDelayMs: z.number().default(1000)
+        }),
+        cases: z.object({
+            dmOnWarn: z.boolean().default(true),
+            logChannelId: z.string().optional(),
+            autoTimeoutThreshold: z.number().optional()
         })
     }).default({
         prune: {
@@ -146,8 +157,12 @@ const configSchema = z.object({
             confirmThreshold: 50,
             batchSize: 100,
             batchDelayMs: 1000
+        },
+        cases: {
+            dmOnWarn: true
         }
-    })
+    }),
+    system: z.record(z.string(), z.any()).default({}),
 });
 
 export function reloadConfig() {

src/lib/constants.ts

@@ -0,0 +1,65 @@
+/**
+ * Global Constants and Enums
+ */
+
+export enum TimerType {
+    COOLDOWN = 'COOLDOWN',
+    EFFECT = 'EFFECT',
+    ACCESS = 'ACCESS',
+    EXAM_SYSTEM = 'EXAM_SYSTEM',
+}
+
+export enum EffectType {
+    ADD_XP = 'ADD_XP',
+    ADD_BALANCE = 'ADD_BALANCE',
+    REPLY_MESSAGE = 'REPLY_MESSAGE',
+    XP_BOOST = 'XP_BOOST',
+    TEMP_ROLE = 'TEMP_ROLE',
+    COLOR_ROLE = 'COLOR_ROLE',
+    LOOTBOX = 'LOOTBOX',
+}
+
+export enum TransactionType {
+    TRANSFER_IN = 'TRANSFER_IN',
+    TRANSFER_OUT = 'TRANSFER_OUT',
+    DAILY_REWARD = 'DAILY_REWARD',
+    ITEM_USE = 'ITEM_USE',
+    LOOTBOX = 'LOOTBOX',
+    EXAM_REWARD = 'EXAM_REWARD',
+    PURCHASE = 'PURCHASE',
+    TRADE_IN = 'TRADE_IN',
+    TRADE_OUT = 'TRADE_OUT',
+    QUEST_REWARD = 'QUEST_REWARD',
+}
+
+export enum ItemTransactionType {
+    TRADE_IN = 'TRADE_IN',
+    TRADE_OUT = 'TRADE_OUT',
+    SHOP_BUY = 'SHOP_BUY',
+    DROP = 'DROP',
+    GIVE = 'GIVE',
+    USE = 'USE',
+}
+
+export enum ItemType {
+    MATERIAL = 'MATERIAL',
+    CONSUMABLE = 'CONSUMABLE',
+    EQUIPMENT = 'EQUIPMENT',
+    QUEST = 'QUEST',
+}
+
+export enum CaseType {
+    WARN = 'warn',
+    TIMEOUT = 'timeout',
+    KICK = 'kick',
+    BAN = 'ban',
+    NOTE = 'note',
+    PRUNE = 'prune',
+}
+
+export enum LootType {
+    NOTHING = 'NOTHING',
+    CURRENCY = 'CURRENCY',
+    XP = 'XP',
+    ITEM = 'ITEM',
+}

src/lib/db.test.ts

@@ -0,0 +1,47 @@
+import { describe, it, expect, mock, beforeEach } from "bun:test";
+
+// Mock DrizzleClient
+mock.module("./DrizzleClient", () => ({
+    DrizzleClient: {
+        transaction: async (cb: any) => cb("MOCK_TX")
+    }
+}));
+
+import { withTransaction } from "./db";
+import { setShuttingDown, getActiveTransactions, decrementTransactions } from "./shutdown";
+
+describe("db withTransaction", () => {
+    beforeEach(() => {
+        setShuttingDown(false);
+        // Reset transaction count
+        while (getActiveTransactions() > 0) {
+            decrementTransactions();
+        }
+    });
+
+    it("should allow transactions when not shutting down", async () => {
+        const result = await withTransaction(async (tx) => {
+            return "success";
+        });
+        expect(result).toBe("success");
+        expect(getActiveTransactions()).toBe(0);
+    });
+
+    it("should throw error when shutting down", async () => {
+        setShuttingDown(true);
+        expect(withTransaction(async (tx) => {
+            return "success";
+        })).rejects.toThrow("System is shutting down, no new transactions allowed.");
+        expect(getActiveTransactions()).toBe(0);
+    });
+
+    it("should increment and decrement transaction count", async () => {
+        let countDuring = 0;
+        await withTransaction(async (tx) => {
+            countDuring = getActiveTransactions();
+            return "ok";
+        });
+        expect(countDuring).toBe(1);
+        expect(getActiveTransactions()).toBe(0);
+    });
+});

src/lib/db.ts

@@ -1,5 +1,6 @@
 import { DrizzleClient } from "./DrizzleClient";
 import type { Transaction } from "./types";
+import { isShuttingDown, incrementTransactions, decrementTransactions } from "./shutdown";
 
 export const withTransaction = async <T>(
     callback: (tx: Transaction) => Promise<T>,
@@ -8,8 +9,17 @@ export const withTransaction = async <T>(
     if (tx) {
         return await callback(tx);
     } else {
+        if (isShuttingDown()) {
+            throw new Error("System is shutting down, no new transactions allowed.");
+        }
+
+        incrementTransactions();
+        try {
             return await DrizzleClient.transaction(async (newTx) => {
                 return await callback(newTx);
             });
+        } finally {
+            decrementTransactions();
+        }
     }
 };

src/lib/env.ts

@@ -5,6 +5,7 @@ const envSchema = z.object({
     DISCORD_CLIENT_ID: z.string().optional(),
     DISCORD_GUILD_ID: z.string().optional(),
     DATABASE_URL: z.string().min(1, "Database URL is required"),
+    PORT: z.coerce.number().default(3000),
 });
 
 const parsedEnv = envSchema.safeParse(process.env);

src/lib/handlers/AutocompleteHandler.ts

@@ -0,0 +1,22 @@
+import { AutocompleteInteraction } from "discord.js";
+import { AuroraClient } from "@/lib/BotClient";
+import { logger } from "@lib/logger";
+
+/**
+ * Handles autocomplete interactions for slash commands
+ */
+export class AutocompleteHandler {
+    static async handle(interaction: AutocompleteInteraction): Promise<void> {
+        const command = AuroraClient.commands.get(interaction.commandName);
+
+        if (!command || !command.autocomplete) {
+            return;
+        }
+
+        try {
+            await command.autocomplete(interaction);
+        } catch (error) {
+            logger.error(`Error handling autocomplete for ${interaction.commandName}:`, error);
+        }
+    }
+}

src/lib/handlers/CommandHandler.test.ts

@@ -0,0 +1,59 @@
+import { describe, test, expect, mock, beforeEach } from "bun:test";
+import { CommandHandler } from "./CommandHandler";
+import { AuroraClient } from "@/lib/BotClient";
+import { ChatInputCommandInteraction } from "discord.js";
+
+// Mock UserService
+mock.module("@/modules/user/user.service", () => ({
+    userService: {
+        getOrCreateUser: mock(() => Promise.resolve())
+    }
+}));
+
+describe("CommandHandler", () => {
+    beforeEach(() => {
+        AuroraClient.commands.clear();
+        AuroraClient.lastCommandTimestamp = null;
+    });
+
+    test("should update lastCommandTimestamp on successful execution", async () => {
+        const executeSuccess = mock(() => Promise.resolve());
+        AuroraClient.commands.set("test", {
+            data: { name: "test" } as any,
+            execute: executeSuccess
+        } as any);
+
+        const interaction = {
+            commandName: "test",
+            user: { id: "123", username: "testuser" }
+        } as unknown as ChatInputCommandInteraction;
+
+        await CommandHandler.handle(interaction);
+
+        expect(executeSuccess).toHaveBeenCalled();
+        expect(AuroraClient.lastCommandTimestamp).not.toBeNull();
+        expect(AuroraClient.lastCommandTimestamp).toBeGreaterThan(0);
+    });
+
+    test("should not update lastCommandTimestamp on failed execution", async () => {
+        const executeError = mock(() => Promise.reject(new Error("Command Failed")));
+        AuroraClient.commands.set("fail", {
+            data: { name: "fail" } as any,
+            execute: executeError
+        } as any);
+
+        const interaction = {
+            commandName: "fail",
+            user: { id: "123", username: "testuser" },
+            replied: false,
+            deferred: false,
+            reply: mock(() => Promise.resolve()),
+            followUp: mock(() => Promise.resolve())
+        } as unknown as ChatInputCommandInteraction;
+
+        await CommandHandler.handle(interaction);
+
+        expect(executeError).toHaveBeenCalled();
+        expect(AuroraClient.lastCommandTimestamp).toBeNull();
+    });
+});

src/lib/handlers/CommandHandler.ts

@@ -0,0 +1,41 @@
+import { ChatInputCommandInteraction, MessageFlags } from "discord.js";
+import { AuroraClient } from "@/lib/BotClient";
+import { userService } from "@/modules/user/user.service";
+import { createErrorEmbed } from "@lib/embeds";
+import { logger } from "@lib/logger";
+
+/**
+ * Handles slash command execution
+ * Includes user validation and comprehensive error handling
+ */
+export class CommandHandler {
+    static async handle(interaction: ChatInputCommandInteraction): Promise<void> {
+        const command = AuroraClient.commands.get(interaction.commandName);
+
+        if (!command) {
+            logger.error(`No command matching ${interaction.commandName} was found.`);
+            return;
+        }
+
+        // Ensure user exists in database
+        try {
+            await userService.getOrCreateUser(interaction.user.id, interaction.user.username);
+        } catch (error) {
+            logger.error("Failed to ensure user exists:", error);
+        }
+
+        try {
+            await command.execute(interaction);
+            AuroraClient.lastCommandTimestamp = Date.now();
+        } catch (error) {
+            logger.error(String(error));
+            const errorEmbed = createErrorEmbed('There was an error while executing this command!');
+
+            if (interaction.replied || interaction.deferred) {
+                await interaction.followUp({ embeds: [errorEmbed], flags: MessageFlags.Ephemeral });
+            } else {
+                await interaction.reply({ embeds: [errorEmbed], flags: MessageFlags.Ephemeral });
+            }
+        }
+    }
+}

src/lib/handlers/ComponentInteractionHandler.ts

@@ -0,0 +1,78 @@
+import { ButtonInteraction, StringSelectMenuInteraction, ModalSubmitInteraction, MessageFlags } from "discord.js";
+import { logger } from "@lib/logger";
+import { UserError } from "@lib/errors";
+import { createErrorEmbed } from "@lib/embeds";
+
+type ComponentInteraction = ButtonInteraction | StringSelectMenuInteraction | ModalSubmitInteraction;
+
+/**
+ * Handles component interactions (buttons, select menus, modals)
+ * Routes to appropriate handlers based on customId patterns
+ * Provides centralized error handling with UserError differentiation
+ */
+export class ComponentInteractionHandler {
+    static async handle(interaction: ComponentInteraction): Promise<void> {
+        const { interactionRoutes } = await import("@lib/interaction.routes");
+
+        for (const route of interactionRoutes) {
+            if (route.predicate(interaction)) {
+                const module = await route.handler();
+                const handlerMethod = module[route.method];
+
+                if (typeof handlerMethod === 'function') {
+                    try {
+                        await handlerMethod(interaction);
+                        return;
+                    } catch (error) {
+                        await this.handleError(interaction, error, route.method);
+                        return;
+                    }
+                } else {
+                    logger.error(`Handler method ${route.method} not found in module`);
+                }
+            }
+        }
+    }
+
+    /**
+     * Handles errors from interaction handlers
+     * Differentiates between UserError (user-facing) and system errors
+     */
+    private static async handleError(
+        interaction: ComponentInteraction,
+        error: unknown,
+        handlerName: string
+    ): Promise<void> {
+        const isUserError = error instanceof UserError;
+
+        // Determine error message
+        const errorMessage = isUserError
+            ? (error as Error).message
+            : 'An unexpected error occurred. Please try again later.';
+
+        // Log system errors (non-user errors) for debugging
+        if (!isUserError) {
+            logger.error(`Error in ${handlerName}:`, error);
+        }
+
+        const errorEmbed = createErrorEmbed(errorMessage);
+
+        try {
+            // Handle different interaction states
+            if (interaction.replied || interaction.deferred) {
+                await interaction.followUp({
+                    embeds: [errorEmbed],
+                    flags: MessageFlags.Ephemeral
+                });
+            } else {
+                await interaction.reply({
+                    embeds: [errorEmbed],
+                    flags: MessageFlags.Ephemeral
+                });
+            }
+        } catch (replyError) {
+            // If we can't send a reply, log it
+            logger.error(`Failed to send error response in ${handlerName}:`, replyError);
+        }
+    }
+}

src/lib/handlers/index.ts

@@ -0,0 +1,3 @@
+export { ComponentInteractionHandler } from "./ComponentInteractionHandler";
+export { AutocompleteHandler } from "./AutocompleteHandler";
+export { CommandHandler } from "./CommandHandler";

src/lib/interaction.routes.ts

@@ -1,19 +1,32 @@
 import { ButtonInteraction, ModalSubmitInteraction, StringSelectMenuInteraction } from "discord.js";
 
-type InteractionHandler = (interaction: any) => Promise<void>;
+// Union type for all component interactions
+type ComponentInteraction = ButtonInteraction | StringSelectMenuInteraction | ModalSubmitInteraction;
 
+// Type for the handler function that modules export
+type InteractionHandler = (interaction: ComponentInteraction) => Promise<void>;
+
+// Type for the dynamically imported module containing the handler
+interface InteractionModule {
+    [key: string]: (...args: any[]) => Promise<void> | any;
+}
+
+// Route definition
 interface InteractionRoute {
-    predicate: (interaction: ButtonInteraction | StringSelectMenuInteraction | ModalSubmitInteraction) => boolean;
-    handler: () => Promise<any>;
+    predicate: (interaction: ComponentInteraction) => boolean;
+    handler: () => Promise<InteractionModule>;
     method: string;
 }
 
 export const interactionRoutes: InteractionRoute[] = [
+    // --- TRADE MODULE ---
     {
         predicate: (i) => i.customId.startsWith("trade_") || i.customId === "amount",
         handler: () => import("@/modules/trade/trade.interaction"),
         method: 'handleTradeInteraction'
     },
+
+    // --- ECONOMY MODULE ---
     {
         predicate: (i) => i.isButton() && i.customId.startsWith("shop_buy_"),
         handler: () => import("@/modules/economy/shop.interaction"),
@@ -24,16 +37,22 @@ export const interactionRoutes: InteractionRoute[] = [
         handler: () => import("@/modules/economy/lootdrop.interaction"),
         method: 'handleLootdropInteraction'
     },
+
+    // --- ADMIN MODULE ---
     {
         predicate: (i) => i.customId.startsWith("createitem_"),
         handler: () => import("@/modules/admin/item_wizard"),
         method: 'handleItemWizardInteraction'
     },
+
+    // --- USER MODULE ---
     {
         predicate: (i) => i.isButton() && i.customId === "enrollment",
         handler: () => import("@/modules/user/enrollment.interaction"),
         method: 'handleEnrollmentInteraction'
     },
+
+    // --- FEEDBACK MODULE ---
     {
         predicate: (i) => i.customId.startsWith("feedback_"),
         handler: () => import("@/modules/feedback/feedback.interaction"),

src/lib/loaders/CommandLoader.ts

@@ -0,0 +1,111 @@
+import { readdir } from "node:fs/promises";
+import { join } from "node:path";
+import type { Command } from "@lib/types";
+import { config } from "@lib/config";
+import type { LoadResult, LoadError } from "./types";
+import type { Client } from "../BotClient";
+import { logger } from "@lib/logger";
+
+/**
+ * Handles loading commands from the file system
+ */
+export class CommandLoader {
+    private client: Client;
+
+    constructor(client: Client) {
+        this.client = client;
+    }
+
+    /**
+     * Load commands from a directory recursively
+     */
+    async loadFromDirectory(dir: string, reload: boolean = false): Promise<LoadResult> {
+        const result: LoadResult = { loaded: 0, skipped: 0, errors: [] };
+        await this.scanDirectory(dir, reload, result);
+        return result;
+    }
+
+    /**
+     * Recursively scan directory for command files
+     */
+    private async scanDirectory(dir: string, reload: boolean, result: LoadResult): Promise<void> {
+        try {
+            const files = await readdir(dir, { withFileTypes: true });
+
+            for (const file of files) {
+                const filePath = join(dir, file.name);
+
+                if (file.isDirectory()) {
+                    await this.scanDirectory(filePath, reload, result);
+                    continue;
+                }
+
+                if ((!file.name.endsWith('.ts') && !file.name.endsWith('.js')) || file.name.endsWith('.test.ts') || file.name.endsWith('.spec.ts')) continue;
+
+                await this.loadCommandFile(filePath, reload, result);
+            }
+        } catch (error) {
+            logger.error(`Error reading directory ${dir}:`, error);
+            result.errors.push({ file: dir, error });
+        }
+    }
+
+    /**
+     * Load a single command file
+     */
+    private async loadCommandFile(filePath: string, reload: boolean, result: LoadResult): Promise<void> {
+        try {
+            const importPath = reload ? `${filePath}?t=${Date.now()}` : filePath;
+            const commandModule = await import(importPath);
+            const commands = Object.values(commandModule);
+
+            if (commands.length === 0) {
+                logger.warn(`No commands found in ${filePath}`);
+                result.skipped++;
+                return;
+            }
+
+            const category = this.extractCategory(filePath);
+
+            for (const command of commands) {
+                if (this.isValidCommand(command)) {
+                    command.category = category;
+
+                    const isEnabled = config.commands[command.data.name] !== false;
+
+                    if (!isEnabled) {
+                        logger.info(`🚫 Skipping disabled command: ${command.data.name}`);
+                        result.skipped++;
+                        continue;
+                    }
+
+                    this.client.commands.set(command.data.name, command);
+                    logger.success(`Loaded command: ${command.data.name}`);
+                    result.loaded++;
+                } else {
+                    logger.warn(`Skipping invalid command in ${filePath}`);
+                    result.skipped++;
+                }
+            }
+        } catch (error) {
+            logger.error(`Failed to load command from ${filePath}:`, error);
+            result.errors.push({ file: filePath, error });
+        }
+    }
+
+    /**
+     * Extract category from file path
+     * e.g., /path/to/commands/admin/features.ts -> "admin"
+     */
+    private extractCategory(filePath: string): string {
+        const pathParts = filePath.split('/');
+        return pathParts[pathParts.length - 2] ?? "uncategorized";
+    }
+
+    /**
+     * Type guard to validate command structure
+     */
+    private isValidCommand(command: any): command is Command {
+        return command && typeof command === 'object' && 'data' in command && 'execute' in command;
+    }
+}

src/lib/loaders/EventLoader.ts

@@ -0,0 +1,85 @@
+import { readdir } from "node:fs/promises";
+import { join } from "node:path";
+import type { Event } from "@lib/types";
+import type { LoadResult } from "./types";
+import type { Client } from "../BotClient";
+import { logger } from "@lib/logger";
+
+/**
+ * Handles loading events from the file system
+ */
+export class EventLoader {
+    private client: Client;
+
+    constructor(client: Client) {
+        this.client = client;
+    }
+
+    /**
+     * Load events from a directory recursively
+     */
+    async loadFromDirectory(dir: string, reload: boolean = false): Promise<LoadResult> {
+        const result: LoadResult = { loaded: 0, skipped: 0, errors: [] };
+        await this.scanDirectory(dir, reload, result);
+        return result;
+    }
+
+    /**
+     * Recursively scan directory for event files
+     */
+    private async scanDirectory(dir: string, reload: boolean, result: LoadResult): Promise<void> {
+        try {
+            const files = await readdir(dir, { withFileTypes: true });
+
+            for (const file of files) {
+                const filePath = join(dir, file.name);
+
+                if (file.isDirectory()) {
+                    await this.scanDirectory(filePath, reload, result);
+                    continue;
+                }
+
+                if (!file.name.endsWith('.ts') && !file.name.endsWith('.js')) continue;
+
+                await this.loadEventFile(filePath, reload, result);
+            }
+        } catch (error) {
+            logger.error(`Error reading directory ${dir}:`, error);
+            result.errors.push({ file: dir, error });
+        }
+    }
+
+    /**
+     * Load a single event file
+     */
+    private async loadEventFile(filePath: string, reload: boolean, result: LoadResult): Promise<void> {
+        try {
+            const importPath = reload ? `${filePath}?t=${Date.now()}` : filePath;
+            const eventModule = await import(importPath);
+            const event = eventModule.default;
+
+            if (this.isValidEvent(event)) {
+                if (event.once) {
+                    this.client.once(event.name, (...args) => event.execute(...args));
+                } else {
+                    this.client.on(event.name, (...args) => event.execute(...args));
+                }
+                logger.success(`Loaded event: ${event.name}`);
+                result.loaded++;
+            } else {
+                logger.warn(`Skipping invalid event in ${filePath}`);
+                result.skipped++;
+            }
+        } catch (error) {
+            logger.error(`Failed to load event from ${filePath}:`, error);
+            result.errors.push({ file: filePath, error });
+        }
+    }
+
+    /**
+     * Type guard to validate event structure
+     */
+    private isValidEvent(event: any): event is Event<any> {
+        return event && typeof event === 'object' && 'name' in event && 'execute' in event;
+    }
+}

src/lib/loaders/types.ts

@@ -0,0 +1,16 @@
+/**
+ * Result of loading commands or events
+ */
+export interface LoadResult {
+    loaded: number;
+    skipped: number;
+    errors: LoadError[];
+}
+
+/**
+ * Error that occurred during loading
+ */
+export interface LoadError {
+    file: string;
+    error: unknown;
+}

src/lib/logger.ts

@@ -0,0 +1,39 @@
+/**
+ * Centralized logging utility with consistent formatting
+ */
+export const logger = {
+    /**
+     * General information message
+     */
+    info: (message: string, ...args: any[]) => {
+        console.log(`ℹ️  ${message}`, ...args);
+    },
+
+    /**
+     * Success message
+     */
+    success: (message: string, ...args: any[]) => {
+        console.log(`✅ ${message}`, ...args);
+    },
+
+    /**
+     * Warning message
+     */
+    warn: (message: string, ...args: any[]) => {
+        console.warn(`⚠️  ${message}`, ...args);
+    },
+
+    /**
+     * Error message
+     */
+    error: (message: string, ...args: any[]) => {
+        console.error(`❌ ${message}`, ...args);
+    },
+
+    /**
+     * Debug message
+     */
+    debug: (message: string, ...args: any[]) => {
+        console.log(`🔍 ${message}`, ...args);
+    },
+};

src/lib/shutdown.test.ts

@@ -0,0 +1,56 @@
+import { describe, it, expect, beforeEach } from "bun:test";
+import { isShuttingDown, setShuttingDown, incrementTransactions, decrementTransactions, getActiveTransactions, waitForTransactions } from "./shutdown";
+
+describe("shutdown logic", () => {
+    beforeEach(() => {
+        setShuttingDown(false);
+        while (getActiveTransactions() > 0) {
+            decrementTransactions();
+        }
+    });
+
+    it("should initialize with shuttingDown as false", () => {
+        expect(isShuttingDown()).toBe(false);
+    });
+
+    it("should update shuttingDown state", () => {
+        setShuttingDown(true);
+        expect(isShuttingDown()).toBe(true);
+    });
+
+    it("should track active transactions", () => {
+        expect(getActiveTransactions()).toBe(0);
+        incrementTransactions();
+        expect(getActiveTransactions()).toBe(1);
+        decrementTransactions();
+        expect(getActiveTransactions()).toBe(0);
+    });
+
+    it("should wait for transactions to complete", async () => {
+        incrementTransactions();
+
+        const start = Date.now();
+        const waitPromise = waitForTransactions(1000);
+
+        // Simulate completion after 200ms
+        setTimeout(() => {
+            decrementTransactions();
+        }, 200);
+
+        await waitPromise;
+        const duration = Date.now() - start;
+
+        expect(duration).toBeGreaterThanOrEqual(200);
+        expect(getActiveTransactions()).toBe(0);
+    });
+
+    it("should timeout if transactions never complete", async () => {
+        incrementTransactions();
+        const start = Date.now();
+        await waitForTransactions(500);
+        const duration = Date.now() - start;
+
+        expect(duration).toBeGreaterThanOrEqual(500);
+        expect(getActiveTransactions()).toBe(1); // Still 1 because we didn't decrement
+    });
+});

src/lib/shutdown.ts

@@ -0,0 +1,30 @@
+import { logger } from "@lib/logger";
+
+let shuttingDown = false;
+let activeTransactions = 0;
+
+export const isShuttingDown = () => shuttingDown;
+export const setShuttingDown = (value: boolean) => {
+    shuttingDown = value;
+};
+
+export const incrementTransactions = () => {
+    activeTransactions++;
+};
+
+export const decrementTransactions = () => {
+    activeTransactions--;
+};
+
+export const getActiveTransactions = () => activeTransactions;
+
+export const waitForTransactions = async (timeoutMs: number = 10000) => {
+    const start = Date.now();
+    while (activeTransactions > 0) {
+        if (Date.now() - start > timeoutMs) {
+            logger.warn(`Shutdown timed out waiting for ${activeTransactions} transactions after ${timeoutMs}ms`);
+            break;
+        }
+        await new Promise(resolve => setTimeout(resolve, 100));
+    }
+};

src/lib/types.ts

@@ -1,4 +1,6 @@
 import type { AutocompleteInteraction, ChatInputCommandInteraction, ClientEvents, SlashCommandBuilder, SlashCommandOptionsOnlyBuilder, SlashCommandSubcommandsOnlyBuilder } from "discord.js";
+import { LootType, EffectType } from "./constants";
+import { DrizzleClient } from "./DrizzleClient";
 
 export interface Command {
     data: SlashCommandBuilder | SlashCommandOptionsOnlyBuilder | SlashCommandSubcommandsOnlyBuilder;
@@ -14,19 +16,28 @@ export interface Event<K extends keyof ClientEvents> {
 }
 
 export type ItemEffect =
-    | { type: 'ADD_XP'; amount: number }
-    | { type: 'ADD_BALANCE'; amount: number }
-    | { type: 'XP_BOOST'; multiplier: number; durationSeconds?: number; durationMinutes?: number; durationHours?: number }
-    | { type: 'TEMP_ROLE'; roleId: string; durationSeconds?: number; durationMinutes?: number; durationHours?: number }
-    | { type: 'REPLY_MESSAGE'; message: string }
-    | { type: 'COLOR_ROLE'; roleId: string };
+    | { type: EffectType.ADD_XP; amount: number }
+    | { type: EffectType.ADD_BALANCE; amount: number }
+    | { type: EffectType.XP_BOOST; multiplier: number; durationSeconds?: number; durationMinutes?: number; durationHours?: number }
+    | { type: EffectType.TEMP_ROLE; roleId: string; durationSeconds?: number; durationMinutes?: number; durationHours?: number }
+    | { type: EffectType.REPLY_MESSAGE; message: string }
+    | { type: EffectType.COLOR_ROLE; roleId: string }
+    | { type: EffectType.LOOTBOX; pool: LootTableItem[] };
+
+export interface LootTableItem {
+    type: LootType;
+    weight: number;
+    amount?: number; // For CURRENCY, XP
+    itemId?: number; // For ITEM
+    minAmount?: number; // Optional range for CURRENCY/XP
+    maxAmount?: number; // Optional range for CURRENCY/XP
+    message?: string; // Optional custom message for this outcome
+}
 
 export interface ItemUsageData {
     consume: boolean;
     effects: ItemEffect[];
 }
 
-import { DrizzleClient } from "./DrizzleClient";
-
 export type DbClient = typeof DrizzleClient;
 export type Transaction = Parameters<Parameters<DbClient['transaction']>[0]>[0];

src/modules/admin/item_wizard.ts

@@ -4,6 +4,7 @@ import { DrizzleClient } from "@/lib/DrizzleClient";
 import type { ItemUsageData, ItemEffect } from "@/lib/types";
 import { getItemWizardEmbed, getItemTypeSelection, getEffectTypeSelection, getDetailsModal, getEconomyModal, getVisualsModal, getEffectConfigModal } from "./item_wizard.view";
 import type { DraftItem } from "./item_wizard.types";
+import { ItemType, EffectType } from "@/lib/constants";
 
 // --- Types ---
 
@@ -23,7 +24,7 @@ export const renderWizard = (userId: string, isDraft = true) => {
             name: "New Item",
             description: "No description",
             rarity: "Common",
-            type: "MATERIAL",
+            type: ItemType.MATERIAL,
             price: null,
             iconUrl: "",
             imageUrl: "",
@@ -176,26 +177,26 @@ export const handleItemWizardInteraction = async (interaction: Interaction) => {
             if (type) {
                 let effect: ItemEffect | null = null;
 
-                if (type === "ADD_XP" || type === "ADD_BALANCE") {
+                if (type === EffectType.ADD_XP || type === EffectType.ADD_BALANCE) {
                     const amount = parseInt(interaction.fields.getTextInputValue("amount"));
                     if (!isNaN(amount)) effect = { type: type as any, amount };
                 }
-                else if (type === "REPLY_MESSAGE") {
-                    effect = { type: "REPLY_MESSAGE", message: interaction.fields.getTextInputValue("message") };
+                else if (type === EffectType.REPLY_MESSAGE) {
+                    effect = { type: EffectType.REPLY_MESSAGE, message: interaction.fields.getTextInputValue("message") };
                 }
-                else if (type === "XP_BOOST") {
+                else if (type === EffectType.XP_BOOST) {
                     const multiplier = parseFloat(interaction.fields.getTextInputValue("multiplier"));
                     const duration = parseInt(interaction.fields.getTextInputValue("duration"));
-                    if (!isNaN(multiplier) && !isNaN(duration)) effect = { type: "XP_BOOST", multiplier, durationSeconds: duration };
+                    if (!isNaN(multiplier) && !isNaN(duration)) effect = { type: EffectType.XP_BOOST, multiplier, durationSeconds: duration };
                 }
-                else if (type === "TEMP_ROLE") {
+                else if (type === EffectType.TEMP_ROLE) {
                     const roleId = interaction.fields.getTextInputValue("role_id");
                     const duration = parseInt(interaction.fields.getTextInputValue("duration"));
-                    if (roleId && !isNaN(duration)) effect = { type: "TEMP_ROLE", roleId: roleId, durationSeconds: duration };
+                    if (roleId && !isNaN(duration)) effect = { type: EffectType.TEMP_ROLE, roleId: roleId, durationSeconds: duration };
                 }
-                else if (type === "COLOR_ROLE") {
+                else if (type === EffectType.COLOR_ROLE) {
                     const roleId = interaction.fields.getTextInputValue("role_id");
-                    if (roleId) effect = { type: "COLOR_ROLE", roleId: roleId };
+                    if (roleId) effect = { type: EffectType.COLOR_ROLE, roleId: roleId };
                 }
 
                 if (effect) {

src/modules/admin/item_wizard.view.ts

@@ -10,12 +10,13 @@ import {
 } from "discord.js";
 import { createBaseEmbed } from "@lib/embeds";
 import type { DraftItem } from "./item_wizard.types";
+import { ItemType } from "@/lib/constants";
 
 const getItemTypeOptions = () => [
-    { label: "Material", value: "MATERIAL", description: "Used for crafting or trading" },
-    { label: "Consumable", value: "CONSUMABLE", description: "Can be used to gain effects" },
-    { label: "Equipment", value: "EQUIPMENT", description: "Can be equipped (Not yet implemented)" },
-    { label: "Quest Item", value: "QUEST", description: "Required for quests" },
+    { label: "Material", value: ItemType.MATERIAL, description: "Used for crafting or trading" },
+    { label: "Consumable", value: ItemType.CONSUMABLE, description: "Can be used to gain effects" },
+    { label: "Equipment", value: ItemType.EQUIPMENT, description: "Can be equipped (Not yet implemented)" },
+    { label: "Quest Item", value: ItemType.QUEST, description: "Required for quests" },
 ];
 
 const getEffectTypeOptions = () => [

src/modules/class/class.service.ts

@@ -2,14 +2,16 @@ import { classes, users } from "@/db/schema";
 import { eq, sql } from "drizzle-orm";
 import { DrizzleClient } from "@/lib/DrizzleClient";
 import { UserError } from "@/lib/errors";
+import { withTransaction } from "@/lib/db";
+import type { Transaction } from "@/lib/types";
 
 export const classService = {
     getAllClasses: async () => {
         return await DrizzleClient.query.classes.findMany();
     },
 
-    assignClass: async (userId: string, classId: bigint, tx?: any) => {
-        const execute = async (txFn: any) => {
+    assignClass: async (userId: string, classId: bigint, tx?: Transaction) => {
+        return await withTransaction(async (txFn) => {
             const cls = await txFn.query.classes.findFirst({
                 where: eq(classes.id, classId),
             });
@@ -22,8 +24,7 @@ export const classService = {
                 .returning();
 
             return user;
-        };
-        return tx ? await execute(tx) : await DrizzleClient.transaction(execute);
+        }, tx);
     },
     getClassBalance: async (classId: bigint) => {
         const cls = await DrizzleClient.query.classes.findFirst({
@@ -31,15 +32,15 @@ export const classService = {
         });
         return cls?.balance || 0n;
     },
-    modifyClassBalance: async (classId: bigint, amount: bigint, tx?: any) => {
-        const execute = async (txFn: any) => {
+    modifyClassBalance: async (classId: bigint, amount: bigint, tx?: Transaction) => {
+        return await withTransaction(async (txFn) => {
             const cls = await txFn.query.classes.findFirst({
                 where: eq(classes.id, classId),
             });
 
             if (!cls) throw new UserError("Class not found");
 
-            if ((cls.balance ?? 0n) < amount) {
+            if ((cls.balance ?? 0n) + amount < 0n) {
                 throw new UserError("Insufficient class funds");
             }
 
@@ -51,35 +52,31 @@ export const classService = {
                 .returning();
 
             return updatedClass;
-        };
-        return tx ? await execute(tx) : await DrizzleClient.transaction(execute);
+        }, tx);
     },
 
-    updateClass: async (id: bigint, data: Partial<typeof classes.$inferInsert>, tx?: any) => {
-        const execute = async (txFn: any) => {
+    updateClass: async (id: bigint, data: Partial<typeof classes.$inferInsert>, tx?: Transaction) => {
+        return await withTransaction(async (txFn) => {
             const [updatedClass] = await txFn.update(classes)
                 .set(data)
                 .where(eq(classes.id, id))
                 .returning();
             return updatedClass;
-        };
-        return tx ? await execute(tx) : await DrizzleClient.transaction(execute);
+        }, tx);
     },
 
-    createClass: async (data: typeof classes.$inferInsert, tx?: any) => {
-        const execute = async (txFn: any) => {
+    createClass: async (data: typeof classes.$inferInsert, tx?: Transaction) => {
+        return await withTransaction(async (txFn) => {
             const [newClass] = await txFn.insert(classes)
                 .values(data)
                 .returning();
             return newClass;
-        };
-        return tx ? await execute(tx) : await DrizzleClient.transaction(execute);
+        }, tx);
     },
 
-    deleteClass: async (id: bigint, tx?: any) => {
-        const execute = async (txFn: any) => {
+    deleteClass: async (id: bigint, tx?: Transaction) => {
+        return await withTransaction(async (txFn) => {
             await txFn.delete(classes).where(eq(classes.id, id));
-        };
-        return tx ? await execute(tx) : await DrizzleClient.transaction(execute);
+        }, tx);
     }
 };

src/modules/economy/economy.service.test.ts

@@ -173,10 +173,22 @@ describe("economyService", () => {
         it("should throw if cooldown is active", async () => {
             const future = new Date("2023-01-02T12:00:00Z"); // +24h
             mockFindFirst.mockResolvedValue({ expiresAt: future });
-
             expect(economyService.claimDaily("1")).rejects.toThrow("Daily already claimed");
         });
 
+        it("should set cooldown to next UTC midnight", async () => {
+            // 2023-01-01T12:00:00Z -> Should be 2023-01-02T00:00:00Z
+
+            mockFindFirst
+                .mockResolvedValueOnce(undefined) // No cooldown
+                .mockResolvedValueOnce({ id: 1n, dailyStreak: 5, balance: 1000n });
+
+            const result = await economyService.claimDaily("1");
+
+            const expectedReset = new Date("2023-01-02T00:00:00Z");
+            expect(result.nextReadyAt.toISOString()).toBe(expectedReset.toISOString());
+        });
+
         it("should reset streak if missed a day (long time gap)", async () => {
             // Expired 3 days ago
             const past = new Date("2023-01-01T00:00:00Z"); // now is 12:00
@@ -193,8 +205,40 @@ describe("economyService", () => {
             const result = await economyService.claimDaily("1");
 
             // timeSinceReady = 48h. 
-            // streak = (5+1) - floor(48h / 24h) = 6 - 2 = 4.
-            expect(result.streak).toBe(4);
+            // streak should reset to 1
+            expect(result.streak).toBe(1);
+        });
+
+        it("should preserve streak if cooldown is missing but user has a streak", async () => {
+            mockFindFirst
+                .mockResolvedValueOnce(undefined) // No cooldown
+                .mockResolvedValueOnce({ id: 1n, dailyStreak: 10 });
+
+            const result = await economyService.claimDaily("1");
+            expect(result.streak).toBe(11);
+        });
+
+        it("should prevent weekly bonus exploit by resetting streak", async () => {
+            // Mock user at streak 7.
+            // Mock time as 24h + 1m after expiry.
+
+            const expiredAt = new Date("2023-01-01T11:59:00Z"); // now is 12:00 next day, plus 1 min gap? 
+            // no, 'now' is 2023-01-01T12:00:00Z set in beforeEach
+
+            // We want gap > 24h. 
+            // If expiry was yesterday 11:59:59. Gap is 24h + 1s.
+
+            const expiredAtExploit = new Date("2022-12-31T11:59:00Z"); // Over 24h ago
+
+            mockFindFirst
+                .mockResolvedValueOnce({ expiresAt: expiredAtExploit })
+                .mockResolvedValueOnce({ id: 1n, dailyStreak: 7 });
+
+            const result = await economyService.claimDaily("1");
+
+            // Should reset to 1
+            expect(result.streak).toBe(1);
+            expect(result.isWeekly).toBe(false);
         });
     });
 

src/modules/economy/economy.service.ts

@@ -4,6 +4,7 @@ import { config } from "@/lib/config";
 import { withTransaction } from "@/lib/db";
 import type { Transaction } from "@/lib/types";
 import { UserError } from "@/lib/errors";
+import { TimerType, TransactionType } from "@/lib/constants";
 
 export const economyService = {
     transfer: async (fromUserId: string, toUserId: string, amount: bigint, tx?: Transaction) => {
@@ -48,7 +49,7 @@ export const economyService = {
             await txFn.insert(transactions).values({
                 userId: BigInt(fromUserId),
                 amount: -amount,
-                type: 'TRANSFER_OUT',
+                type: TransactionType.TRANSFER_OUT,
                 description: `Transfer to ${toUserId}`,
             });
 
@@ -56,7 +57,7 @@ export const economyService = {
             await txFn.insert(transactions).values({
                 userId: BigInt(toUserId),
                 amount: amount,
-                type: 'TRANSFER_IN',
+                type: TransactionType.TRANSFER_IN,
                 description: `Transfer from ${fromUserId}`,
             });
 
@@ -67,20 +68,18 @@ export const economyService = {
     claimDaily: async (userId: string, tx?: Transaction) => {
         return await withTransaction(async (txFn) => {
             const now = new Date();
-            const startOfDay = new Date(now);
-            startOfDay.setHours(0, 0, 0, 0);
 
             // Check cooldown
             const cooldown = await txFn.query.userTimers.findFirst({
                 where: and(
                     eq(userTimers.userId, BigInt(userId)),
-                    eq(userTimers.type, 'COOLDOWN'),
+                    eq(userTimers.type, TimerType.COOLDOWN),
                     eq(userTimers.key, 'daily')
                 ),
             });
 
             if (cooldown && cooldown.expiresAt > now) {
-                throw new UserError(`Daily already claimed. Ready <t:${Math.floor(cooldown.expiresAt.getTime() / 1000)}:R>`);
+                throw new UserError(`Daily already claimed today. Next claim <t:${Math.floor(cooldown.expiresAt.getTime() / 1000)}:F>`);
             }
 
             // Get user for streak logic
@@ -89,17 +88,23 @@ export const economyService = {
             });
 
             if (!user) {
-                throw new Error("User not found"); // This might be system error because user should exist if authenticated, but keeping simple for now
+                throw new Error("User not found");
             }
 
             let streak = (user.dailyStreak || 0) + 1;
 
-            // If previous cooldown exists and expired more than 24h ago (meaning >48h since last claim), reduce streak by one for each day passed minimum 1
+            // Check if streak should be reset due to missing a day
             if (cooldown) {
                 const timeSinceReady = now.getTime() - cooldown.expiresAt.getTime();
+                // If more than 24h passed since it became ready, they missed a full calendar day
                 if (timeSinceReady > 24 * 60 * 60 * 1000) {
-                    streak = Math.max(1, streak - Math.floor(timeSinceReady / (24 * 60 * 60 * 1000)));
+                    streak = 1;
                 }
+            } else if ((user.dailyStreak || 0) > 0) {
+                // If no cooldown record exists but user has a streak,
+                // we'll allow one "free" increment to restore the timer state.
+                // This prevents unfair resets if timers were cleared/lost.
+                streak = (user.dailyStreak || 0) + 1;
             } else {
                 streak = 1;
             }
@@ -119,13 +124,15 @@ export const economyService = {
                 })
                 .where(eq(users.id, BigInt(userId)));
 
-            // Set new cooldown (now + 24h)
-            const nextReadyAt = new Date(now.getTime() + config.economy.daily.cooldownMs);
+            // Set new cooldown (Next UTC Midnight)
+            const nextReadyAt = new Date(now);
+            nextReadyAt.setUTCDate(nextReadyAt.getUTCDate() + 1);
+            nextReadyAt.setUTCHours(0, 0, 0, 0);
 
             await txFn.insert(userTimers)
                 .values({
                     userId: BigInt(userId),
-                    type: 'COOLDOWN',
+                    type: TimerType.COOLDOWN,
                     key: 'daily',
                     expiresAt: nextReadyAt,
                 })
@@ -138,7 +145,7 @@ export const economyService = {
             await txFn.insert(transactions).values({
                 userId: BigInt(userId),
                 amount: totalReward,
-                type: 'DAILY_REWARD',
+                type: TransactionType.DAILY_REWARD,
                 description: `Daily reward (Streak: ${streak})`,
             });
 

src/modules/economy/lootdrop.interaction.ts

@@ -1,6 +1,6 @@
 import { ButtonInteraction } from "discord.js";
 import { lootdropService } from "./lootdrop.service";
-import { createErrorEmbed } from "@/lib/embeds";
+import { UserError } from "@/lib/errors";
 import { getLootdropClaimedMessage } from "./lootdrop.view";
 
 export async function handleLootdropInteraction(interaction: ButtonInteraction) {
@@ -9,28 +9,27 @@ export async function handleLootdropInteraction(interaction: ButtonInteraction)
 
         const result = await lootdropService.tryClaim(interaction.message.id, interaction.user.id, interaction.user.username);
 
-        if (result.success) {
+        if (!result.success) {
+            throw new UserError(result.error || "Failed to claim.");
+        }
+
         await interaction.editReply({
             content: `🎉 You successfully claimed **${result.amount} ${result.currency}**!`
         });
 
-            // Update original message to show claimed state
-            const originalEmbed = interaction.message.embeds[0];
-            if (!originalEmbed) return;
-
-            const { embeds, components } = getLootdropClaimedMessage(
-                originalEmbed.title || "💰 LOOTDROP!",
+        const { content, files, components } = await getLootdropClaimedMessage(
             interaction.user.id,
+            interaction.user.username,
+            interaction.user.displayAvatarURL({ extension: "png" }),
             result.amount || 0,
             result.currency || "Coins"
         );
 
-            await interaction.message.edit({ embeds, components });
-
-        } else {
-            await interaction.editReply({
-                embeds: [createErrorEmbed(result.error || "Failed to claim.")]
+        await interaction.message.edit({
+            content,
+            embeds: [],
+            files,
+            components
         });
     }
-    }
 }

src/modules/economy/lootdrop.service.ts

@@ -27,7 +27,7 @@ class LootdropService {
         // Cleanup interval for activity tracking and expired lootdrops
         setInterval(() => {
             this.cleanupActivity();
-            this.cleanupExpiredLootdrops();
+            this.cleanupExpiredLootdrops(true);
         }, 60000);
     }
 
@@ -45,16 +45,24 @@ class LootdropService {
         }
     }
 
-    private async cleanupExpiredLootdrops() {
+    public async cleanupExpiredLootdrops(includeClaimed: boolean = false): Promise<number> {
         try {
             const now = new Date();
-            await DrizzleClient.delete(lootdrops)
-                .where(and(
-                    isNull(lootdrops.claimedBy),
-                    lt(lootdrops.expiresAt, now)
-                ));
+            const whereClause = includeClaimed
+                ? lt(lootdrops.expiresAt, now)
+                : and(isNull(lootdrops.claimedBy), lt(lootdrops.expiresAt, now));
+
+            const result = await DrizzleClient.delete(lootdrops)
+                .where(whereClause)
+                .returning();
+
+            if (result.length > 0) {
+                console.log(`[LootdropService] Cleaned up ${result.length} expired lootdrops.`);
+            }
+            return result.length;
         } catch (error) {
             console.error("Failed to cleanup lootdrops:", error);
+            return 0;
         }
     }
 
@@ -94,10 +102,10 @@ class LootdropService {
         const reward = Math.floor(Math.random() * (max - min + 1)) + min;
         const currency = config.lootdrop.reward.currency;
 
-        const { embeds, components } = getLootdropMessage(reward, currency);
+        const { content, files, components } = await getLootdropMessage(reward, currency);
 
         try {
-            const message = await channel.send({ embeds, components });
+            const message = await channel.send({ content, files, components });
 
             // Persist to DB
             await DrizzleClient.insert(lootdrops).values({

src/modules/economy/lootdrop.view.ts

@@ -1,31 +1,29 @@
-import { ActionRowBuilder, ButtonBuilder, ButtonStyle, EmbedBuilder } from "discord.js";
-import { createBaseEmbed } from "@lib/embeds";
+import { ActionRowBuilder, AttachmentBuilder, ButtonBuilder, ButtonStyle } from "discord.js";
+import { generateLootdropCard, generateClaimedLootdropCard } from "@/graphics/lootdrop";
 
-export function getLootdropMessage(reward: number, currency: string) {
-    const embed = createBaseEmbed(
-        "💰 LOOTDROP!",
-        `A lootdrop has appeared! Click the button below to claim **${reward} ${currency}**!`,
-        "#FFD700"
-    );
+export async function getLootdropMessage(reward: number, currency: string) {
+    const cardBuffer = await generateLootdropCard(reward, currency);
+    const attachment = new AttachmentBuilder(cardBuffer, { name: "lootdrop.png" });
 
     const claimButton = new ButtonBuilder()
         .setCustomId("lootdrop_claim")
         .setLabel("CLAIM REWARD")
-        .setStyle(ButtonStyle.Success)
-        .setEmoji("💸");
+        .setStyle(ButtonStyle.Secondary) // Changed to Secondary to fit the darker theme better? Or keep Success? Let's try Secondary with custom emoji
+        .setEmoji("🌠");
 
     const row = new ActionRowBuilder<ButtonBuilder>()
         .addComponents(claimButton);
 
-    return { embeds: [embed], components: [row] };
+    return {
+        content: "",
+        files: [attachment],
+        components: [row]
+    };
 }
 
-export function getLootdropClaimedMessage(originalTitle: string, userId: string, amount: number, currency: string) {
-    const newEmbed = createBaseEmbed(
-        originalTitle || "💰 LOOTDROP!",
-        `✅ Claimed by <@${userId}> for **${amount} ${currency}**!`,
-        "#00FF00"
-    );
+export async function getLootdropClaimedMessage(userId: string, username: string, avatarUrl: string, amount: number, currency: string) {
+    const cardBuffer = await generateClaimedLootdropCard(amount, currency, username, avatarUrl);
+    const attachment = new AttachmentBuilder(cardBuffer, { name: "lootdrop_claimed.png" });
 
     const newRow = new ActionRowBuilder<ButtonBuilder>()
         .addComponents(
@@ -37,5 +35,9 @@ export function getLootdropClaimedMessage(originalTitle: string, userId: string,
                 .setDisabled(true)
         );
 
-    return { embeds: [newEmbed], components: [newRow] };
+    return {
+        content: ``, // Remove content as the image says it all
+        files: [attachment],
+        components: [newRow]
+    };
 }

src/modules/economy/shop.interaction.ts

@@ -1,40 +1,34 @@
 import { ButtonInteraction, MessageFlags } from "discord.js";
 import { inventoryService } from "@/modules/inventory/inventory.service";
 import { userService } from "@/modules/user/user.service";
-import { createErrorEmbed, createWarningEmbed } from "@/lib/embeds";
+import { UserError } from "@/lib/errors";
 
 export async function handleShopInteraction(interaction: ButtonInteraction) {
     if (!interaction.customId.startsWith("shop_buy_")) return;
 
-    try {
     await interaction.deferReply({ flags: MessageFlags.Ephemeral });
 
     const itemId = parseInt(interaction.customId.replace("shop_buy_", ""));
     if (isNaN(itemId)) {
-            await interaction.editReply({ embeds: [createErrorEmbed("Invalid Item ID.")] });
-            return;
+        throw new UserError("Invalid Item ID.");
     }
 
     const item = await inventoryService.getItem(itemId);
     if (!item || !item.price) {
-            await interaction.editReply({ embeds: [createErrorEmbed("Item not found or not for sale.")] });
-            return;
+        throw new UserError("Item not found or not for sale.");
     }
 
     const user = await userService.getOrCreateUser(interaction.user.id, interaction.user.username);
+    if (!user) {
+        throw new UserError("User profiles could not be loaded. Please try again later.");
+    }
 
     // Double check balance here too, although service handles it, we want a nice message
     if ((user.balance ?? 0n) < item.price) {
-            await interaction.editReply({ embeds: [createWarningEmbed(`You need ${item.price} 🪙 to buy this item. You have ${user.balance} 🪙.`)] });
-            return;
+        throw new UserError(`You need ${item.price} 🪙 to buy this item. You have ${user.balance?.toString() ?? "0"} 🪙.`);
     }
 
-        const result = await inventoryService.buyItem(user.id, item.id, 1n);
+    await inventoryService.buyItem(user.id.toString(), item.id, 1n);
 
     await interaction.editReply({ content: `✅ **Success!** You bought **${item.name}** for ${item.price} 🪙.` });
-
-    } catch (error: any) {
-        console.error("Shop Purchase Error:", error);
-        await interaction.editReply({ embeds: [createErrorEmbed(error.message || "An error occurred while processing your purchase.")] });
-    }
 }

src/modules/feedback/feedback.interaction.ts

@@ -4,7 +4,7 @@ import { config } from "@/lib/config";
 import { AuroraClient } from "@/lib/BotClient";
 import { buildFeedbackMessage, getFeedbackModal } from "./feedback.view";
 import { FEEDBACK_CUSTOM_IDS, type FeedbackType, type FeedbackData } from "./feedback.types";
-import { createErrorEmbed, createSuccessEmbed } from "@/lib/embeds";
+import { UserError } from "@/lib/errors";
 
 export const handleFeedbackInteraction = async (interaction: Interaction) => {
     // Handle select menu for choosing feedback type
@@ -12,11 +12,7 @@ export const handleFeedbackInteraction = async (interaction: Interaction) => {
         const feedbackType = interaction.values[0] as FeedbackType;
 
         if (!feedbackType) {
-            await interaction.reply({
-                embeds: [createErrorEmbed("Invalid feedback type selected.")],
-                ephemeral: true
-            });
-            return;
+            throw new UserError("Invalid feedback type selected.");
         }
 
         const modal = getFeedbackModal(feedbackType);
@@ -34,22 +30,13 @@ export const handleFeedbackInteraction = async (interaction: Interaction) => {
 
         if (!feedbackType || !["FEATURE_REQUEST", "BUG_REPORT", "GENERAL"].includes(feedbackType)) {
             console.error(`Invalid feedback type extracted: ${feedbackType} from customId: ${interaction.customId}`);
-            await interaction.reply({
-                embeds: [createErrorEmbed("An error occurred processing your feedback. Please try again.")],
-                ephemeral: true
-            });
-            return;
+            throw new UserError("An error occurred processing your feedback. Please try again.");
         }
 
         if (!config.feedbackChannelId) {
-            await interaction.reply({
-                embeds: [createErrorEmbed("Feedback channel is not configured. Please contact an administrator.")],
-                ephemeral: true
-            });
-            return;
+            throw new UserError("Feedback channel is not configured. Please contact an administrator.");
         }
 
-        try {
         // Parse modal inputs
         const title = interaction.fields.getTextInputValue(FEEDBACK_CUSTOM_IDS.TITLE_FIELD);
         const description = interaction.fields.getTextInputValue(FEEDBACK_CUSTOM_IDS.DESCRIPTION_FIELD);
@@ -68,11 +55,7 @@ export const handleFeedbackInteraction = async (interaction: Interaction) => {
         const channel = await AuroraClient.channels.fetch(config.feedbackChannelId).catch(() => null) as TextChannel | null;
 
         if (!channel) {
-                await interaction.reply({
-                    embeds: [createErrorEmbed("Feedback channel not found. Please contact an administrator.")],
-                    ephemeral: true
-                });
-                return;
+            throw new UserError("Feedback channel not found. Please contact an administrator.");
         }
 
         // Build and send beautiful message
@@ -89,24 +72,8 @@ export const handleFeedbackInteraction = async (interaction: Interaction) => {
 
         // Confirm to user
         await interaction.reply({
-                embeds: [createSuccessEmbed("Your feedback has been submitted successfully! Thank you for helping improve Aurora.", "✨ Feedback Submitted")],
-                ephemeral: true
+            content: "✨ **Feedback Submitted**\nYour feedback has been submitted successfully! Thank you for helping improve Aurora.",
+            flags: MessageFlags.Ephemeral
         });
-
-        } catch (error: any) {
-            console.error("Error submitting feedback:", error);
-
-            if (!interaction.replied && !interaction.deferred) {
-                await interaction.reply({
-                    embeds: [createErrorEmbed("An error occurred while submitting your feedback. Please try again later.")],
-                    ephemeral: true
-                });
-            } else {
-                await interaction.followUp({
-                    embeds: [createErrorEmbed("An error occurred while submitting your feedback. Please try again later.")],
-                    ephemeral: true
-                });
-            }
-        }
     }
 };

src/modules/inventory/effects/handlers.ts

@@ -2,6 +2,11 @@ import { levelingService } from "@/modules/leveling/leveling.service";
 import { economyService } from "@/modules/economy/economy.service";
 import { userTimers } from "@/db/schema";
 import type { EffectHandler } from "./types";
+import type { LootTableItem } from "@/lib/types";
+import { inventoryService } from "@/modules/inventory/inventory.service";
+import { inventory, items } from "@/db/schema";
+import { TimerType, TransactionType, LootType } from "@/lib/constants";
+
 
 // Helper to extract duration in seconds
 const getDuration = (effect: any): number => {
@@ -16,7 +21,7 @@ export const handleAddXp: EffectHandler = async (userId, effect, txFn) => {
 };
 
 export const handleAddBalance: EffectHandler = async (userId, effect, txFn) => {
-    await economyService.modifyUserBalance(userId, BigInt(effect.amount), 'ITEM_USE', `Used Item`, null, txFn);
+    await economyService.modifyUserBalance(userId, BigInt(effect.amount), TransactionType.ITEM_USE, `Used Item`, null, txFn);
     return `Gained ${effect.amount} 🪙`;
 };
 
@@ -29,7 +34,7 @@ export const handleXpBoost: EffectHandler = async (userId, effect, txFn) => {
     const expiresAt = new Date(Date.now() + boostDuration * 1000);
     await txFn.insert(userTimers).values({
         userId: BigInt(userId),
-        type: 'EFFECT',
+        type: TimerType.EFFECT,
         key: 'xp_boost',
         expiresAt: expiresAt,
         metadata: { multiplier: effect.multiplier }
@@ -45,7 +50,7 @@ export const handleTempRole: EffectHandler = async (userId, effect, txFn) => {
     const roleExpiresAt = new Date(Date.now() + roleDuration * 1000);
     await txFn.insert(userTimers).values({
         userId: BigInt(userId),
-        type: 'ACCESS',
+        type: TimerType.ACCESS,
         key: `role_${effect.roleId}`,
         expiresAt: roleExpiresAt,
         metadata: { roleId: effect.roleId }
@@ -60,3 +65,73 @@ export const handleTempRole: EffectHandler = async (userId, effect, txFn) => {
 export const handleColorRole: EffectHandler = async (_userId, _effect, _txFn) => {
     return "Color Role Equipped";
 };
+
+export const handleLootbox: EffectHandler = async (userId, effect, txFn) => {
+    const pool = effect.pool as LootTableItem[];
+    if (!pool || pool.length === 0) return "The box is empty...";
+
+    const totalWeight = pool.reduce((sum, item) => sum + item.weight, 0);
+    let random = Math.random() * totalWeight;
+
+    let winner: LootTableItem | null = null;
+    for (const item of pool) {
+        if (random < item.weight) {
+            winner = item;
+            break;
+        }
+        random -= item.weight;
+    }
+
+    if (!winner) return "The box is empty..."; // Should not happen
+
+    // Process Winner
+    if (winner.type === LootType.NOTHING) {
+        return winner.message || "You found nothing inside.";
+    }
+
+    if (winner.type === LootType.CURRENCY) {
+        let amount = winner.amount || 0;
+        if (winner.minAmount && winner.maxAmount) {
+            amount = Math.floor(Math.random() * (winner.maxAmount - winner.minAmount + 1)) + winner.minAmount;
+        }
+        if (amount > 0) {
+            await economyService.modifyUserBalance(userId, BigInt(amount), TransactionType.LOOTBOX, 'Lootbox Reward', null, txFn);
+            return winner.message || `You found ${amount} 🪙!`;
+        }
+    }
+
+    if (winner.type === LootType.XP) {
+        let amount = winner.amount || 0;
+        if (winner.minAmount && winner.maxAmount) {
+            amount = Math.floor(Math.random() * (winner.maxAmount - winner.minAmount + 1)) + winner.minAmount;
+        }
+        if (amount > 0) {
+            await levelingService.addXp(userId, BigInt(amount), txFn);
+            return winner.message || `You gained ${amount} XP!`;
+        }
+    }
+
+    if (winner.type === LootType.ITEM) {
+        if (winner.itemId) {
+            const quantity = BigInt(winner.amount || 1);
+
+            await inventoryService.addItem(userId, winner.itemId, quantity, txFn);
+
+            // Try to fetch item name for the message
+            try {
+                const item = await txFn.query.items.findFirst({
+                    where: (items, { eq }) => eq(items.id, winner.itemId!)
+                });
+                if (item) {
+                    return winner.message || `You found ${quantity > 1 ? quantity + 'x ' : ''}**${item.name}**!`;
+                }
+            } catch (e) {
+                console.error("Failed to fetch item name for lootbox message", e);
+            }
+
+            return winner.message || `You found an item! (ID: ${winner.itemId})`;
+        }
+    }
+
+    return "You found nothing suitable inside.";
+};

src/modules/inventory/effects/registry.ts

@@ -4,7 +4,8 @@ import {
     handleReplyMessage,
     handleXpBoost,
     handleTempRole,
-    handleColorRole
+    handleColorRole,
+    handleLootbox
 } from "./handlers";
 import type { EffectHandler } from "./types";
 
@@ -14,5 +15,6 @@ export const effectHandlers: Record<string, EffectHandler> = {
     'REPLY_MESSAGE': handleReplyMessage,
     'XP_BOOST': handleXpBoost,
     'TEMP_ROLE': handleTempRole,
-    'COLOR_ROLE': handleColorRole
+    'COLOR_ROLE': handleColorRole,
+    'LOOTBOX': handleLootbox
 };

src/modules/inventory/inventory.service.test.ts

@@ -18,6 +18,8 @@ const mockWhere = mock();
 const mockSelect = mock();
 const mockFrom = mock();
 const mockOnConflictDoUpdate = mock();
+const mockInnerJoin = mock();
+const mockLimit = mock();
 
 // Chain setup
 mockInsert.mockReturnValue({ values: mockValues });
@@ -34,7 +36,10 @@ mockWhere.mockReturnValue({ returning: mockReturning });
 mockDelete.mockReturnValue({ where: mockWhere });
 
 mockSelect.mockReturnValue({ from: mockFrom });
-mockFrom.mockReturnValue({ where: mockWhere });
+mockFrom.mockReturnValue({ where: mockWhere, innerJoin: mockInnerJoin });
+mockInnerJoin.mockReturnValue({ where: mockWhere });
+mockWhere.mockReturnValue({ returning: mockReturning, limit: mockLimit });
+mockLimit.mockResolvedValue([]);
 
 // Mock DrizzleClient
 mock.module("@/lib/DrizzleClient", () => {
@@ -239,4 +244,39 @@ describe("inventoryService", () => {
             expect(mockDelete).toHaveBeenCalledWith(inventory); // Consume
         });
     });
+
+    describe("getAutocompleteItems", () => {
+        it("should return formatted autocomplete results with rarity", async () => {
+            const mockItems = [
+                {
+                    item: { id: 1, name: "Common Sword", rarity: "Common", usageData: { effects: [{}] } },
+                    quantity: 5n
+                },
+                {
+                    item: { id: 2, name: "Epic Shield", rarity: "Epic", usageData: { effects: [{}] } },
+                    quantity: 1n
+                }
+            ];
+
+            mockLimit.mockResolvedValue(mockItems);
+
+            // Restore mocks that might have been polluted by other tests
+            mockFrom.mockReturnValue({ where: mockWhere, innerJoin: mockInnerJoin });
+            mockWhere.mockReturnValue({ returning: mockReturning, limit: mockLimit });
+
+            const result = await inventoryService.getAutocompleteItems("1", "Sw");
+
+            expect(mockSelect).toHaveBeenCalled();
+            expect(mockFrom).toHaveBeenCalledWith(inventory);
+            expect(mockInnerJoin).toHaveBeenCalled(); // checks join
+            expect(mockWhere).toHaveBeenCalled(); // checks filters
+            expect(mockLimit).toHaveBeenCalledWith(20);
+
+            expect(result).toHaveLength(2);
+            expect(result[0]?.name).toBe("Common Sword (5) [Common]");
+            expect(result[0]?.value).toBe(1);
+            expect(result[1]?.name).toBe("Epic Shield (1) [Epic]");
+            expect(result[1]?.value).toBe(2);
+        });
+    });
 });

src/modules/inventory/inventory.service.ts

@@ -1,5 +1,5 @@
 import { inventory, items, users, userTimers } from "@/db/schema";
-import { eq, and, sql, count } from "drizzle-orm";
+import { eq, and, sql, count, ilike } from "drizzle-orm";
 import { DrizzleClient } from "@/lib/DrizzleClient";
 import { economyService } from "@/modules/economy/economy.service";
 import { levelingService } from "@/modules/leveling/leveling.service";
@@ -7,6 +7,7 @@ import { config } from "@/lib/config";
 import { UserError } from "@/lib/errors";
 import { withTransaction } from "@/lib/db";
 import type { Transaction, ItemUsageData } from "@/lib/types";
+import { TransactionType } from "@/lib/constants";
 
 
 
@@ -121,7 +122,7 @@ export const inventoryService = {
             const totalPrice = item.price * quantity;
 
             // Deduct Balance using economy service (passing tx ensures atomicity)
-            await economyService.modifyUserBalance(userId, -totalPrice, 'PURCHASE', `Bought ${quantity}x ${item.name}`, null, txFn);
+            await economyService.modifyUserBalance(userId, -totalPrice, TransactionType.PURCHASE, `Bought ${quantity}x ${item.name}`, null, txFn);
 
             await inventoryService.addItem(userId, itemId, quantity, txFn);
 
@@ -159,7 +160,6 @@ export const inventoryService = {
 
             const results: string[] = [];
 
-            // 2. Apply Effects
             // 2. Apply Effects
             const { effectHandlers } = await import("./effects/registry");
 
@@ -179,7 +179,31 @@ export const inventoryService = {
                 await inventoryService.removeItem(userId, itemId, 1n, txFn);
             }
 
-            return { success: true, results, usageData };
+            return { success: true, results, usageData, item };
         }, tx);
+    },
+
+    getAutocompleteItems: async (userId: string, query: string) => {
+        const entries = await DrizzleClient.select({
+            quantity: inventory.quantity,
+            item: items
+        })
+            .from(inventory)
+            .innerJoin(items, eq(inventory.itemId, items.id))
+            .where(and(
+                eq(inventory.userId, BigInt(userId)),
+                ilike(items.name, `%${query}%`)
+            ))
+            .limit(20);
+
+        const filtered = entries.filter(entry => {
+            const usageData = entry.item.usageData as ItemUsageData | null;
+            return usageData && usageData.effects && usageData.effects.length > 0;
+        });
+
+        return filtered.map(entry => ({
+            name: `${entry.item.name} (${entry.quantity}) [${entry.item.rarity || 'Common'}]`,
+            value: entry.item.id
+        }));
     }
 };

src/modules/inventory/inventory.view.ts

@@ -0,0 +1,54 @@
+import { EmbedBuilder } from "discord.js";
+import type { ItemUsageData } from "@/lib/types";
+import { EffectType } from "@/lib/constants";
+
+/**
+ * Inventory entry with item details
+ */
+interface InventoryEntry {
+    quantity: bigint | null;
+    item: {
+        id: number;
+        name: string;
+        [key: string]: any;
+    };
+}
+
+/**
+ * Creates an embed displaying a user's inventory
+ */
+export function getInventoryEmbed(items: InventoryEntry[], username: string): EmbedBuilder {
+    const description = items.map(entry => {
+        return `**${entry.item.name}** x${entry.quantity}`;
+    }).join("\n");
+
+    return new EmbedBuilder()
+        .setTitle(`📦 ${username}'s Inventory`)
+        .setDescription(description)
+        .setColor(0x3498db); // Blue
+}
+
+/**
+ * Creates an embed showing the results of using an item
+ */
+export function getItemUseResultEmbed(results: string[], item?: { name: string, iconUrl: string | null, usageData: any }): EmbedBuilder {
+    const description = results.map(r => `• ${r}`).join("\n");
+
+    // Check if it was a lootbox
+    const isLootbox = item?.usageData?.effects?.some((e: any) => e.type === EffectType.LOOTBOX);
+
+    const embed = new EmbedBuilder()
+        .setDescription(description)
+        .setColor(isLootbox ? 0xFFD700 : 0x2ecc71); // Gold for lootbox, Green otherwise
+
+    if (isLootbox && item) {
+        embed.setTitle(`🎁 ${item.name} Opened!`);
+        if (item.iconUrl) {
+            embed.setThumbnail(item.iconUrl);
+        }
+    } else {
+        embed.setTitle(item ? `✅ Used ${item.name}` : "✅ Item Used!");
+    }
+
+    return embed;
+}

src/modules/leveling/leveling.service.test.ts

@@ -77,8 +77,8 @@ describe("levelingService", () => {
             // base 100, exp 1.5
             // lvl 1: 100 * 1^1.5 = 100
             // lvl 2: 100 * 2^1.5 = 100 * 2.828 = 282
-            expect(levelingService.getXpForLevel(1)).toBe(100);
-            expect(levelingService.getXpForLevel(2)).toBe(282);
+            expect(levelingService.getXpForNextLevel(1)).toBe(100);
+            expect(levelingService.getXpForNextLevel(2)).toBe(282);
         });
     });
 
@@ -123,7 +123,7 @@ describe("levelingService", () => {
 
             expect(result.levelUp).toBe(true);
             expect(result.currentLevel).toBe(2);
-            expect(mockSet).toHaveBeenCalledWith({ xp: 20n, level: 2 });
+            expect(mockSet).toHaveBeenCalledWith({ xp: 120n, level: 2 });
         });
 
         it("should handle multiple level ups", async () => {

src/modules/leveling/leveling.service.ts

@@ -3,6 +3,7 @@ import { eq, sql, and } from "drizzle-orm";
 import { withTransaction } from "@/lib/db";
 import { config } from "@/lib/config";
 import type { Transaction } from "@/lib/types";
+import { TimerType } from "@/lib/constants";
 
 export const levelingService = {
     // Calculate total XP required to REACH a specific level (Cumulative)
@@ -78,7 +79,7 @@ export const levelingService = {
             const cooldown = await txFn.query.userTimers.findFirst({
                 where: and(
                     eq(userTimers.userId, BigInt(id)),
-                    eq(userTimers.type, 'COOLDOWN'),
+                    eq(userTimers.type, TimerType.COOLDOWN),
                     eq(userTimers.key, 'chat_xp')
                 ),
             });
@@ -95,7 +96,7 @@ export const levelingService = {
             const xpBoost = await txFn.query.userTimers.findFirst({
                 where: and(
                     eq(userTimers.userId, BigInt(id)),
-                    eq(userTimers.type, 'EFFECT'),
+                    eq(userTimers.type, TimerType.EFFECT),
                     eq(userTimers.key, 'xp_boost')
                 )
             });
@@ -114,7 +115,7 @@ export const levelingService = {
             await txFn.insert(userTimers)
                 .values({
                     userId: BigInt(id),
-                    type: 'COOLDOWN',
+                    type: TimerType.COOLDOWN,
                     key: 'chat_xp',
                     expiresAt: nextReadyAt,
                 })

src/modules/leveling/leveling.view.ts

@@ -0,0 +1,71 @@
+import { EmbedBuilder } from "discord.js";
+
+/**
+ * User data for leaderboard display
+ */
+interface LeaderboardUser {
+    username: string;
+    level: number | null;
+    xp: bigint | null;
+    balance: bigint | null;
+    netWorth?: bigint | null;
+}
+
+/**
+ * Returns the appropriate medal emoji for a ranking position
+ */
+function getMedalEmoji(index: number): string {
+    if (index === 0) return "🥇";
+    if (index === 1) return "🥈";
+    if (index === 2) return "🥉";
+    return `${index + 1}.`;
+}
+
+/**
+ * Formats a single leaderboard entry based on type
+ */
+function formatLeaderEntry(user: LeaderboardUser, index: number, type: 'xp' | 'balance' | 'networth'): string {
+    const medal = getMedalEmoji(index);
+    let value = '';
+
+    switch (type) {
+        case 'xp':
+            value = `Lvl ${user.level ?? 1} (${user.xp ?? 0n} XP)`;
+            break;
+        case 'balance':
+            value = `${user.balance ?? 0n} 🪙`;
+            break;
+        case 'networth':
+            value = `${user.netWorth ?? 0n} 🪙 (Net Worth)`;
+            break;
+    }
+
+    return `${medal} **${user.username}** — ${value}`;
+}
+
+/**
+ * Creates a leaderboard embed for either XP, Balance or Net Worth rankings
+ */
+export function getLeaderboardEmbed(leaders: LeaderboardUser[], type: 'xp' | 'balance' | 'networth'): EmbedBuilder {
+    const description = leaders.map((user, index) =>
+        formatLeaderEntry(user, index, type)
+    ).join("\n");
+
+    let title = '';
+    switch (type) {
+        case 'xp':
+            title = "🏆 XP Leaderboard";
+            break;
+        case 'balance':
+            title = "💰 Richest Players";
+            break;
+        case 'networth':
+            title = "💎 Net Worth Leaderboard";
+            break;
+    }
+
+    return new EmbedBuilder()
+        .setTitle(title)
+        .setDescription(description)
+        .setColor(0xFFD700); // Gold
+}

src/modules/moderation/moderation.service.test.ts

@@ -0,0 +1,291 @@
+
+import { describe, it, expect, mock, beforeEach } from "bun:test";
+import { ModerationService } from "./moderation.service";
+import { moderationCases } from "@/db/schema";
+import { CaseType } from "@/lib/constants";
+
+// Mock Drizzle Functions
+const mockFindFirst = mock();
+const mockFindMany = mock();
+const mockInsert = mock();
+const mockUpdate = mock();
+const mockValues = mock();
+const mockReturning = mock();
+const mockSet = mock();
+const mockWhere = mock();
+
+// Mock Config
+const mockConfig = {
+    moderation: {
+        cases: {
+            dmOnWarn: true,
+            autoTimeoutThreshold: 3
+        }
+    }
+};
+
+mock.module("@/lib/config", () => ({
+    config: mockConfig
+}));
+
+// Mock View
+const mockGetUserWarningEmbed = mock(() => ({}));
+mock.module("./moderation.view", () => ({
+    getUserWarningEmbed: mockGetUserWarningEmbed
+}));
+
+// Mock DrizzleClient
+mock.module("@/lib/DrizzleClient", () => ({
+    DrizzleClient: {
+        query: {
+            moderationCases: {
+                findFirst: mockFindFirst,
+                findMany: mockFindMany,
+            },
+        },
+        insert: mockInsert,
+        update: mockUpdate,
+    }
+}));
+
+// Setup chains
+mockInsert.mockReturnValue({ values: mockValues });
+mockValues.mockReturnValue({ returning: mockReturning });
+mockUpdate.mockReturnValue({ set: mockSet });
+mockSet.mockReturnValue({ where: mockWhere });
+mockWhere.mockReturnValue({ returning: mockReturning });
+
+describe("ModerationService", () => {
+    beforeEach(() => {
+        mockFindFirst.mockReset();
+        mockFindMany.mockReset();
+        mockInsert.mockClear();
+        mockUpdate.mockClear();
+        mockValues.mockClear();
+        mockReturning.mockClear();
+        mockSet.mockClear();
+        mockWhere.mockClear();
+        mockGetUserWarningEmbed.mockClear();
+        // Reset config to defaults
+        mockConfig.moderation.cases.dmOnWarn = true;
+        mockConfig.moderation.cases.autoTimeoutThreshold = 3;
+    });
+
+    describe("issueWarning", () => {
+        const defaultOptions = {
+            userId: "123456789",
+            username: "testuser",
+            moderatorId: "987654321",
+            moderatorName: "mod",
+            reason: "test reason",
+            guildName: "Test Guild"
+        };
+
+        it("should issue a warning and attempt to DM the user", async () => {
+            mockFindFirst.mockResolvedValue({ caseId: "CASE-0001" });
+            mockReturning.mockResolvedValue([{ caseId: "CASE-0002" }]);
+            mockFindMany.mockResolvedValue([{ type: CaseType.WARN, active: true }]); // 1 warning total
+
+            const mockDmTarget = { send: mock() };
+
+            const result = await ModerationService.issueWarning({
+                ...defaultOptions,
+                dmTarget: mockDmTarget
+            });
+
+            expect(result.moderationCase).toBeDefined();
+            expect(result.warningCount).toBe(1);
+            expect(mockDmTarget.send).toHaveBeenCalled();
+            expect(mockGetUserWarningEmbed).toHaveBeenCalled();
+        });
+
+        it("should not DM if dmOnWarn is false", async () => {
+            mockConfig.moderation.cases.dmOnWarn = false;
+            mockFindFirst.mockResolvedValue({ caseId: "CASE-0001" });
+            mockReturning.mockResolvedValue([{ caseId: "CASE-0002" }]);
+            mockFindMany.mockResolvedValue([]);
+
+            const mockDmTarget = { send: mock() };
+
+            await ModerationService.issueWarning({
+                ...defaultOptions,
+                dmTarget: mockDmTarget
+            });
+
+            expect(mockDmTarget.send).not.toHaveBeenCalled();
+        });
+
+        it("should trigger auto-timeout when threshold is reached", async () => {
+            mockFindFirst.mockResolvedValue({ caseId: "CASE-0001" });
+            mockReturning.mockResolvedValue([{ caseId: "CASE-0002" }]);
+            // Simulate 3 warnings (threshold is 3)
+            mockFindMany.mockResolvedValue([{}, {}, {}]);
+
+            const mockTimeoutTarget = { timeout: mock() };
+
+            const result = await ModerationService.issueWarning({
+                ...defaultOptions,
+                timeoutTarget: mockTimeoutTarget
+            });
+
+            expect(result.autoTimeoutIssued).toBe(true);
+            expect(mockTimeoutTarget.timeout).toHaveBeenCalledWith(86400000, expect.stringContaining("3 warnings"));
+            // Should create two cases: one for warn, one for timeout
+            expect(mockInsert).toHaveBeenCalledTimes(2);
+        });
+
+        it("should not timeout if threshold is not reached", async () => {
+            mockFindFirst.mockResolvedValue({ caseId: "CASE-0001" });
+            mockReturning.mockResolvedValue([{ caseId: "CASE-0002" }]);
+            // Simulate 2 warnings (threshold is 3)
+            mockFindMany.mockResolvedValue([{}, {}]);
+
+            const mockTimeoutTarget = { timeout: mock() };
+
+            const result = await ModerationService.issueWarning({
+                ...defaultOptions,
+                timeoutTarget: mockTimeoutTarget
+            });
+
+            expect(result.autoTimeoutIssued).toBe(false);
+            expect(mockTimeoutTarget.timeout).not.toHaveBeenCalled();
+            expect(mockInsert).toHaveBeenCalledTimes(1);
+        });
+    });
+
+    describe("getNextCaseId", () => {
+        it("should return CASE-0001 if no cases exist", async () => {
+            mockFindFirst.mockResolvedValue(undefined);
+            // Accessing private method via bracket notation for testing
+            const nextId = await (ModerationService as any).getNextCaseId();
+            expect(nextId).toBe("CASE-0001");
+        });
+
+        it("should increment the latest case ID", async () => {
+            mockFindFirst.mockResolvedValue({ caseId: "CASE-0042" });
+            const nextId = await (ModerationService as any).getNextCaseId();
+            expect(nextId).toBe("CASE-0043");
+        });
+
+        it("should handle padding correctly (e.g., 9 -> 0010)", async () => {
+            mockFindFirst.mockResolvedValue({ caseId: "CASE-0009" });
+            const nextId = await (ModerationService as any).getNextCaseId();
+            expect(nextId).toBe("CASE-0010");
+        });
+    });
+
+    describe("createCase", () => {
+        it("should create a new moderation case with correct values", async () => {
+            mockFindFirst.mockResolvedValue({ caseId: "CASE-0001" });
+            const mockNewCase = {
+                caseId: "CASE-0002",
+                type: CaseType.WARN,
+                userId: 123456789n,
+                username: "testuser",
+                moderatorId: 987654321n,
+                moderatorName: "mod",
+                reason: "test reason",
+                metadata: {},
+                active: true
+            };
+            mockReturning.mockResolvedValue([mockNewCase]);
+
+            const result = await ModerationService.createCase({
+                type: CaseType.WARN,
+                userId: "123456789",
+                username: "testuser",
+                moderatorId: "987654321",
+                moderatorName: "mod",
+                reason: "test reason"
+            });
+
+            expect(result?.caseId).toBe("CASE-0002");
+            expect(mockInsert).toHaveBeenCalled();
+            expect(mockValues).toHaveBeenCalledWith(expect.objectContaining({
+                caseId: "CASE-0002",
+                type: CaseType.WARN,
+                userId: 123456789n,
+                reason: "test reason"
+            }));
+        });
+
+        it("should set active to false for non-warn types", async () => {
+            mockFindFirst.mockResolvedValue(undefined);
+            mockReturning.mockImplementation((values) => [values]); // Simplified mock
+
+            const result = await ModerationService.createCase({
+                type: CaseType.BAN,
+                userId: "123456789",
+                username: "testuser",
+                moderatorId: "987654321",
+                moderatorName: "mod",
+                reason: "test reason"
+            });
+
+            expect(mockValues).toHaveBeenCalledWith(expect.objectContaining({
+                active: false
+            }));
+        });
+    });
+
+    describe("getCaseById", () => {
+        it("should return a case by its ID", async () => {
+            const mockCase = { caseId: "CASE-0001", reason: "test" };
+            mockFindFirst.mockResolvedValue(mockCase);
+
+            const result = await ModerationService.getCaseById("CASE-0001");
+            expect(result).toEqual(mockCase as any);
+        });
+    });
+
+    describe("getUserCases", () => {
+        it("should return all cases for a user", async () => {
+            const mockCases = [{ caseId: "CASE-0001" }, { caseId: "CASE-0002" }];
+            mockFindMany.mockResolvedValue(mockCases);
+
+            const result = await ModerationService.getUserCases("123456789");
+            expect(result).toHaveLength(2);
+            expect(mockFindMany).toHaveBeenCalled();
+        });
+    });
+
+    describe("clearCase", () => {
+        it("should update a case to be inactive and resolved", async () => {
+            const mockUpdatedCase = { caseId: "CASE-0001", active: false };
+            mockReturning.mockResolvedValue([mockUpdatedCase]);
+
+            const result = await ModerationService.clearCase({
+                caseId: "CASE-0001",
+                clearedBy: "987654321",
+                clearedByName: "mod",
+                reason: "resolved"
+            });
+
+            expect(result?.active).toBe(false);
+            expect(mockUpdate).toHaveBeenCalled();
+            expect(mockSet).toHaveBeenCalledWith(expect.objectContaining({
+                active: false,
+                resolvedBy: 987654321n,
+                resolvedReason: "resolved"
+            }));
+        });
+    });
+
+    describe("getActiveWarningCount", () => {
+        it("should return the number of active warnings", async () => {
+            mockFindMany.mockResolvedValue([
+                { id: 1n, type: CaseType.WARN, active: true },
+                { id: 2n, type: CaseType.WARN, active: true }
+            ]);
+
+            const count = await ModerationService.getActiveWarningCount("123456789");
+            expect(count).toBe(2);
+        });
+
+        it("should return 0 if no active warnings", async () => {
+            mockFindMany.mockResolvedValue([]);
+            const count = await ModerationService.getActiveWarningCount("123456789");
+            expect(count).toBe(0);
+        });
+    });
+});

src/modules/moderation/moderation.service.ts

@@ -0,0 +1,234 @@
+import { moderationCases } from "@/db/schema";
+import { eq, and, desc } from "drizzle-orm";
+import { DrizzleClient } from "@/lib/DrizzleClient";
+import type { CreateCaseOptions, ClearCaseOptions, SearchCasesFilter } from "./moderation.types";
+import { config } from "@/lib/config";
+import { getUserWarningEmbed } from "./moderation.view";
+import { CaseType } from "@/lib/constants";
+
+export class ModerationService {
+    /**
+     * Generate the next sequential case ID
+     */
+    private static async getNextCaseId(): Promise<string> {
+        const latestCase = await DrizzleClient.query.moderationCases.findFirst({
+            orderBy: [desc(moderationCases.id)],
+        });
+
+        if (!latestCase) {
+            return "CASE-0001";
+        }
+
+        // Extract number from case ID (e.g., "CASE-0042" -> 42)
+        const match = latestCase.caseId.match(/CASE-(\d+)/);
+        if (!match || !match[1]) {
+            return "CASE-0001";
+        }
+
+        const nextNumber = parseInt(match[1], 10) + 1;
+        return `CASE-${nextNumber.toString().padStart(4, '0')}`;
+    }
+
+    /**
+     * Create a new moderation case
+     */
+    static async createCase(options: CreateCaseOptions) {
+        const caseId = await this.getNextCaseId();
+
+        const [newCase] = await DrizzleClient.insert(moderationCases).values({
+            caseId,
+            type: options.type,
+            userId: BigInt(options.userId),
+            username: options.username,
+            moderatorId: BigInt(options.moderatorId),
+            moderatorName: options.moderatorName,
+            reason: options.reason,
+            metadata: options.metadata || {},
+            active: options.type === CaseType.WARN ? true : false, // Only warnings are "active" by default
+        }).returning();
+
+        return newCase;
+    }
+
+    /**
+     * Issue a warning with DM and threshold logic
+     */
+    static async issueWarning(options: {
+        userId: string;
+        username: string;
+        moderatorId: string;
+        moderatorName: string;
+        reason: string;
+        guildName?: string;
+        dmTarget?: { send: (options: any) => Promise<any> };
+        timeoutTarget?: { timeout: (duration: number, reason: string) => Promise<any> };
+    }) {
+        const moderationCase = await this.createCase({
+            type: CaseType.WARN,
+            userId: options.userId,
+            username: options.username,
+            moderatorId: options.moderatorId,
+            moderatorName: options.moderatorName,
+            reason: options.reason,
+        });
+
+        if (!moderationCase) {
+            throw new Error("Failed to create moderation case");
+        }
+
+        const warningCount = await this.getActiveWarningCount(options.userId);
+
+        // Try to DM the user if configured
+        if (config.moderation.cases.dmOnWarn && options.dmTarget) {
+            try {
+                await options.dmTarget.send({
+                    embeds: [getUserWarningEmbed(
+                        options.guildName || 'this server',
+                        options.reason,
+                        moderationCase.caseId,
+                        warningCount
+                    )]
+                });
+            } catch (error) {
+                console.log(`Could not DM warning to ${options.username}: ${error}`);
+            }
+        }
+
+        // Check for auto-timeout threshold
+        let autoTimeoutIssued = false;
+        if (config.moderation.cases.autoTimeoutThreshold &&
+            warningCount >= config.moderation.cases.autoTimeoutThreshold &&
+            options.timeoutTarget) {
+
+            try {
+                // Auto-timeout for 24 hours (86400000 ms)
+                await options.timeoutTarget.timeout(86400000, `Automatic timeout: ${warningCount} warnings`);
+
+                // Create a timeout case
+                await this.createCase({
+                    type: CaseType.TIMEOUT,
+                    userId: options.userId,
+                    username: options.username,
+                    moderatorId: "0", // System/Bot
+                    moderatorName: "System",
+                    reason: `Automatic timeout: reached ${warningCount} warnings`,
+                    metadata: { duration: '24h', automatic: true }
+                });
+                autoTimeoutIssued = true;
+            } catch (error) {
+                console.error('Failed to auto-timeout user:', error);
+            }
+        }
+
+        return { moderationCase, warningCount, autoTimeoutIssued };
+    }
+
+    /**
+     * Get a case by its case ID
+     */
+    static async getCaseById(caseId: string) {
+        return await DrizzleClient.query.moderationCases.findFirst({
+            where: eq(moderationCases.caseId, caseId),
+        });
+    }
+
+    /**
+     * Get all cases for a specific user
+     */
+    static async getUserCases(userId: string, activeOnly: boolean = false) {
+        const conditions = [eq(moderationCases.userId, BigInt(userId))];
+
+        if (activeOnly) {
+            conditions.push(eq(moderationCases.active, true));
+        }
+
+        return await DrizzleClient.query.moderationCases.findMany({
+            where: and(...conditions),
+            orderBy: [desc(moderationCases.createdAt)],
+        });
+    }
+
+    /**
+     * Get active warnings for a user
+     */
+    static async getUserWarnings(userId: string) {
+        return await DrizzleClient.query.moderationCases.findMany({
+            where: and(
+                eq(moderationCases.userId, BigInt(userId)),
+                eq(moderationCases.type, CaseType.WARN),
+                eq(moderationCases.active, true)
+            ),
+            orderBy: [desc(moderationCases.createdAt)],
+        });
+    }
+
+    /**
+     * Get all notes for a user
+     */
+    static async getUserNotes(userId: string) {
+        return await DrizzleClient.query.moderationCases.findMany({
+            where: and(
+                eq(moderationCases.userId, BigInt(userId)),
+                eq(moderationCases.type, CaseType.NOTE)
+            ),
+            orderBy: [desc(moderationCases.createdAt)],
+        });
+    }
+
+    /**
+     * Clear/resolve a warning
+     */
+    static async clearCase(options: ClearCaseOptions) {
+        const [updatedCase] = await DrizzleClient.update(moderationCases)
+            .set({
+                active: false,
+                resolvedAt: new Date(),
+                resolvedBy: BigInt(options.clearedBy),
+                resolvedReason: options.reason || 'Manually cleared',
+            })
+            .where(eq(moderationCases.caseId, options.caseId))
+            .returning();
+
+        return updatedCase;
+    }
+
+    /**
+     * Search cases with various filters
+     */
+    static async searchCases(filter: SearchCasesFilter) {
+        const conditions = [];
+
+        if (filter.userId) {
+            conditions.push(eq(moderationCases.userId, BigInt(filter.userId)));
+        }
+
+        if (filter.moderatorId) {
+            conditions.push(eq(moderationCases.moderatorId, BigInt(filter.moderatorId)));
+        }
+
+        if (filter.type) {
+            conditions.push(eq(moderationCases.type, filter.type));
+        }
+
+        if (filter.active !== undefined) {
+            conditions.push(eq(moderationCases.active, filter.active));
+        }
+
+        const whereClause = conditions.length > 0 ? and(...conditions) : undefined;
+
+        return await DrizzleClient.query.moderationCases.findMany({
+            where: whereClause,
+            orderBy: [desc(moderationCases.createdAt)],
+            limit: filter.limit || 50,
+            offset: filter.offset || 0,
+        });
+    }
+
+    /**
+     * Get total count of active warnings for a user (useful for auto-timeout)
+     */
+    static async getActiveWarningCount(userId: string): Promise<number> {
+        const warnings = await this.getUserWarnings(userId);
+        return warnings.length;
+    }
+}

src/modules/moderation/moderation.types.ts

@@ -0,0 +1,46 @@
+import { CaseType } from "@/lib/constants";
+
+export { CaseType };
+
+export interface CreateCaseOptions {
+    type: CaseType;
+    userId: string;
+    username: string;
+    moderatorId: string;
+    moderatorName: string;
+    reason: string;
+    metadata?: Record<string, any>;
+}
+
+export interface ClearCaseOptions {
+    caseId: string;
+    clearedBy: string;
+    clearedByName: string;
+    reason?: string;
+}
+
+export interface ModerationCase {
+    id: bigint;
+    caseId: string;
+    type: string;
+    userId: bigint;
+    username: string;
+    moderatorId: bigint;
+    moderatorName: string;
+    reason: string;
+    metadata: unknown;
+    active: boolean;
+    createdAt: Date;
+    resolvedAt: Date | null;
+    resolvedBy: bigint | null;
+    resolvedReason: string | null;
+}
+
+export interface SearchCasesFilter {
+    userId?: string;
+    moderatorId?: string;
+    type?: CaseType;
+    active?: boolean;
+    limit?: number;
+    offset?: number;
+}

src/modules/moderation/moderation.view.ts

@@ -0,0 +1,241 @@
+import { EmbedBuilder, Colors, time, TimestampStyles } from "discord.js";
+import type { ModerationCase } from "./moderation.types";
+
+/**
+ * Get color based on case type
+ */
+function getCaseColor(type: string): number {
+    switch (type) {
+        case 'warn': return Colors.Yellow;
+        case 'timeout': return Colors.Orange;
+        case 'kick': return Colors.Red;
+        case 'ban': return Colors.DarkRed;
+        case 'note': return Colors.Blue;
+        case 'prune': return Colors.Grey;
+        default: return Colors.Grey;
+    }
+}
+
+/**
+ * Get emoji based on case type
+ */
+function getCaseEmoji(type: string): string {
+    switch (type) {
+        case 'warn': return '⚠️';
+        case 'timeout': return '🔇';
+        case 'kick': return '👢';
+        case 'ban': return '🔨';
+        case 'note': return '📝';
+        case 'prune': return '🧹';
+        default: return '📋';
+    }
+}
+
+/**
+ * Display a single case
+ */
+export function getCaseEmbed(moderationCase: ModerationCase): EmbedBuilder {
+    const emoji = getCaseEmoji(moderationCase.type);
+    const color = getCaseColor(moderationCase.type);
+
+    const embed = new EmbedBuilder()
+        .setTitle(`${emoji} Case ${moderationCase.caseId}`)
+        .setColor(color)
+        .addFields(
+            { name: 'Type', value: moderationCase.type.toUpperCase(), inline: true },
+            { name: 'Status', value: moderationCase.active ? '🟢 Active' : '⚫ Resolved', inline: true },
+            { name: '\u200B', value: '\u200B', inline: true },
+            { name: 'User', value: `${moderationCase.username} (${moderationCase.userId})`, inline: false },
+            { name: 'Moderator', value: moderationCase.moderatorName, inline: true },
+            { name: 'Date', value: time(moderationCase.createdAt, TimestampStyles.ShortDateTime), inline: true }
+        )
+        .addFields({ name: 'Reason', value: moderationCase.reason })
+        .setTimestamp(moderationCase.createdAt);
+
+    // Add resolution info if resolved
+    if (!moderationCase.active && moderationCase.resolvedAt) {
+        embed.addFields(
+            { name: '\u200B', value: '**Resolution**' },
+            { name: 'Resolved At', value: time(moderationCase.resolvedAt, TimestampStyles.ShortDateTime), inline: true }
+        );
+
+        if (moderationCase.resolvedReason) {
+            embed.addFields({ name: 'Resolution Reason', value: moderationCase.resolvedReason });
+        }
+    }
+
+    // Add metadata if present
+    if (moderationCase.metadata && Object.keys(moderationCase.metadata).length > 0) {
+        const metadataStr = JSON.stringify(moderationCase.metadata, null, 2);
+        if (metadataStr.length < 1024) {
+            embed.addFields({ name: 'Additional Info', value: `\`\`\`json\n${metadataStr}\n\`\`\`` });
+        }
+    }
+
+    return embed;
+}
+
+/**
+ * Display a list of cases
+ */
+export function getCasesListEmbed(
+    cases: ModerationCase[],
+    title: string,
+    description?: string
+): EmbedBuilder {
+    const embed = new EmbedBuilder()
+        .setTitle(title)
+        .setColor(Colors.Blue)
+        .setTimestamp();
+
+    if (description) {
+        embed.setDescription(description);
+    }
+
+    if (cases.length === 0) {
+        embed.setDescription('No cases found.');
+        return embed;
+    }
+
+    // Group by type for better display
+    const casesByType: Record<string, ModerationCase[]> = {};
+    for (const c of cases) {
+        if (!casesByType[c.type]) {
+            casesByType[c.type] = [];
+        }
+        casesByType[c.type]!.push(c);
+    }
+
+    // Add fields for each type
+    for (const [type, typeCases] of Object.entries(casesByType)) {
+        const emoji = getCaseEmoji(type);
+        const caseList = typeCases.slice(0, 5).map(c => {
+            const status = c.active ? '🟢' : '⚫';
+            const date = time(c.createdAt, TimestampStyles.ShortDate);
+            return `${status} **${c.caseId}** - ${c.reason.substring(0, 50)}${c.reason.length > 50 ? '...' : ''} (${date})`;
+        }).join('\n');
+
+        embed.addFields({
+            name: `${emoji} ${type.toUpperCase()} (${typeCases.length})`,
+            value: caseList || 'None',
+            inline: false
+        });
+
+        if (typeCases.length > 5) {
+            embed.addFields({
+                name: '\u200B',
+                value: `_...and ${typeCases.length - 5} more_`,
+                inline: false
+            });
+        }
+    }
+
+    return embed;
+}
+
+/**
+ * Display user's active warnings
+ */
+export function getWarningsEmbed(warnings: ModerationCase[], username: string): EmbedBuilder {
+    const embed = new EmbedBuilder()
+        .setTitle(`⚠️ Active Warnings for ${username}`)
+        .setColor(Colors.Yellow)
+        .setTimestamp();
+
+    if (warnings.length === 0) {
+        embed.setDescription('No active warnings.');
+        return embed;
+    }
+
+    embed.setDescription(`**Total Active Warnings:** ${warnings.length}`);
+
+    for (const warning of warnings.slice(0, 10)) {
+        const date = time(warning.createdAt, TimestampStyles.ShortDateTime);
+        embed.addFields({
+            name: `${warning.caseId} - ${date}`,
+            value: `**Moderator:** ${warning.moderatorName}\n**Reason:** ${warning.reason}`,
+            inline: false
+        });
+    }
+
+    if (warnings.length > 10) {
+        embed.addFields({
+            name: '\u200B',
+            value: `_...and ${warnings.length - 10} more warnings. Use \`/cases\` to view all._`,
+            inline: false
+        });
+    }
+
+    return embed;
+}
+
+/**
+ * Success message after warning a user
+ */
+export function getWarnSuccessEmbed(caseId: string, username: string, reason: string): EmbedBuilder {
+    return new EmbedBuilder()
+        .setTitle('✅ Warning Issued')
+        .setDescription(`**${username}** has been warned.`)
+        .addFields(
+            { name: 'Case ID', value: caseId, inline: true },
+            { name: 'Reason', value: reason, inline: false }
+        )
+        .setColor(Colors.Green)
+        .setTimestamp();
+}
+
+/**
+ * Success message after adding a note
+ */
+export function getNoteSuccessEmbed(caseId: string, username: string): EmbedBuilder {
+    return new EmbedBuilder()
+        .setTitle('✅ Note Added')
+        .setDescription(`Staff note added for **${username}**.`)
+        .addFields({ name: 'Case ID', value: caseId, inline: true })
+        .setColor(Colors.Green)
+        .setTimestamp();
+}
+
+/**
+ * Success message after clearing a warning
+ */
+export function getClearSuccessEmbed(caseId: string): EmbedBuilder {
+    return new EmbedBuilder()
+        .setTitle('✅ Warning Cleared')
+        .setDescription(`Case **${caseId}** has been resolved.`)
+        .setColor(Colors.Green)
+        .setTimestamp();
+}
+
+/**
+ * Error embed for moderation operations
+ */
+export function getModerationErrorEmbed(message: string): EmbedBuilder {
+    return new EmbedBuilder()
+        .setTitle('❌ Error')
+        .setDescription(message)
+        .setColor(Colors.Red)
+        .setTimestamp();
+}
+
+/**
+ * Warning embed to send to user via DM
+ */
+export function getUserWarningEmbed(
+    serverName: string,
+    reason: string,
+    caseId: string,
+    warningCount: number
+): EmbedBuilder {
+    return new EmbedBuilder()
+        .setTitle('⚠️ You have received a warning')
+        .setDescription(`You have been warned in **${serverName}**.`)
+        .addFields(
+            { name: 'Reason', value: reason, inline: false },
+            { name: 'Case ID', value: caseId, inline: true },
+            { name: 'Total Warnings', value: warningCount.toString(), inline: true }
+        )
+        .setColor(Colors.Yellow)
+        .setTimestamp()
+        .setFooter({ text: 'Please review the server rules to avoid further action.' });
+}

src/modules/quest/quest.service.ts

@@ -6,6 +6,7 @@ import { economyService } from "@/modules/economy/economy.service";
 import { levelingService } from "@/modules/leveling/leveling.service";
 import { withTransaction } from "@/lib/db";
 import type { Transaction } from "@/lib/types";
+import { TransactionType } from "@/lib/constants";
 
 export const questService = {
     assignQuest: async (userId: string, questId: number, tx?: Transaction) => {
@@ -62,7 +63,7 @@ export const questService = {
 
             if (rewards?.balance) {
                 const bal = BigInt(rewards.balance);
-                await economyService.modifyUserBalance(userId, bal, 'QUEST_REWARD', `Reward for quest ${questId}`, null, txFn);
+                await economyService.modifyUserBalance(userId, bal, TransactionType.QUEST_REWARD, `Reward for quest ${questId}`, null, txFn);
                 results.balance = bal;
             }
 

src/modules/quest/quest.view.ts

@@ -0,0 +1,54 @@
+import { EmbedBuilder } from "discord.js";
+
+/**
+ * Quest entry with quest details and progress
+ */
+interface QuestEntry {
+    progress: number | null;
+    completedAt: Date | null;
+    quest: {
+        name: string;
+        description: string | null;
+        rewards: any;
+    };
+}
+
+/**
+ * Formats quest rewards object into a human-readable string
+ */
+function formatQuestRewards(rewards: { xp?: number, balance?: number }): string {
+    const rewardStr: string[] = [];
+    if (rewards?.xp) rewardStr.push(`${rewards.xp} XP`);
+    if (rewards?.balance) rewardStr.push(`${rewards.balance} 🪙`);
+    return rewardStr.join(", ");
+}
+
+/**
+ * Returns the quest status display string
+ */
+function getQuestStatus(completedAt: Date | null): string {
+    return completedAt ? "✅ Completed" : "📝 In Progress";
+}
+
+/**
+ * Creates an embed displaying a user's quest log
+ */
+export function getQuestListEmbed(userQuests: QuestEntry[]): EmbedBuilder {
+    const embed = new EmbedBuilder()
+        .setTitle("📜 Quest Log")
+        .setColor(0x3498db); // Blue
+
+    userQuests.forEach(entry => {
+        const status = getQuestStatus(entry.completedAt);
+        const rewards = entry.quest.rewards as { xp?: number, balance?: number };
+        const rewardsText = formatQuestRewards(rewards);
+
+        embed.addFields({
+            name: `${entry.quest.name} (${status})`,
+            value: `${entry.quest.description}\n**Rewards:** ${rewardsText}\n**Progress:** ${entry.progress}%`,
+            inline: false
+        });
+    });
+
+    return embed;
+}

src/modules/system/scheduler.ts

@@ -1,86 +1,21 @@
-import { userTimers } from "@/db/schema";
-import { eq, and, lt } from "drizzle-orm";
-import { DrizzleClient } from "@/lib/DrizzleClient";
-import { AuroraClient } from "@/lib/BotClient";
-import { env } from "@/lib/env";
+import { temporaryRoleService } from "./temp-role.service";
 
-/**
- * The Janitor responsible for cleaning up expired ACCESS timers
- * and revoking privileges.
- */
 export const schedulerService = {
     start: () => {
-        console.log("🕒 Scheduler started: Janitor loop running every 60s");
-        // Run immediately on start
-        schedulerService.runJanitor();
+        console.log("🕒 Scheduler started: Maintenance loops initialized.");
 
-        // Loop every 60 seconds
+        // 1. Temporary Role Revocation (every 60s)
         setInterval(() => {
-            schedulerService.runJanitor();
+            temporaryRoleService.processExpiredRoles();
         }, 60 * 1000);
 
-        // Terminal Update Loop (every 60s)
+        // 2. Terminal Update Loop (every 60s)
         const { terminalService } = require("@/modules/terminal/terminal.service");
         setInterval(() => {
             terminalService.update();
         }, 60 * 1000);
-    },
 
-    runJanitor: async () => {
-        try {
-            // Find all expired ACCESS timers
-            // We do this in a transaction to ensure we read and delete atomically if possible,
-            // though for this specific case, fetching then deleting is fine as long as we handle race conditions gracefully.
-
-            const now = new Date();
-
-            const expiredAccess = await DrizzleClient.query.userTimers.findMany({
-                where: and(
-                    eq(userTimers.type, 'ACCESS'),
-                    lt(userTimers.expiresAt, now)
-                )
-            });
-
-            if (expiredAccess.length === 0) return;
-
-            console.log(`🧹 Janitor: Found ${expiredAccess.length} expired access timers.`);
-
-            for (const timer of expiredAccess) {
-                const meta = timer.metadata as any;
-                const userIdStr = timer.userId.toString();
-
-                // Specific Handling for Roles
-                if (timer.key.startsWith('role_')) {
-                    try {
-                        const roleId = meta?.roleId || timer.key.replace('role_', '');
-                        const guildId = env.DISCORD_GUILD_ID;
-
-                        if (guildId) {
-                            // We try to fetch, if bot is not in guild or lacks perms, it will catch
-                            const guild = await AuroraClient.guilds.fetch(guildId);
-                            const member = await guild.members.fetch(userIdStr);
-                            await member.roles.remove(roleId);
-                            console.log(`👋 Removed temporary role ${roleId} from ${member.user.tag}`);
-                        }
-                    } catch (err) {
-                        console.error(`Failed to remove role for user ${userIdStr}:`, err);
-                        // We still delete the timer so we don't loop forever on a left user
-                    }
-                } else {
-                    console.log(`🚫 Revoking access for User ${timer.userId}: Key=${timer.key} (Channel: ${meta?.channelId || 'N/A'})`);
-                    // TODO: Generic channel permission removal if needed
-                }
-
-                // Delete the timer row
-                await DrizzleClient.delete(userTimers)
-                    .where(and(
-                        eq(userTimers.userId, timer.userId),
-                        eq(userTimers.type, timer.type),
-                        eq(userTimers.key, timer.key)
-                    ));
-            }
-        } catch (error) {
-            console.error("Janitor Error:", error);
-        }
+        // Run an initial check on start
+        temporaryRoleService.processExpiredRoles();
     }
 };

src/modules/system/temp-role.service.test.ts

@@ -0,0 +1,114 @@
+import { describe, it, expect, mock, beforeEach } from "bun:test";
+import { temporaryRoleService } from "./temp-role.service";
+import { userTimers } from "@/db/schema";
+import { TimerType } from "@/lib/constants";
+
+const mockDelete = mock();
+const mockWhere = mock();
+const mockFindMany = mock();
+
+mockDelete.mockReturnValue({ where: mockWhere });
+
+// Mock DrizzleClient
+mock.module("@/lib/DrizzleClient", () => ({
+    DrizzleClient: {
+        delete: mockDelete,
+        query: {
+            userTimers: {
+                findMany: mockFindMany
+            }
+        }
+    }
+}));
+
+// Mock AuroraClient
+const mockRemoveRole = mock();
+const mockFetchMember = mock();
+const mockFetchGuild = mock();
+
+mock.module("@/lib/BotClient", () => ({
+    AuroraClient: {
+        guilds: {
+            fetch: mockFetchGuild
+        }
+    }
+}));
+
+mock.module("@/lib/env", () => ({
+    env: {
+        DISCORD_GUILD_ID: "guild123"
+    }
+}));
+
+describe("temporaryRoleService", () => {
+    beforeEach(() => {
+        mockDelete.mockClear();
+        mockWhere.mockClear();
+        mockFindMany.mockClear();
+        mockRemoveRole.mockClear();
+        mockFetchMember.mockClear();
+        mockFetchGuild.mockClear();
+
+        mockFetchGuild.mockResolvedValue({
+            members: {
+                fetch: mockFetchMember
+            }
+        });
+
+        mockFetchMember.mockResolvedValue({
+            user: { tag: "TestUser#1234" },
+            roles: { remove: mockRemoveRole }
+        });
+    });
+
+    it("should revoke expired roles and delete timers", async () => {
+        // Mock findMany to return an expired role timer
+        mockFindMany.mockResolvedValue([
+            {
+                userId: 123n,
+                type: TimerType.ACCESS,
+                key: 'role_456',
+                expiresAt: new Date(Date.now() - 1000),
+                metadata: { roleId: '456' }
+            }
+        ]);
+
+        const count = await temporaryRoleService.processExpiredRoles();
+
+        expect(count).toBe(1);
+        expect(mockFetchGuild).toHaveBeenCalledWith("guild123");
+        expect(mockFetchMember).toHaveBeenCalledWith("123");
+        expect(mockRemoveRole).toHaveBeenCalledWith("456");
+        expect(mockDelete).toHaveBeenCalledWith(userTimers);
+    });
+
+    it("should still delete the timer even if member is not found", async () => {
+        mockFindMany.mockResolvedValue([
+            {
+                userId: 999n,
+                type: TimerType.ACCESS,
+                key: 'role_789',
+                expiresAt: new Date(Date.now() - 1000),
+                metadata: {}
+            }
+        ]);
+
+        // Mock member fetch failure
+        mockFetchMember.mockRejectedValue(new Error("Member not found"));
+
+        const count = await temporaryRoleService.processExpiredRoles();
+
+        expect(count).toBe(1);
+        expect(mockRemoveRole).not.toHaveBeenCalled();
+        expect(mockDelete).toHaveBeenCalledWith(userTimers);
+    });
+
+    it("should return 0 if no expired timers exist", async () => {
+        mockFindMany.mockResolvedValue([]);
+
+        const count = await temporaryRoleService.processExpiredRoles();
+
+        expect(count).toBe(0);
+        expect(mockDelete).not.toHaveBeenCalled();
+    });
+});

src/modules/system/temp-role.service.ts

@@ -0,0 +1,67 @@
+import { userTimers } from "@/db/schema";
+import { eq, and, lt } from "drizzle-orm";
+import { DrizzleClient } from "@/lib/DrizzleClient";
+import { AuroraClient } from "@/lib/BotClient";
+import { env } from "@/lib/env";
+import { TimerType } from "@/lib/constants";
+
+export const temporaryRoleService = {
+    /**
+     * Checks for and revokes expired temporary roles.
+     * This is intended to run as a high-frequency maintenance task.
+     */
+    processExpiredRoles: async (): Promise<number> => {
+        const now = new Date();
+        let revokedCount = 0;
+
+        // Find all expired ACCESS (temporary role) timers
+        const expiredTimers = await DrizzleClient.query.userTimers.findMany({
+            where: and(
+                eq(userTimers.type, TimerType.ACCESS),
+                lt(userTimers.expiresAt, now)
+            )
+        });
+
+        if (expiredTimers.length === 0) return 0;
+
+        for (const timer of expiredTimers) {
+            const userIdStr = timer.userId.toString();
+            const meta = timer.metadata as any;
+
+            // We only handle keys that indicate role management
+            if (timer.key.startsWith('role_')) {
+                try {
+                    const roleId = meta?.roleId || timer.key.replace('role_', '');
+                    const guildId = env.DISCORD_GUILD_ID;
+
+                    if (guildId) {
+                        const guild = await AuroraClient.guilds.fetch(guildId);
+                        const member = await guild.members.fetch(userIdStr).catch(() => null);
+
+                        if (member) {
+                            await member.roles.remove(roleId);
+                            console.log(`👋 Temporary role ${roleId} revoked from ${member.user.tag} (Expired)`);
+                        } else {
+                            console.log(`⚠️ Could not find member ${userIdStr} to revoke role ${roleId}.`);
+                        }
+                    }
+                } catch (err) {
+                    console.error(`❌ Failed to revoke role for user ${userIdStr}:`, err);
+                }
+            }
+
+            // Always delete the timer record after trying to revoke (or if it's not a role key)
+            // to prevent repeated failed attempts.
+            await DrizzleClient.delete(userTimers)
+                .where(and(
+                    eq(userTimers.userId, timer.userId),
+                    eq(userTimers.type, timer.type),
+                    eq(userTimers.key, timer.key)
+                ));
+
+            revokedCount++;
+        }
+
+        return revokedCount;
+    }
+};

src/modules/terminal/terminal.service.ts

@@ -1,13 +1,30 @@
-import { TextChannel, Message, ContainerBuilder, TextDisplayBuilder, SectionBuilder, MessageFlags } from "discord.js";
+import {
+    TextChannel,
+    ContainerBuilder,
+    TextDisplayBuilder,
+    SectionBuilder,
+    SeparatorBuilder,
+    ThumbnailBuilder,
+    MessageFlags,
+    SeparatorSpacingSize
+} from "discord.js";
 import { AuroraClient } from "@/lib/BotClient";
 import { DrizzleClient } from "@/lib/DrizzleClient";
-import { users, transactions, lootdrops } from "@/db/schema";
-import { desc } from "drizzle-orm";
+import { users, transactions, lootdrops, inventory } from "@/db/schema";
+import { desc, sql } from "drizzle-orm";
 import { config, saveConfig } from "@/lib/config";
 
+// Color palette for containers (hex as decimal)
+const COLORS = {
+    HEADER: 0x9B59B6,    // Purple - mystical
+    LEADERS: 0xF1C40F,   // Gold - achievement
+    ACTIVITY: 0x3498DB,  // Blue - activity
+    ALERT: 0xE74C3C      // Red - active events
+};
+
 export const terminalService = {
     init: async (channel: TextChannel) => {
-        // limit to one terminal for now
+        // Limit to one terminal for now
         if (config.terminal) {
             try {
                 const oldChannel = await AuroraClient.channels.fetch(config.terminal.channelId) as TextChannel;
@@ -16,11 +33,11 @@ export const terminalService = {
                     if (oldMsg) await oldMsg.delete();
                 }
             } catch (e) {
-                // ignore if old message doesn't exist
+                // Ignore if old message doesn't exist
             }
         }
 
-        const msg = await channel.send({ content: "🔄 Initializing Aurora Observatory..." });
+        const msg = await channel.send({ content: "🔄 Initializing Aurora Station..." });
 
         config.terminal = {
             channelId: channel.id,
@@ -48,8 +65,6 @@ export const terminalService = {
 
             const containers = await terminalService.buildMessage();
 
-            // Components V2 requires the IsComponentsV2 flag and no content/embeds
-            // Disable allowedMentions to prevent pings from the dashboard
             await message.edit({
                 content: null,
                 embeds: null as any,
@@ -64,24 +79,51 @@ export const terminalService = {
     },
 
     buildMessage: async () => {
-        // 1. Data Fetching
+        // ═══════════════════════════════════════════════════════════
+        // DATA FETCHING
+        // ═══════════════════════════════════════════════════════════
+
         const allUsers = await DrizzleClient.select().from(users);
         const totalUsers = allUsers.length;
         const totalWealth = allUsers.reduce((acc, u) => acc + (u.balance || 0n), 0n);
 
-        // 2. Leaderboards Calculation
-        const topLevels = [...allUsers].sort((a, b) => (b.level || 0) - (a.level || 0)).slice(0, 3);
-        const topWealth = [...allUsers].sort((a, b) => Number(b.balance || 0n) - Number(a.balance || 0n)).slice(0, 3);
+        // System stats
+        const uptime = process.uptime();
+        const uptimeHours = Math.floor(uptime / 3600);
+        const uptimeMinutes = Math.floor((uptime % 3600) / 60);
+        const ping = AuroraClient.ws.ping;
+        const now = Math.floor(Date.now() / 1000);
 
-        const formatUser = (u: typeof users.$inferSelect, i: number) => {
-            const star = i === 0 ? "🌟" : i === 1 ? "⭐" : "✨";
-            return `${star} <@${u.id}>`;
-        };
+        // Guild member count (if available)
+        const guild = AuroraClient.guilds.cache.first();
+        const memberCount = guild?.memberCount ?? totalUsers;
 
-        const levelText = topLevels.map((u, i) => `> ${formatUser(u, i)} • Lvl ${u.level}`).join("\n") || "> *The sky is empty...*";
-        const wealthText = topWealth.map((u, i) => `> ${formatUser(u, i)} • ${u.balance} AU`).join("\n") || "> *The sky is empty...*";
+        // Additional metrics
+        const avgLevel = totalUsers > 0
+            ? Math.round(allUsers.reduce((acc, u) => acc + (u.level || 1), 0) / totalUsers)
+            : 1;
+        const topStreak = allUsers.reduce((max, u) => Math.max(max, u.dailyStreak || 0), 0);
 
-        // 3. Lootdrops Data
+        // Items in circulation
+        const itemsResult = await DrizzleClient
+            .select({ total: sql<string>`COALESCE(SUM(${inventory.quantity}), 0)` })
+            .from(inventory);
+        const totalItems = Number(itemsResult[0]?.total || 0);
+
+        // Last command timestamp
+        const lastCmd = AuroraClient.lastCommandTimestamp
+            ? `<t:${Math.floor(AuroraClient.lastCommandTimestamp / 1000)}:R>`
+            : "*Never*";
+
+        // Leaderboards
+        const topLevels = [...allUsers]
+            .sort((a, b) => (b.level || 0) - (a.level || 0))
+            .slice(0, 3);
+        const topWealth = [...allUsers]
+            .sort((a, b) => Number(b.balance || 0n) - Number(a.balance || 0n))
+            .slice(0, 3);
+
+        // Lootdrops
         const activeDrops = await DrizzleClient.query.lootdrops.findMany({
             where: (lootdrops, { isNull }) => isNull(lootdrops.claimedBy),
             limit: 1,
@@ -94,65 +136,166 @@ export const terminalService = {
             orderBy: desc(lootdrops.createdAt)
         });
 
-        // --- CONTAINER 1: Header ---
-        const headerContainer = new ContainerBuilder()
-            .addTextDisplayComponents(
-                new TextDisplayBuilder().setContent("# 🌌 AURORA OBSERVATORY"),
-                new TextDisplayBuilder().setContent("*Current Moon Phase: Waxing Crescent 🌒*")
-            );
-
-        // --- CONTAINER 2: Observation Log ---
-        let phenomenaContent = "";
-
-        if (activeDrops.length > 0 && activeDrops[0]) {
-            const drop = activeDrops[0];
-            phenomenaContent = `\n**SHOOTING STAR DETECTED**\nRadiance: \`${drop.rewardAmount} ${drop.currency}\`\nCoordinates: <#${drop.channelId}>\nImpact: <t:${Math.floor(drop.expiresAt!.getTime() / 1000)}:R>`;
-        } else if (recentDrops.length > 0 && recentDrops[0]) {
-            const drop = recentDrops[0];
-            const claimer = allUsers.find(u => u.id === drop.claimedBy);
-            phenomenaContent = `\n**RECENT EVENT**\nStar yielded \`${drop.rewardAmount} ${drop.currency}\` to ${claimer ? `<@${claimer.id}>` : '**Unknown**'}`;
-        }
-
-        const logContainer = new ContainerBuilder()
-            .addTextDisplayComponents(
-                new TextDisplayBuilder().setContent("## 🔭 OBSERVATION LOG"),
-                new TextDisplayBuilder().setContent(`> **Stargazers**: \`${totalUsers}\`\n> **Astral Wealth**: \`${totalWealth.toLocaleString()} AU\`${phenomenaContent}`)
-            );
-
-        // --- CONTAINER 3: Leaders ---
-        const leaderContainer = new ContainerBuilder()
-            .addTextDisplayComponents(
-                new TextDisplayBuilder().setContent("## ✨ CONSTELLATION LEADERS"),
-                new TextDisplayBuilder().setContent(`**Brightest Stars**\n${levelText}`),
-                new TextDisplayBuilder().setContent(`**Gilded Nebulas**\n${wealthText}`)
-            );
-
-        // --- CONTAINER 4: Echoes ---
+        // Recent transactions
         const recentTx = await DrizzleClient.query.transactions.findMany({
-            limit: 5,
+            limit: 3,
             orderBy: [desc(transactions.createdAt)]
         });
 
-        const activityLines = recentTx.map(tx => {
-            const time = Math.floor(tx.createdAt!.getTime() / 1000);
-            let icon = "💫";
-            if (tx.type.includes("LOOT")) icon = "🌠";
-            if (tx.type.includes("GIFT")) icon = "🌕";
-            const user = allUsers.find(u => u.id === tx.userId);
+        // ═══════════════════════════════════════════════════════════
+        // HELPER FORMATTERS
+        // ═══════════════════════════════════════════════════════════
 
-            // the description might contain a channel id all the way at the end
-            const channelId = tx.description?.split(" ").pop() || "";
-            const text = tx.description?.replace(channelId, "<#" + channelId + ">") || "";
-            return `<t:${time}:F> ${icon} ${user ? `<@${user.id}>` : '**Unknown**'}: ${text}`;
-        });
+        const getMedal = (i: number) => i === 0 ? "🥇" : i === 1 ? "🥈" : "🥉";
 
-        const echoesContainer = new ContainerBuilder()
+        const formatLeaderEntry = (u: typeof users.$inferSelect, i: number, type: 'level' | 'wealth') => {
+            const medal = getMedal(i);
+            const value = type === 'level'
+                ? `Lvl ${u.level ?? 1}`
+                : `${Number(u.balance ?? 0).toLocaleString()} AU`;
+            return `${medal} **${u.username}** — ${value}`;
+        };
+
+        const getActivityIcon = (type: string) => {
+            if (type.includes("LOOT")) return "🌠";
+            if (type.includes("GIFT")) return "🎁";
+            if (type.includes("SHOP")) return "🛒";
+            if (type.includes("DAILY")) return "☀️";
+            if (type.includes("QUEST")) return "📜";
+            return "💫";
+        };
+
+        // ═══════════════════════════════════════════════════════════
+        // CONTAINER 1: HEADER - Station Overview
+        // ═══════════════════════════════════════════════════════════
+
+        const botAvatar = AuroraClient.user?.displayAvatarURL({ size: 64 }) ?? "";
+
+        const headerSection = new SectionBuilder()
             .addTextDisplayComponents(
-                new TextDisplayBuilder().setContent("## 📡 COSMIC ECHOES"),
-                new TextDisplayBuilder().setContent(activityLines.join("\n") || "Silence...")
+                new TextDisplayBuilder().setContent("# 🔮 AURORA STATION"),
+                new TextDisplayBuilder().setContent("-# Real-time server observatory")
+            )
+            .setThumbnailAccessory(
+                new ThumbnailBuilder().setURL(botAvatar)
             );
 
+        const statsText = [
+            `📡 **Uptime** ${uptimeHours}h ${uptimeMinutes}m`,
+            `🏓 **Ping** ${ping}ms`,
+            `👥 **Students** ${totalUsers}`,
+            `🪙 **Economy** ${totalWealth.toLocaleString()} AU`
+        ].join("  •  ");
 
-        return [headerContainer, logContainer, leaderContainer, echoesContainer];
+        const secondaryStats = [
+            `📦 **Items** ${totalItems.toLocaleString()}`,
+            `📈 **Avg Lvl** ${avgLevel}`,
+            `🔥 **Top Streak** ${topStreak}d`,
+            `⚡ **Last Cmd** ${lastCmd}`
+        ].join("  •  ");
+
+        const headerContainer = new ContainerBuilder()
+            .setAccentColor(COLORS.HEADER)
+            .addSectionComponents(headerSection)
+            .addSeparatorComponents(new SeparatorBuilder().setSpacing(SeparatorSpacingSize.Small))
+            .addTextDisplayComponents(
+                new TextDisplayBuilder().setContent(statsText),
+                new TextDisplayBuilder().setContent(secondaryStats),
+                new TextDisplayBuilder().setContent(`-# Updated <t:${now}:R>`)
+            );
+
+        // ═══════════════════════════════════════════════════════════
+        // CONTAINER 2: LEADERBOARDS
+        // ═══════════════════════════════════════════════════════════
+
+        const levelLeaderText = topLevels.length > 0
+            ? topLevels.map((u, i) => formatLeaderEntry(u, i, 'level')).join("\n")
+            : "*No data yet*";
+
+        const wealthLeaderText = topWealth.length > 0
+            ? topWealth.map((u, i) => formatLeaderEntry(u, i, 'wealth')).join("\n")
+            : "*No data yet*";
+
+        const leadersContainer = new ContainerBuilder()
+            .setAccentColor(COLORS.LEADERS)
+            .addTextDisplayComponents(
+                new TextDisplayBuilder().setContent("## ✨ CONSTELLATION LEADERS")
+            )
+            .addSeparatorComponents(new SeparatorBuilder().setSpacing(SeparatorSpacingSize.Small))
+            .addTextDisplayComponents(
+                new TextDisplayBuilder().setContent(`**Brightest Stars**\n${levelLeaderText}`),
+                new TextDisplayBuilder().setContent(`**Gilded Nebulas**\n${wealthLeaderText}`)
+            );
+
+        // ═══════════════════════════════════════════════════════════
+        // CONTAINER 3: LIVE ACTIVITY
+        // ═══════════════════════════════════════════════════════════
+
+        // Determine if there's an active lootdrop
+        const hasActiveDrop = activeDrops.length > 0 && activeDrops[0];
+        const activityColor = hasActiveDrop ? COLORS.ALERT : COLORS.ACTIVITY;
+
+        const activityContainer = new ContainerBuilder()
+            .setAccentColor(activityColor)
+            .addTextDisplayComponents(
+                new TextDisplayBuilder().setContent("## 🌠 LIVE ACTIVITY")
+            )
+            .addSeparatorComponents(new SeparatorBuilder().setSpacing(SeparatorSpacingSize.Small));
+
+        // Active lootdrop or recent event
+        if (hasActiveDrop) {
+            const drop = activeDrops[0]!;
+            const expiresTimestamp = Math.floor(drop.expiresAt!.getTime() / 1000);
+
+            activityContainer.addTextDisplayComponents(
+                new TextDisplayBuilder().setContent(
+                    `🚨 **SHOOTING STAR ACTIVE**\n` +
+                    `> **Reward:** \`${drop.rewardAmount} ${drop.currency}\`\n` +
+                    `> **Location:** <#${drop.channelId}>\n` +
+                    `> **Expires:** <t:${expiresTimestamp}:R>`
+                )
+            );
+        } else if (recentDrops.length > 0 && recentDrops[0]) {
+            const drop = recentDrops[0];
+            const claimer = allUsers.find(u => u.id === drop.claimedBy);
+            const claimedTimestamp = drop.createdAt ? Math.floor(drop.createdAt.getTime() / 1000) : now;
+
+            activityContainer.addTextDisplayComponents(
+                new TextDisplayBuilder().setContent(
+                    `✅ **Last Star Claimed**\n` +
+                    `> **${claimer?.username ?? 'Unknown'}** collected \`${drop.rewardAmount} ${drop.currency}\` <t:${claimedTimestamp}:R>`
+                )
+            );
+        } else {
+            activityContainer.addTextDisplayComponents(
+                new TextDisplayBuilder().setContent(`-# The sky is quiet... waiting for the next star.`)
+            );
+        }
+
+        // Recent transactions
+        if (recentTx.length > 0) {
+            activityContainer.addSeparatorComponents(
+                new SeparatorBuilder().setSpacing(SeparatorSpacingSize.Small)
+            );
+
+            const txLines = recentTx.map(tx => {
+                const time = Math.floor(tx.createdAt!.getTime() / 1000);
+                const icon = getActivityIcon(tx.type);
+                const user = allUsers.find(u => u.id === tx.userId);
+
+                // Clean description (remove trailing channel IDs)
+                let desc = tx.description || "Unknown";
+                desc = desc.replace(/\s*\d{17,19}\s*$/, "").trim();
+
+                return `${icon} **${user?.username ?? 'Unknown'}**: ${desc} · <t:${time}:R>`;
+            });
+
+            activityContainer.addTextDisplayComponents(
+                new TextDisplayBuilder().setContent("**Recent Echoes**"),
+                new TextDisplayBuilder().setContent(txLines.join("\n"))
+            );
+        }
+
+        return [headerContainer, leadersContainer, activityContainer];
     }
 };

src/modules/trade/trade.interaction.ts

@@ -7,9 +7,10 @@ import {
     TextChannel,
     EmbedBuilder
 } from "discord.js";
-import { TradeService } from "./trade.service";
+import { tradeService } from "./trade.service";
 import { inventoryService } from "@/modules/inventory/inventory.service";
 import { createErrorEmbed, createWarningEmbed, createSuccessEmbed, createInfoEmbed } from "@lib/embeds";
+import { UserError } from "@lib/errors";
 import { getTradeDashboard, getTradeMoneyModal, getItemSelectMenu, getTradeCompletedEmbed } from "./trade.view";
 
 
@@ -22,7 +23,6 @@ export async function handleTradeInteraction(interaction: Interaction) {
 
     if (!threadId) return;
 
-    try {
     if (customId === 'trade_cancel') {
         await handleCancel(interaction, threadId);
     } else if (customId === 'trade_lock') {
@@ -44,21 +44,13 @@ export async function handleTradeInteraction(interaction: Interaction) {
     } else if (customId === 'trade_remove_item_select') {
         await handleRemoveItemSelect(interaction as StringSelectMenuInteraction, threadId);
     }
-    } catch (error: any) {
-        const errorEmbed = createErrorEmbed(error.message);
-        if (interaction.replied || interaction.deferred) {
-            await interaction.followUp({ embeds: [errorEmbed], ephemeral: true });
-        } else {
-            await interaction.reply({ embeds: [errorEmbed], ephemeral: true });
-        }
-    }
 }
 
 async function handleCancel(interaction: ButtonInteraction | StringSelectMenuInteraction | ModalSubmitInteraction, threadId: string) {
-    const session = TradeService.getSession(threadId);
+    const session = tradeService.getSession(threadId);
     const user = interaction.user;
 
-    TradeService.endSession(threadId);
+    tradeService.endSession(threadId);
 
     await interaction.deferUpdate();
 
@@ -70,11 +62,11 @@ async function handleCancel(interaction: ButtonInteraction | StringSelectMenuInt
 
 async function handleLock(interaction: ButtonInteraction | StringSelectMenuInteraction | ModalSubmitInteraction, threadId: string) {
     await interaction.deferUpdate();
-    const isLocked = TradeService.toggleLock(threadId, interaction.user.id);
+    const isLocked = tradeService.toggleLock(threadId, interaction.user.id);
     await updateTradeDashboard(interaction, threadId);
 
     // Check if trade executed (both locked)
-    const session = TradeService.getSession(threadId);
+    const session = tradeService.getSession(threadId);
     if (session && session.state === 'COMPLETED') {
         // Trade executed during updateTradeDashboard
         return;
@@ -93,9 +85,9 @@ async function handleMoneySubmit(interaction: ModalSubmitInteraction, threadId:
     const amountStr = interaction.fields.getTextInputValue('amount');
     const amount = BigInt(amountStr);
 
-    if (amount < 0n) throw new Error("Amount must be positive");
+    if (amount < 0n) throw new UserError("Amount must be positive");
 
-    TradeService.updateMoney(threadId, interaction.user.id, amount);
+    tradeService.updateMoney(threadId, interaction.user.id, amount);
     await interaction.deferUpdate(); // Acknowledge modal
     await updateTradeDashboard(interaction, threadId);
 }
@@ -126,16 +118,16 @@ async function handleItemSelect(interaction: StringSelectMenuInteraction, thread
 
     // Assuming implementation implies adding 1 item for now
     const item = await inventoryService.getItem(itemId);
-    if (!item) throw new Error("Item not found");
+    if (!item) throw new UserError("Item not found");
 
-    TradeService.addItem(threadId, interaction.user.id, { id: item.id, name: item.name }, 1n);
+    tradeService.addItem(threadId, interaction.user.id, { id: item.id, name: item.name }, 1n);
 
     await interaction.update({ content: `Added ${item.name} x1`, components: [] });
     await updateTradeDashboard(interaction, threadId);
 }
 
 async function handleRemoveItemClick(interaction: ButtonInteraction, threadId: string) {
-    const session = TradeService.getSession(threadId);
+    const session = tradeService.getSession(threadId);
     if (!session) return;
 
     const participant = session.userA.id === interaction.user.id ? session.userA : session.userB;
@@ -158,7 +150,7 @@ async function handleRemoveItemSelect(interaction: StringSelectMenuInteraction,
     const value = interaction.values[0];
     if (!value) return;
     const itemId = parseInt(value);
-    TradeService.removeItem(threadId, interaction.user.id, itemId);
+    tradeService.removeItem(threadId, interaction.user.id, itemId);
 
     await interaction.update({ content: `Removed item.`, components: [] });
     await updateTradeDashboard(interaction, threadId);
@@ -168,14 +160,14 @@ async function handleRemoveItemSelect(interaction: StringSelectMenuInteraction,
 // --- DASHBOARD UPDATER ---
 
 export async function updateTradeDashboard(interaction: Interaction, threadId: string) {
-    const session = TradeService.getSession(threadId);
+    const session = tradeService.getSession(threadId);
     if (!session) return;
 
     // Check Auto-Execute (If both locked)
     if (session.userA.locked && session.userB.locked) {
         // Execute Trade
         try {
-            await TradeService.executeTrade(threadId);
+            await tradeService.executeTrade(threadId);
             const embed = getTradeCompletedEmbed(session);
             await updateDashboardMessage(interaction, { embeds: [embed], components: [] });
 

src/modules/trade/trade.service.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect, mock, beforeEach, afterEach, spyOn } from "bun:test";
-import { TradeService } from "./trade.service";
+import { tradeService } from "./trade.service";
 import { itemTransactions } from "@/db/schema";
 import { economyService } from "@/modules/economy/economy.service";
 import { inventoryService } from "@/modules/inventory/inventory.service";
@@ -37,7 +37,7 @@ describe("TradeService", () => {
         mockValues.mockClear();
 
         // Clear sessions
-        (TradeService as any).sessions.clear();
+        (tradeService as any)._sessions.clear();
 
         // Spies
         mockModifyUserBalance = spyOn(economyService, 'modifyUserBalance').mockResolvedValue({} as any);
@@ -54,68 +54,68 @@ describe("TradeService", () => {
 
     describe("createSession", () => {
         it("should create a new session", () => {
-            const session = TradeService.createSession("thread1", userA, userB);
+            const session = tradeService.createSession("thread1", userA, userB);
 
             expect(session.threadId).toBe("thread1");
             expect(session.state).toBe("NEGOTIATING");
             expect(session.userA.id).toBe("1");
             expect(session.userB.id).toBe("2");
-            expect(TradeService.getSession("thread1")).toBe(session);
+            expect(tradeService.getSession("thread1")).toBe(session);
         });
     });
 
     describe("updateMoney", () => {
         it("should update money offer", () => {
-            TradeService.createSession("thread1", userA, userB);
-            TradeService.updateMoney("thread1", "1", 100n);
+            tradeService.createSession("thread1", userA, userB);
+            tradeService.updateMoney("thread1", "1", 100n);
 
-            const session = TradeService.getSession("thread1");
+            const session = tradeService.getSession("thread1");
             expect(session?.userA.offer.money).toBe(100n);
         });
 
         it("should unlock participants when offer changes", () => {
-            const session = TradeService.createSession("thread1", userA, userB);
+            const session = tradeService.createSession("thread1", userA, userB);
             session.userA.locked = true;
             session.userB.locked = true;
 
-            TradeService.updateMoney("thread1", "1", 100n);
+            tradeService.updateMoney("thread1", "1", 100n);
 
             expect(session.userA.locked).toBe(false);
             expect(session.userB.locked).toBe(false);
         });
 
         it("should throw if not in trade", () => {
-            TradeService.createSession("thread1", userA, userB);
-            expect(() => TradeService.updateMoney("thread1", "3", 100n)).toThrow("User not in trade");
+            tradeService.createSession("thread1", userA, userB);
+            expect(() => tradeService.updateMoney("thread1", "3", 100n)).toThrow("User not in trade");
         });
     });
 
     describe("addItem", () => {
         it("should add item to offer", () => {
-            TradeService.createSession("thread1", userA, userB);
-            TradeService.addItem("thread1", "1", { id: 10, name: "Sword" }, 1n);
+            tradeService.createSession("thread1", userA, userB);
+            tradeService.addItem("thread1", "1", { id: 10, name: "Sword" }, 1n);
 
-            const session = TradeService.getSession("thread1");
+            const session = tradeService.getSession("thread1");
             expect(session?.userA.offer.items).toHaveLength(1);
             expect(session?.userA.offer.items[0]).toEqual({ id: 10, name: "Sword", quantity: 1n });
         });
 
         it("should stack items if already offered", () => {
-            TradeService.createSession("thread1", userA, userB);
-            TradeService.addItem("thread1", "1", { id: 10, name: "Sword" }, 1n);
-            TradeService.addItem("thread1", "1", { id: 10, name: "Sword" }, 2n);
+            tradeService.createSession("thread1", userA, userB);
+            tradeService.addItem("thread1", "1", { id: 10, name: "Sword" }, 1n);
+            tradeService.addItem("thread1", "1", { id: 10, name: "Sword" }, 2n);
 
-            const session = TradeService.getSession("thread1");
+            const session = tradeService.getSession("thread1");
             expect(session?.userA.offer.items[0]!.quantity).toBe(3n);
         });
     });
 
     describe("removeItem", () => {
         it("should remove item from offer", () => {
-            const session = TradeService.createSession("thread1", userA, userB);
+            const session = tradeService.createSession("thread1", userA, userB);
             session.userA.offer.items.push({ id: 10, name: "Sword", quantity: 1n });
 
-            TradeService.removeItem("thread1", "1", 10);
+            tradeService.removeItem("thread1", "1", 10);
 
             expect(session.userA.offer.items).toHaveLength(0);
         });
@@ -123,19 +123,19 @@ describe("TradeService", () => {
 
     describe("toggleLock", () => {
         it("should toggle lock status", () => {
-            TradeService.createSession("thread1", userA, userB);
+            tradeService.createSession("thread1", userA, userB);
 
-            const locked1 = TradeService.toggleLock("thread1", "1");
+            const locked1 = tradeService.toggleLock("thread1", "1");
             expect(locked1).toBe(true);
 
-            const locked2 = TradeService.toggleLock("thread1", "1");
+            const locked2 = tradeService.toggleLock("thread1", "1");
             expect(locked2).toBe(false);
         });
     });
 
     describe("executeTrade", () => {
         it("should execute trade successfully", async () => {
-            const session = TradeService.createSession("thread1", userA, userB);
+            const session = tradeService.createSession("thread1", userA, userB);
 
             // Setup offers
             session.userA.offer.money = 100n;
@@ -148,7 +148,7 @@ describe("TradeService", () => {
             session.userA.locked = true;
             session.userB.locked = true;
 
-            await TradeService.executeTrade("thread1");
+            await tradeService.executeTrade("thread1");
 
             expect(session.state).toBe("COMPLETED");
 
@@ -171,11 +171,11 @@ describe("TradeService", () => {
         });
 
         it("should throw if not locked", async () => {
-            const session = TradeService.createSession("thread1", userA, userB);
+            const session = tradeService.createSession("thread1", userA, userB);
             session.userA.locked = true;
             // B not locked
 
-            expect(TradeService.executeTrade("thread1")).rejects.toThrow("Both players must accept");
+            expect(tradeService.executeTrade("thread1")).rejects.toThrow("Both players must accept");
         });
     });
 });

src/modules/trade/trade.service.ts

@@ -1,149 +1,32 @@
 import type { TradeSession, TradeParticipant } from "./trade.types";
-import { DrizzleClient } from "@/lib/DrizzleClient";
 import { economyService } from "@/modules/economy/economy.service";
 import { inventoryService } from "@/modules/inventory/inventory.service";
 import { itemTransactions } from "@/db/schema";
+import { withTransaction } from "@/lib/db";
 import type { Transaction } from "@/lib/types";
+import { TransactionType, ItemTransactionType } from "@/lib/constants";
 
-export class TradeService {
-    private static sessions = new Map<string, TradeSession>();
+// Module-level session storage
+const sessions = new Map<string, TradeSession>();
 
-    /**
-     * Creates a new trade session
+/**
+ * Unlocks both participants in a trade session
  */
-    static createSession(threadId: string, userA: { id: string, username: string }, userB: { id: string, username: string }): TradeSession {
-        const session: TradeSession = {
-            threadId,
-            userA: {
-                id: userA.id,
-                username: userA.username,
-                locked: false,
-                offer: { money: 0n, items: [] }
-            },
-            userB: {
-                id: userB.id,
-                username: userB.username,
-                locked: false,
-                offer: { money: 0n, items: [] }
-            },
-            state: 'NEGOTIATING',
-            lastInteraction: Date.now()
-        };
-
-        this.sessions.set(threadId, session);
-        return session;
-    }
-
-    static getSession(threadId: string): TradeSession | undefined {
-        return this.sessions.get(threadId);
-    }
-
-    static endSession(threadId: string) {
-        this.sessions.delete(threadId);
-    }
-
-    /**
-     * Updates an offer. If allowed, validation checks should be done BEFORE calling this.
-     * unlocking logic is handled here (if offer changes, unlock both).
-     */
-    static updateMoney(threadId: string, userId: string, amount: bigint) {
-        const session = this.getSession(threadId);
-        if (!session) throw new Error("Session not found");
-        if (session.state !== 'NEGOTIATING') throw new Error("Trade is not active");
-
-        const participant = session.userA.id === userId ? session.userA : session.userB.id === userId ? session.userB : null;
-        if (!participant) throw new Error("User not in trade");
-
-        participant.offer.money = amount;
-        this.unlockAll(session);
-        session.lastInteraction = Date.now();
-    }
-
-    static addItem(threadId: string, userId: string, item: { id: number, name: string }, quantity: bigint) {
-        const session = this.getSession(threadId);
-        if (!session) throw new Error("Session not found");
-        if (session.state !== 'NEGOTIATING') throw new Error("Trade is not active");
-
-        const participant = session.userA.id === userId ? session.userA : session.userB.id === userId ? session.userB : null;
-        if (!participant) throw new Error("User not in trade");
-
-        const existing = participant.offer.items.find(i => i.id === item.id);
-        if (existing) {
-            existing.quantity += quantity;
-        } else {
-            participant.offer.items.push({ id: item.id, name: item.name, quantity });
-        }
-
-        this.unlockAll(session);
-        session.lastInteraction = Date.now();
-    }
-
-    static removeItem(threadId: string, userId: string, itemId: number) {
-        const session = this.getSession(threadId);
-        if (!session) throw new Error("Session not found");
-
-        const participant = session.userA.id === userId ? session.userA : session.userB.id === userId ? session.userB : null;
-        if (!participant) throw new Error("User not in trade");
-
-        participant.offer.items = participant.offer.items.filter(i => i.id !== itemId);
-
-        this.unlockAll(session);
-        session.lastInteraction = Date.now();
-    }
-
-    static toggleLock(threadId: string, userId: string): boolean {
-        const session = this.getSession(threadId);
-        if (!session) throw new Error("Session not found");
-
-        const participant = session.userA.id === userId ? session.userA : session.userB.id === userId ? session.userB : null;
-        if (!participant) throw new Error("User not in trade");
-
-        participant.locked = !participant.locked;
-        session.lastInteraction = Date.now();
-
-        return participant.locked;
-    }
-
-    private static unlockAll(session: TradeSession) {
+const unlockAll = (session: TradeSession) => {
     session.userA.locked = false;
     session.userB.locked = false;
-    }
+};
 
-    /**
-     * Executes the trade atomically.
-     * 1. Validates balances/inventory for both users.
-     * 2. Swaps money.
-     * 3. Swaps items.
-     * 4. Logs transactions.
+/**
+ * Processes a one-way transfer from one participant to another
  */
-    static async executeTrade(threadId: string): Promise<void> {
-        const session = this.getSession(threadId);
-        if (!session) throw new Error("Session not found");
-
-        if (!session.userA.locked || !session.userB.locked) {
-            throw new Error("Both players must accept the trade first.");
-        }
-
-        session.state = 'COMPLETED'; // Prevent double execution
-
-        await DrizzleClient.transaction(async (tx) => {
-            // -- Validate & Execute User A -> User B --
-            await this.processTransfer(tx, session.userA, session.userB, session.threadId);
-
-            // -- Validate & Execute User B -> User A --
-            await this.processTransfer(tx, session.userB, session.userA, session.threadId);
-        });
-
-        this.endSession(threadId);
-    }
-
-    private static async processTransfer(tx: Transaction, from: TradeParticipant, to: TradeParticipant, threadId: string) {
+const processTransfer = async (tx: Transaction, from: TradeParticipant, to: TradeParticipant, threadId: string) => {
     // 1. Money
     if (from.offer.money > 0n) {
         await economyService.modifyUserBalance(
             from.id,
             -from.offer.money,
-                'TRADE_OUT',
+            TransactionType.TRADE_OUT,
             `Trade with ${to.username} (Thread: ${threadId})`,
             to.id,
             tx
@@ -151,7 +34,7 @@ export class TradeService {
         await economyService.modifyUserBalance(
             to.id,
             from.offer.money,
-                'TRADE_IN',
+            TransactionType.TRADE_IN,
             `Trade with ${from.username} (Thread: ${threadId})`,
             from.id,
             tx
@@ -172,7 +55,7 @@ export class TradeService {
             relatedUserId: BigInt(to.id),
             itemId: item.id,
             quantity: -item.quantity,
-                type: 'TRADE_OUT',
+            type: ItemTransactionType.TRADE_OUT,
             description: `Traded to ${to.username}`,
         });
 
@@ -182,9 +65,136 @@ export class TradeService {
             relatedUserId: BigInt(from.id),
             itemId: item.id,
             quantity: item.quantity,
-                type: 'TRADE_IN',
+            type: ItemTransactionType.TRADE_IN,
             description: `Received from ${from.username}`,
         });
     }
+};
+
+export const tradeService = {
+    // Expose for testing
+    _sessions: sessions,
+    /**
+     * Creates a new trade session
+     */
+    createSession: (threadId: string, userA: { id: string, username: string }, userB: { id: string, username: string }): TradeSession => {
+        const session: TradeSession = {
+            threadId,
+            userA: {
+                id: userA.id,
+                username: userA.username,
+                locked: false,
+                offer: { money: 0n, items: [] }
+            },
+            userB: {
+                id: userB.id,
+                username: userB.username,
+                locked: false,
+                offer: { money: 0n, items: [] }
+            },
+            state: 'NEGOTIATING',
+            lastInteraction: Date.now()
+        };
+
+        sessions.set(threadId, session);
+        return session;
+    },
+
+    getSession: (threadId: string): TradeSession | undefined => {
+        return sessions.get(threadId);
+    },
+
+    endSession: (threadId: string) => {
+        sessions.delete(threadId);
+    },
+
+    /**
+     * Updates an offer. If allowed, validation checks should be done BEFORE calling this.
+     * unlocking logic is handled here (if offer changes, unlock both).
+     */
+    updateMoney: (threadId: string, userId: string, amount: bigint) => {
+        const session = tradeService.getSession(threadId);
+        if (!session) throw new Error("Session not found");
+        if (session.state !== 'NEGOTIATING') throw new Error("Trade is not active");
+
+        const participant = session.userA.id === userId ? session.userA : session.userB.id === userId ? session.userB : null;
+        if (!participant) throw new Error("User not in trade");
+
+        participant.offer.money = amount;
+        unlockAll(session);
+        session.lastInteraction = Date.now();
+    },
+
+    addItem: (threadId: string, userId: string, item: { id: number, name: string }, quantity: bigint) => {
+        const session = tradeService.getSession(threadId);
+        if (!session) throw new Error("Session not found");
+        if (session.state !== 'NEGOTIATING') throw new Error("Trade is not active");
+
+        const participant = session.userA.id === userId ? session.userA : session.userB.id === userId ? session.userB : null;
+        if (!participant) throw new Error("User not in trade");
+
+        const existing = participant.offer.items.find(i => i.id === item.id);
+        if (existing) {
+            existing.quantity += quantity;
+        } else {
+            participant.offer.items.push({ id: item.id, name: item.name, quantity });
         }
-}
+
+        unlockAll(session);
+        session.lastInteraction = Date.now();
+    },
+
+    removeItem: (threadId: string, userId: string, itemId: number) => {
+        const session = tradeService.getSession(threadId);
+        if (!session) throw new Error("Session not found");
+
+        const participant = session.userA.id === userId ? session.userA : session.userB.id === userId ? session.userB : null;
+        if (!participant) throw new Error("User not in trade");
+
+        participant.offer.items = participant.offer.items.filter(i => i.id !== itemId);
+
+        unlockAll(session);
+        session.lastInteraction = Date.now();
+    },
+
+    toggleLock: (threadId: string, userId: string): boolean => {
+        const session = tradeService.getSession(threadId);
+        if (!session) throw new Error("Session not found");
+
+        const participant = session.userA.id === userId ? session.userA : session.userB.id === userId ? session.userB : null;
+        if (!participant) throw new Error("User not in trade");
+
+        participant.locked = !participant.locked;
+        session.lastInteraction = Date.now();
+
+        return participant.locked;
+    },
+
+    /**
+     * Executes the trade atomically.
+     * 1. Validates balances/inventory for both users.
+     * 2. Swaps money.
+     * 3. Swaps items.
+     * 4. Logs transactions.
+     */
+    executeTrade: async (threadId: string): Promise<void> => {
+        const session = tradeService.getSession(threadId);
+        if (!session) throw new Error("Session not found");
+
+        if (!session.userA.locked || !session.userB.locked) {
+            throw new Error("Both players must accept the trade first.");
+        }
+
+        session.state = 'COMPLETED'; // Prevent double execution
+
+        await withTransaction(async (tx) => {
+            // -- Validate & Execute User A -> User B --
+            await processTransfer(tx, session.userA, session.userB, session.threadId);
+
+            // -- Validate & Execute User B -> User A --
+            await processTransfer(tx, session.userB, session.userA, session.threadId);
+        });
+
+        tradeService.endSession(threadId);
+    }
+};

src/modules/user/enrollment.interaction.ts

@@ -1,48 +1,38 @@
 import { ButtonInteraction, MessageFlags } from "discord.js";
 import { config } from "@/lib/config";
-import { getEnrollmentErrorEmbed, getEnrollmentSuccessMessage } from "./enrollment.view";
+import { getEnrollmentSuccessMessage } from "./enrollment.view";
 import { classService } from "@modules/class/class.service";
 import { userService } from "@modules/user/user.service";
+import { UserError } from "@/lib/errors";
 import { sendWebhookMessage } from "@/lib/webhookUtils";
 
 export async function handleEnrollmentInteraction(interaction: ButtonInteraction) {
     if (!interaction.inCachedGuild()) {
-        await interaction.reply({ content: "This action can only be performed in a server.", flags: MessageFlags.Ephemeral });
-        return;
+        throw new UserError("This action can only be performed in a server.");
     }
 
     const { studentRole, visitorRole } = config;
 
     if (!studentRole || !visitorRole) {
-        await interaction.reply({
-            ...getEnrollmentErrorEmbed("No student or visitor role configured for enrollment.", "Configuration Error"),
-            flags: MessageFlags.Ephemeral
-        });
-        return;
+        throw new UserError("No student or visitor role configured for enrollment.");
     }
 
-    try {
     // 1. Ensure user exists in DB and check current enrollment status
     const user = await userService.getOrCreateUser(interaction.user.id, interaction.user.username);
+    if (!user) {
+        throw new UserError("User profiles could not be loaded. Please try again later.");
+    }
 
     // Check DB enrollment
     if (user.class) {
-            await interaction.reply({
-                ...getEnrollmentErrorEmbed("You are already enrolled in a class.", "Enrollment Failed"),
-                flags: MessageFlags.Ephemeral
-            });
-            return;
+        throw new UserError("You are already enrolled in a class.");
     }
 
     const member = interaction.member;
 
     // Check Discord role enrollment (Double safety)
     if (member.roles.cache.has(studentRole)) {
-            await interaction.reply({
-                ...getEnrollmentErrorEmbed("You already have the student role.", "Enrollment Failed"),
-                flags: MessageFlags.Ephemeral
-            });
-            return;
+        throw new UserError("You already have the student role.");
     }
 
     // 2. Get available classes
@@ -50,11 +40,7 @@ export async function handleEnrollmentInteraction(interaction: ButtonInteraction
     const validClasses = allClasses.filter(c => c.roleId);
 
     if (validClasses.length === 0) {
-            await interaction.reply({
-                ...getEnrollmentErrorEmbed("No classes with specified roles found in database.", "Configuration Error"),
-                flags: MessageFlags.Ephemeral
-            });
-            return;
+        throw new UserError("No classes with specified roles found in database.");
     }
 
     // 3. Pick random class
@@ -64,15 +50,10 @@ export async function handleEnrollmentInteraction(interaction: ButtonInteraction
     // Check if the role exists in the guild
     const classRole = interaction.guild.roles.cache.get(classRoleId);
     if (!classRole) {
-            await interaction.reply({
-                ...getEnrollmentErrorEmbed(`The configured role ID \`${classRoleId}\` for class **${selectedClass.name}** does not exist in this server.`, "Configuration Error"),
-                flags: MessageFlags.Ephemeral
-            });
-            return;
+        throw new UserError(`The configured role ID \`${classRoleId}\` for class **${selectedClass.name}** does not exist in this server.`);
     }
 
     // 4. Perform Enrollment Actions
-
     await member.roles.remove(visitorRole);
     await member.roles.add(studentRole);
     await member.roles.add(classRole);
@@ -109,12 +90,4 @@ export async function handleEnrollmentInteraction(interaction: ButtonInteraction
                 .catch((err: any) => console.error("Failed to send welcome message:", err));
         }
     }
-
-    } catch (error) {
-        console.error("Enrollment error:", error);
-        await interaction.reply({
-            ...getEnrollmentErrorEmbed("An unexpected error occurred during enrollment. Please contact an administrator.", "System Error"),
-            flags: MessageFlags.Ephemeral
-        });
-    }
 }

src/modules/user/user.service.test.ts

@@ -20,6 +20,7 @@ mockUpdate.mockReturnValue({ set: mockSet });
 mockSet.mockReturnValue({ where: mockWhere });
 mockWhere.mockReturnValue({ returning: mockReturning });
 
+mockDelete.mockReturnValue({ where: mockWhere });
 
 // Mock DrizzleClient
 mock.module("@/lib/DrizzleClient", () => {
@@ -51,12 +52,39 @@ mock.module("@/lib/DrizzleClient", () => {
     };
 });
 
+// Mock withTransaction helper to use the same pattern as DrizzleClient.transaction
+mock.module("@/lib/db", () => {
+    return {
+        withTransaction: async (callback: any, tx?: any) => {
+            if (tx) {
+                return callback(tx);
+            }
+            // Simulate transaction by calling the callback with mock db
+            return callback({
+                query: {
+                    users: {
+                        findFirst: mockFindFirst,
+                    },
+                },
+                insert: mockInsert,
+                update: mockUpdate,
+                delete: mockDelete,
+            });
+        }
+    };
+});
+
+
 describe("userService", () => {
     beforeEach(() => {
         mockFindFirst.mockReset();
         mockInsert.mockClear();
         mockValues.mockClear();
         mockReturning.mockClear();
+        mockUpdate.mockClear();
+        mockSet.mockClear();
+        mockWhere.mockClear();
+        mockDelete.mockClear();
     });
 
     describe("getUserById", () => {
@@ -80,7 +108,91 @@ describe("userService", () => {
         });
     });
 
-    describe("createUser", () => {
+    describe("getUserByUsername", () => {
+        it("should return user when username exists", async () => {
+            const mockUser = { id: 456n, username: "alice", balance: 100n };
+            mockFindFirst.mockResolvedValue(mockUser);
+
+            const result = await userService.getUserByUsername("alice");
+
+            expect(result).toEqual(mockUser as any);
+            expect(mockFindFirst).toHaveBeenCalledTimes(1);
+        });
+
+        it("should return undefined when username not found", async () => {
+            mockFindFirst.mockResolvedValue(undefined);
+
+            const result = await userService.getUserByUsername("nonexistent");
+
+            expect(result).toBeUndefined();
+        });
+    });
+
+    describe("getUserClass", () => {
+        it("should return user class when user has a class", async () => {
+            const mockClass = { id: 1n, name: "Warrior", emoji: "⚔️" };
+            const mockUser = { id: 123n, username: "testuser", class: mockClass };
+            mockFindFirst.mockResolvedValue(mockUser);
+
+            const result = await userService.getUserClass("123");
+
+            expect(result).toEqual(mockClass as any);
+        });
+
+        it("should return null when user has no class", async () => {
+            const mockUser = { id: 123n, username: "testuser", class: null };
+            mockFindFirst.mockResolvedValue(mockUser);
+
+            const result = await userService.getUserClass("123");
+
+            expect(result).toBeNull();
+        });
+
+        it("should return undefined when user not found", async () => {
+            mockFindFirst.mockResolvedValue(undefined);
+
+            const result = await userService.getUserClass("999");
+
+            expect(result).toBeUndefined();
+        });
+    });
+
+    describe("getOrCreateUser (withTransaction)", () => {
+        it("should return existing user if found", async () => {
+            const mockUser = { id: 123n, username: "existinguser", class: null };
+            mockFindFirst.mockResolvedValue(mockUser);
+
+            const result = await userService.getOrCreateUser("123", "existinguser");
+
+            expect(result).toEqual(mockUser as any);
+            expect(mockFindFirst).toHaveBeenCalledTimes(1);
+            expect(mockInsert).not.toHaveBeenCalled();
+        });
+
+        it("should create new user if not found", async () => {
+            const newUser = { id: 789n, username: "newuser", classId: null };
+
+            // First call returns undefined (user not found)
+            // Second call returns the newly created user (after insert + re-query)
+            mockFindFirst
+                .mockResolvedValueOnce(undefined)
+                .mockResolvedValueOnce({ id: 789n, username: "newuser", class: null });
+
+            mockReturning.mockResolvedValue([newUser]);
+
+            const result = await userService.getOrCreateUser("789", "newuser");
+
+            expect(mockInsert).toHaveBeenCalledTimes(1);
+            expect(mockValues).toHaveBeenCalledWith({
+                id: 789n,
+                username: "newuser"
+            });
+            // Should query twice: once to check, once after insert
+            expect(mockFindFirst).toHaveBeenCalledTimes(2);
+        });
+    });
+
+    describe("createUser (withTransaction)", () => {
         it("should create and return a new user", async () => {
             const newUser = { id: 456n, username: "newuser", classId: null };
             mockReturning.mockResolvedValue([newUser]);
@@ -95,5 +207,53 @@ describe("userService", () => {
                 classId: undefined
             });
         });
+
+        it("should create user with classId when provided", async () => {
+            const newUser = { id: 999n, username: "warrior", classId: 5n };
+            mockReturning.mockResolvedValue([newUser]);
+
+            const result = await userService.createUser("999", "warrior", 5n);
+
+            expect(result).toEqual(newUser as any);
+            expect(mockValues).toHaveBeenCalledWith({
+                id: 999n,
+                username: "warrior",
+                classId: 5n
+            });
+        });
+    });
+
+    describe("updateUser (withTransaction)", () => {
+        it("should update user data", async () => {
+            const updatedUser = { id: 123n, username: "testuser", balance: 500n };
+            mockReturning.mockResolvedValue([updatedUser]);
+
+            const result = await userService.updateUser("123", { balance: 500n });
+
+            expect(result).toEqual(updatedUser as any);
+            expect(mockUpdate).toHaveBeenCalledTimes(1);
+            expect(mockSet).toHaveBeenCalledWith({ balance: 500n });
+        });
+
+        it("should update multiple fields", async () => {
+            const updatedUser = { id: 456n, username: "alice", xp: 100n, level: 5 };
+            mockReturning.mockResolvedValue([updatedUser]);
+
+            const result = await userService.updateUser("456", { xp: 100n, level: 5 });
+
+            expect(result).toEqual(updatedUser as any);
+            expect(mockSet).toHaveBeenCalledWith({ xp: 100n, level: 5 });
+        });
+    });
+
+    describe("deleteUser (withTransaction)", () => {
+        it("should delete user from database", async () => {
+            mockWhere.mockResolvedValue(undefined);
+
+            await userService.deleteUser("123");
+
+            expect(mockDelete).toHaveBeenCalledTimes(1);
+            expect(mockWhere).toHaveBeenCalledTimes(1);
+        });
     });
 });

src/modules/user/user.service.ts

@@ -1,6 +1,8 @@
 import { users } from "@/db/schema";
 import { eq } from "drizzle-orm";
 import { DrizzleClient } from "@/lib/DrizzleClient";
+import { withTransaction } from "@/lib/db";
+import type { Transaction } from "@/lib/types";
 
 export const userService = {
     getUserById: async (id: string) => {
@@ -14,23 +16,27 @@ export const userService = {
         const user = await DrizzleClient.query.users.findFirst({ where: eq(users.username, username) });
         return user;
     },
-    getOrCreateUser: async (id: string, username: string, tx?: any) => {
-        const execute = async (txFn: any) => {
+    getOrCreateUser: async (id: string, username: string, tx?: Transaction) => {
+        return await withTransaction(async (txFn) => {
             let user = await txFn.query.users.findFirst({
                 where: eq(users.id, BigInt(id)),
                 with: { class: true }
             });
 
             if (!user) {
-                const [newUser] = await txFn.insert(users).values({
+                await txFn.insert(users).values({
                     id: BigInt(id),
                     username,
                 }).returning();
-                user = { ...newUser, class: null };
+
+                // Re-query to get the user with class relation
+                user = await txFn.query.users.findFirst({
+                    where: eq(users.id, BigInt(id)),
+                    with: { class: true }
+                });
             }
             return user;
-        };
-        return tx ? await execute(tx) : await DrizzleClient.transaction(execute);
+        }, tx);
     },
     getUserClass: async (id: string) => {
         const user = await DrizzleClient.query.users.findFirst({
@@ -39,31 +45,28 @@ export const userService = {
         });
         return user?.class;
     },
-    createUser: async (id: string | bigint, username: string, classId?: bigint, tx?: any) => {
-        const execute = async (txFn: any) => {
+    createUser: async (id: string | bigint, username: string, classId?: bigint, tx?: Transaction) => {
+        return await withTransaction(async (txFn) => {
             const [user] = await txFn.insert(users).values({
                 id: BigInt(id),
                 username,
                 classId,
             }).returning();
             return user;
-        };
-        return tx ? await execute(tx) : await DrizzleClient.transaction(execute);
+        }, tx);
     },
-    updateUser: async (id: string, data: Partial<typeof users.$inferInsert>, tx?: any) => {
-        const execute = async (txFn: any) => {
+    updateUser: async (id: string, data: Partial<typeof users.$inferInsert>, tx?: Transaction) => {
+        return await withTransaction(async (txFn) => {
             const [user] = await txFn.update(users)
                 .set(data)
                 .where(eq(users.id, BigInt(id)))
                 .returning();
             return user;
-        };
-        return tx ? await execute(tx) : await DrizzleClient.transaction(execute);
+        }, tx);
     },
-    deleteUser: async (id: string, tx?: any) => {
-        const execute = async (txFn: any) => {
+    deleteUser: async (id: string, tx?: Transaction) => {
+        return await withTransaction(async (txFn) => {
             await txFn.delete(users).where(eq(users.id, BigInt(id)));
-        };
-        return tx ? await execute(tx) : await DrizzleClient.transaction(execute);
+        }, tx);
     },
 };

src/modules/user/user.timers.ts

@@ -1,8 +1,9 @@
 import { userTimers } from "@/db/schema";
 import { eq, and } from "drizzle-orm";
 import { DrizzleClient } from "@/lib/DrizzleClient";
+import { TimerType } from "@/lib/constants";
 
-export type TimerType = 'COOLDOWN' | 'EFFECT' | 'ACCESS';
+export { TimerType };
 
 export const userTimerService = {
     /**

src/web/public/style.css

@@ -0,0 +1,68 @@
+:root {
+    --bg-color: #0f172a;
+    --text-color: #f8fafc;
+    --accent-color: #38bdf8;
+    --card-bg: #1e293b;
+    --font-family: system-ui, -apple-system, sans-serif;
+}
+
+body {
+    background-color: var(--bg-color);
+    color: var(--text-color);
+    font-family: var(--font-family);
+    margin: 0;
+    line-height: 1.5;
+    display: flex;
+    flex-direction: column;
+    min-height: 100vh;
+}
+
+header {
+    background-color: var(--card-bg);
+    padding: 1rem 2rem;
+    border-bottom: 1px solid #334155;
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+}
+
+header h1 {
+    margin: 0;
+    font-size: 1.5rem;
+    color: var(--accent-color);
+}
+
+main {
+    flex: 1;
+    padding: 2rem;
+    max-width: 1200px;
+    margin: 0 auto;
+    width: 100%;
+    box-sizing: border-box;
+}
+
+.card {
+    background-color: var(--card-bg);
+    border-radius: 0.5rem;
+    padding: 1.5rem;
+    margin-bottom: 1rem;
+    border: 1px solid #334155;
+    box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1);
+}
+
+footer {
+    text-align: center;
+    padding: 1rem;
+    color: #94a3b8;
+    font-size: 0.875rem;
+    border-top: 1px solid #334155;
+}
+
+a {
+    color: var(--accent-color);
+    text-decoration: none;
+}
+
+a:hover {
+    text-decoration: underline;
+}

src/web/router.test.ts

@@ -0,0 +1,52 @@
+import { describe, expect, it } from "bun:test";
+import { router } from "./router";
+
+describe("Web Router", () => {
+    it("should return home page on /", async () => {
+        const req = new Request("http://localhost/");
+        const res = await router(req);
+        expect(res.status).toBe(200);
+        expect(res.headers.get("Content-Type")).toBe("text/html");
+        expect(await res.text()).toContain("Aurora Web");
+    });
+
+    it("should return health check on /health", async () => {
+        const req = new Request("http://localhost/health");
+        const res = await router(req);
+        expect(res.status).toBe(200);
+        expect(res.headers.get("Content-Type")).toBe("application/json");
+        const data = await res.json();
+        expect(data).toHaveProperty("status", "ok");
+    });
+
+    it("should block path traversal", async () => {
+        // Attempts to go up two directories to reach the project root or src
+        const req = new Request("http://localhost/public/../../package.json");
+        const res = await router(req);
+        // Should be 403 Forbidden or 404 Not Found (our logical change makes it 403)
+        expect([403, 404]).toContain(res.status);
+    });
+
+    it("should serve existing static file", async () => {
+        // We know style.css exists in src/web/public
+        const req = new Request("http://localhost/public/style.css");
+        const res = await router(req);
+        expect(res.status).toBe(200);
+        if (res.status === 200) {
+            const text = await res.text();
+            expect(text).toContain("body");
+        }
+    });
+
+    it("should not serve static files on non-GET methods", async () => {
+        const req = new Request("http://localhost/public/style.css", { method: "POST" });
+        const res = await router(req);
+        expect(res.status).toBe(404);
+    });
+
+    it("should return 404 for unknown routes", async () => {
+        const req = new Request("http://localhost/unknown");
+        const res = await router(req);
+        expect(res.status).toBe(404);
+    });
+});

src/web/router.ts

@@ -0,0 +1,53 @@
+import { homeRoute } from "./routes/home";
+import { healthRoute } from "./routes/health";
+import { file } from "bun";
+import { join, resolve } from "path";
+
+export async function router(request: Request): Promise<Response> {
+    const url = new URL(request.url);
+    const method = request.method;
+
+    // Resolve the absolute path to the public directory
+    const publicDir = resolve(import.meta.dir, "public");
+
+    if (method === "GET") {
+        // Handle Static Files
+        // We handle requests starting with /public/ OR containing an extension (like /style.css)
+        if (url.pathname.startsWith("/public/") || url.pathname.includes(".")) {
+            // Normalize path: remove /public prefix if present so that
+            // /public/style.css and /style.css both map to .../public/style.css
+            const relativePath = url.pathname.replace(/^\/public/, "");
+
+            // Resolve full path
+            // We use join with relativePath. If relativePath starts with /, join handles it correctly
+            // effectively treating it as a segment.
+            // However, to be extra safe with 'resolve', we ensure we are resolving from publicDir.
+            // simple join(publicDir, relativePath) is usually enough with 'bun'.
+            // But we use 'resolve' to handle .. segments correctly.
+            // We prepend '.' to relativePath to ensure it's treated as relative to publicDir logic
+            const normalizedRelative = relativePath.startsWith("/") ? "." + relativePath : relativePath;
+            const requestedPath = resolve(publicDir, normalizedRelative);
+
+            // Security Check: Block Path Traversal
+            if (requestedPath.startsWith(publicDir)) {
+                const staticFile = file(requestedPath);
+                if (await staticFile.exists()) {
+                    return new Response(staticFile);
+                }
+            } else {
+                // If path traversal detected, return 403 or 404. 
+                // 403 indicates we caught them.
+                return new Response("Forbidden", { status: 403 });
+            }
+        }
+
+        if (url.pathname === "/" || url.pathname === "/index.html") {
+            return homeRoute();
+        }
+        if (url.pathname === "/health") {
+            return healthRoute();
+        }
+    }
+
+    return new Response("Not Found", { status: 404 });
+}

src/web/routes/health.ts

@@ -0,0 +1,9 @@
+export function healthRoute(): Response {
+    return new Response(JSON.stringify({
+        status: "ok",
+        uptime: process.uptime(),
+        timestamp: new Date().toISOString()
+    }), {
+        headers: { "Content-Type": "application/json" },
+    });
+}

src/web/routes/home.ts

@@ -0,0 +1,20 @@
+import { BaseLayout } from "../views/layout";
+
+export function homeRoute(): Response {
+    const content = `
+        <div class="card">
+            <h2>Welcome</h2>
+            <p>The Aurora web server is up and running!</p>
+        </div>
+        <div class="card">
+            <h3>Status</h3>
+            <p>System operational.</p>
+        </div>
+    `;
+
+    const html = BaseLayout({ title: "Home", content });
+
+    return new Response(html, {
+        headers: { "Content-Type": "text/html" },
+    });
+}