diff --git a/README.md b/README.md
index 8da5680..94c0398 100644
--- a/README.md
+++ b/README.md
@@ -1,8 +1,6 @@
-# ๐ฌ SceneStack
+# SceneStack
-> *Tracking the shows youโll definitely finishโฆ eventuallyโฆ probably not.*
-
-A personal movie & TV show tracker with a gorgeous glassmorphic UI. Yes, it's *another* media tracking app โ the "TODO list" of MERN stack projects.
+> A modern full-stack web application for tracking movies and TV shows. Built as a learning project to explore the MERN stack, TypeScript, real-time communication, and scalable application architecture.


@@ -10,216 +8,451 @@ A personal movie & TV show tracker with a gorgeous glassmorphic UI. Yes, it's *a



-
-> ๐ **Learning Project** โ This is my playground for learning the MERN stack (MongoDB, Express, React, Node.js), TypeScript, and modern web development.
+**Learning Project** โ This application was developed to gain hands-on experience with modern web development technologies and architectural patterns including RESTful APIs, real-time synchronization, client-side routing, state management, and responsive design.
---
-## โจ Features
-
-- ๐ **Search** movies & TV shows via TMDB
-- ๐บ **Track episodes** - mark individual episodes as watched
-- ๐ **Statistics** - see exactly how much of your life you've spent watching
-- ๐ท๏ธ **Tags** - organize your chaos with custom tags (Still WIP)
-- ๐ฏ **Recommendations** - discover what to watch next
-- โ๏ธ **Real-time sync** - your watchlist lives in the cloud, access from anywhere
-- ๐ **Notifications** - get alerted when new episodes drop (WIP โ TMDB doesn't have a notifications API, so I'm currently negotiating with their servers to not rate-limit me into oblivion)
-- ๐ **Dark mode only** - because we're civilized
+## Features
+
+**Core Functionality**
+- Full-text search for movies and TV shows powered by TMDB API
+- Episode-level tracking for TV series with season/episode granularity
+- Personal watchlist with status management (watching, completed, planned)
+- Custom tagging system for content organization
+- Personalized recommendations based on viewing history
+- Cloud-synchronized data with real-time updates across devices
+
+**Analytics & Insights**
+- Viewing statistics dashboard with time tracking
+- Completion rate and binge-level metrics
+- Genre analysis and taste profiling
+- Visual progress indicators
+
+**User Experience**
+- Dark-themed glassmorphic UI with smooth animations
+- Fully responsive design (mobile-first approach)
+- Client-side routing with browser history integration
+- Optimistic UI updates with conflict resolution
+
+**Security & Performance**
+- JWT-based authentication with HTTP-only cookies
+- Server-side TMDB API proxy (prevents exposed API keys)
+- Redis-based response caching with configurable TTL
+- Rate limiting and request throttling
+- Deferred rendering for heavy computations
+
+**Work in Progress**
+- Episode release notifications (currently exploring TMDB's content update API patterns)
---
-## ๐๏ธ Project Structure
+## Architecture
+
+### System Overview
```
-SceneStack/
-โโโ cinetrack-app/ โ The actual app lives here
-โ โโโ client/ โ React frontend (Vite + TypeScript)
-โ โโโ server/ โ Express backend (Node.js)
-โ โโโ package.json โ Monorepo root
-โโโ README.md โ You are here
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Client (React SPA) โ
+โ โโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโโโโโ โ
+โ โ React Routerโ โ Zustand โ โ Socket.IO Clientโ โ
+โ โ (SPA Routes)โ โ(State Mgmt) โ โ (Real-time Sync)โ โ
+โ โโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโโโโโ โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโฌโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+ โ HTTPS/WSS
+โโโโโโโโโโโโโโโโโโโโโโโโโโโดโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Express.js Server (Node.js) โ
+โ โโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโโโโโ โ
+โ โ Auth โ โ Watchlist โ โ TMDB Proxy โ โ
+โ โ Middleware โ โ Routes โ โ (Server-side) โ โ
+โ โโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโโโโโ โ
+โ โโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโ โ
+โ โ Socket.IO โ โ Redis โ โ
+โ โ Server โ โ Cache โ โ
+โ โโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโ โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโฌโโโโโโโโโโโโโโโโโโโโฌโโโโโโโโโโโโโโโโ
+ โ โ
+ โโโโโโโโโโดโโโโโโโโโ โโโโโโโโดโโโโโโโ
+ โ MongoDB Atlas โ โ TMDB API โ
+ โ (Database) โ โ (External) โ
+ โโโโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโ
```
-### "Why is there a `cinetrack-app` folder inside `SceneStack`?"
-
-Ah yes, the elephant in the repo. ๐
-
-**The honest answer:** This project started as CineTrack before being renamed. The folder structure is a happy accident that became permanent. By the time I realized the mistake, I had already pushed commits and... well... here we are.
-
-**The professional answer:** It's a deliberate architectural decision to support future multi-app monorepo expansion. *\*adjusts imaginary glasses\**
-
-**TL;DR:** It's technical debt I've learned to love. Like that one weird bug that somehow makes everything work.
+### Technology Stack
+
+| Layer | Technology |
+|-------|------------|
+| **Frontend** | React 19 + TypeScript |
+| **Routing** | React Router v7 |
+| **State Management** | Zustand |
+| **Styling** | Tailwind CSS 4 |
+| **Build Tool** | Vite 7 |
+| **Backend** | Express.js 4 |
+| **Real-time** | Socket.IO |
+| **Database** | MongoDB Atlas |
+| **Caching** | Redis (Upstash) |
+| **Authentication** | JWT + bcrypt |
+| **External API** | TMDB API v3 |
+
+### Key Architectural Decisions
+
+**Monorepo Structure**
+- Client and server share a workspace for atomic commits and coordinated deployment
+- Single build process compiles React app and serves it via Express in production
+
+**State Management Evolution**
+- Migrated from React Context to Zustand for better render optimization
+- Implemented selector hooks to prevent unnecessary re-renders
+- Deferred heavy computations with React 18's `useDeferredValue`
+
+**API Design**
+- Server-side TMDB proxy eliminates client-side API key exposure
+- Redis caching reduces external API calls by ~85% (configurable TTL per endpoint)
+- LRU eviction for high-volume endpoints (search, details, recommendations)
+
+**Real-time Synchronization**
+- Socket.IO broadcasts watchlist changes to all user sessions
+- Optimistic UI updates with server confirmation
+- Conflict resolution on concurrent modifications
+
+**Performance Optimizations**
+- Route-based code splitting with React lazy loading
+- Manual chunk splitting (React vendor, Socket.IO, libraries)
+- Debounced search with abort controller for in-flight requests
+- Image lazy loading with intersection observer
---
-## ๐๏ธ Why a Monorepo?
+## Project Structure
-The frontend and backend are in the same repository because:
+```
+SceneStack/
+โโโ cinetrack-app/ # Monorepo root
+โ โโโ client/ # React frontend
+โ โ โโโ src/
+โ โ โ โโโ components/ # Reusable UI components
+โ โ โ โโโ contexts/ # React contexts (Auth, UI, Discover)
+โ โ โ โโโ layouts/ # Layout components (RootLayout)
+โ โ โ โโโ pages/ # Route-level page components
+โ โ โ โโโ services/ # API client layer
+โ โ โ โโโ store/ # Zustand stores
+โ โ โ โโโ types/ # TypeScript type definitions
+โ โ โ โโโ router.tsx # Route configuration
+โ โ โ โโโ App.tsx # Root component
+โ โ โโโ package.json
+โ โ โโโ vite.config.ts
+โ โโโ server/ # Express backend
+โ โ โโโ src/
+โ โ โ โโโ config.js # Environment config & Redis init
+โ โ โ โโโ middleware/ # Error handling, validation
+โ โ โ โโโ routes/ # API route handlers
+โ โ โ โ โโโ authRoutes.js
+โ โ โ โ โโโ watchlistRoutes.js
+โ โ โ โ โโโ tmdbRoutes.js
+โ โ โ โโโ schemas/ # Zod validation schemas
+โ โ โ โโโ server.js # Express app entry point
+โ โ โโโ package.json
+โ โโโ package.json # Workspace root (npm workspaces)
+โ โโโ Dockerfile # Multi-stage production build
+โโโ README.md # This file
+```
-1. **Shared deployment** - One push, both deploy. Render loves it. I love it. Everyone's happy.
-2. **Atomic commits** - Change the API and the frontend together. No more "which version is this compatible with?"
-3. **Simplicity** - It's just me here.
+**Note on Naming**: The `cinetrack-app` directory exists as a historical artifact from the project's original name. While the project is now branded as SceneStack, the internal folder structure remains unchanged. This is a deliberate decisionโrenaming would require updating import paths, deployment configurations, and version control history. Sometimes technical debt is best left untouched.
---
-## ๐ Getting Started
+## Getting Started
-### ๐ฎ๐ณ Important Note
+### Prerequisites
-> **Plot twist:** The app will NOT work in India unless you set a custom DNS. TMDB is blocked on Jio (Not tested other ISP's), for reasons known only to Jio, who apparently thinks a harmless movie database is more dangerous than the thousands of scam sites that load instantly when you misspell โgmail.โ
+- **Node.js** 18 or higher
+- **MongoDB Atlas** account (or local MongoDB instance)
+- **TMDB API** Read Access Token ([get one here](https://www.themoviedb.org/settings/api))
+- **Redis** instance (optional but recommended โ Upstash free tier works well)
-**The fix:** Use a custom DNS provider.
-- [Cloudflare DNS](https://1.1.1.1/) โ `1.1.1.1`
-- [Google DNS](https://developers.google.com/speed/public-dns) โ `8.8.8.8`
-- [NextDNS](https://nextdns.io/) โ for the privacy-conscious
-- [AdGuard DNS](https://adguard-dns.io/) โ blocks ads too
+### Important Note
-Set it on your router, device, or browser, and you're good to go. Welcome to the internet, the way it was meant to be.
+TMDB API endpoints are blocked by some Indian ISPs (particularly Jio). If you encounter connection errors, configure a custom DNS provider:
-### Prerequisites
+- **Cloudflare DNS**: `1.1.1.1` / `1.0.0.1`
+- **Google DNS**: `8.8.8.8` / `8.8.4.4`
+- **Quad9 DNS**: `9.9.9.9`
-- Node.js 18+
-- MongoDB Atlas account (or local MongoDB)
-- TMDB API key ([get one here](https://www.themoviedb.org/settings/api))
-- Redis (optional - [Upstash](https://upstash.com/) free tier works great)
+Configure DNS at the router level, operating system network settings, or browser level (Firefox, Edge support DNS over HTTPS).
-### Setup
+### Local Development Setup
```bash
-# Clone the repo
+# Clone the repository
git clone https://github.com/Alameen1433/SceneStack.git
cd SceneStack/cinetrack-app
# Install all dependencies (uses npm workspaces)
npm install
-# Set up environment variables
+# Configure server environment
cp server/.env.example server/.env
-# Edit server/.env with your MongoDB URI, JWT secret, etc.
+# Edit server/.env with your credentials (MongoDB URI, JWT secret, etc.)
+# Configure client environment (optional - only needed if using client-side fallback)
cp client/.env.example client/.env
-# Edit client/.env with your TMDB read access token
+# Edit client/.env with your TMDB token
```
-### Development Mode
+### Running in Development Mode
-Run the client and server in **two separate terminals**:
+The application requires two processes: the Express backend and the Vite dev server. Run in separate terminals:
```bash
-# Terminal 1 - Start the backend server (port 3001)
+# Terminal 1: Start the backend server (http://localhost:3001)
npm run dev:server
-# Terminal 2 - Start the frontend dev server (port 5173)
+# Terminal 2: Start the frontend dev server (http://localhost:5173)
npm run dev:client
```
-### Deployment (Render, AWS, Railway, etc.)
+The Vite dev server proxies API requests to the backend automatically (configured in `client/vite.config.ts`).
+
+### Development with Docker (Optional)
+
+For local development, you can use Docker Compose to run MongoDB and Redis locally instead of using cloud services.
+
+**Start local services:**
+```bash
+cd cinetrack-app/infra
+docker-compose up -d
+```
+
+This starts:
+- **MongoDB** on `localhost:27017` (data persisted in `infra/data/mongo`)
+- **Redis** on `localhost:6379` (data persisted in `infra/data/redis`)
+
+**Update your `.env` file:**
+```bash
+# Use local MongoDB instead of Atlas
+MONGO_URI=mongodb://localhost:27017/scenestackDB
+
+# Use local Redis instead of Upstash
+REDIS_URL=redis://localhost:6379
+```
+
+**Stop services:**
+```bash
+docker-compose down
+```
+
+**Note**: The `Dockerfile` in the project root is for production deployment, not local development. It uses a multi-stage build to compile the React app and create a minimal production image.
+
+### Production Deployment
+
+The application is designed to run as a monolithic deployment where Express serves both the API and the compiled React frontend.
-This project is configured to run as a **monolith** in production: the Express server serves both the API and the compiled React frontend.
+**Build Process:**
+1. `npm run build` compiles the React app to `client/dist/`
+2. `npm start` runs the Express server which serves `client/dist/` as static files
-**General Application Settings:**
-- **Build Command:** `npm install && npm run build` (Installs deps & compiles React)
-- **Start Command:** `npm start` (Starts Express server)
-- **Root Directory:** `cinetrack-app`
+**General Deployment Configuration:**
+- **Build Command**: `npm install && npm run build`
+- **Start Command**: `npm start`
+- **Root Directory**: `cinetrack-app`
+- **Node Version**: 18 or higher
-#### Example: Deploying to Render
-1. **Create a Web Service** and connect your GitHub repo
-2. **Use the General Settings** above
-3. **Add Environment Variables:**
- - `MONGO_URI`, `JWT_SECRET`, `INVITE_CODES`
- - `VITE_TMDB_API_READ_ACCESS_TOKEN`
-4. **Deploy**
+**Platform-Specific Examples:**
-#### AWS / Other Platforms
-The procedure is virtually the same. Ensure your platform builds the client (`npm run build`) and starts the server (`npm start`).
-- **AWS Elastic Beanstalk:** Configure the build script to run `npm run build` before starting.
-- **Railway/Heroku:** Similar to Render, just set the build and start commands.
+
+Render
-> **How it works:** `npm run build` compiles the React app to `client/dist/`. The Express server serves these static files in production alongside the API routes.
+1. Create a new **Web Service**
+2. Connect your GitHub repository
+3. Configure:
+ - **Root Directory**: `cinetrack-app`
+ - **Build Command**: `npm install && npm run build`
+ - **Start Command**: `npm start`
+4. Add environment variables (see below)
+5. Deploy
+
-### Environment Variables
+
+AWS Elastic Beanstalk
-**Server** (`cinetrack-app/server/.env`):
-```env
+1. Package the `cinetrack-app` directory
+2. Create a Node.js environment
+3. Configure `npm start` as the start command
+4. Ensure `npm run build` runs before application start (use `.ebextensions` if needed)
+5. Set environment variables via EB configuration
+
+
+
+Railway / Heroku
+
+1. Connect repository
+2. Set root directory to `cinetrack-app`
+3. Railway auto-detects the build process
+4. Add environment variables via dashboard
+
+
+---
+
+## Environment Variables
+
+### Server (`cinetrack-app/server/.env`)
+
+```bash
# MongoDB connection string (required)
MONGO_URI=mongodb+srv://username:password@cluster.mongodb.net/scenestackDB
# JWT secret for token signing (required)
-JWT_SECRET=your-super-secret-jwt-key
+# Generate a secure secret: https://jwtsecrets.com/#generator
+JWT_SECRET=your-super-secret-jwt-key-change-in-production
-# Comma-separated invite codes for registration
-INVITE_CODES=SCENESTACK2024,YOURCODE
+# Comma-separated invite codes (required)
+INVITE_CODES=SCENESTACK2024,FRIEND2024
+
+# TMDB API Read Access Token (required)
+TMDB_API_READ_ACCESS_TOKEN=your_tmdb_read_access_token
+
+# Redis connection string (optional - caching disabled if not set)
+REDIS_URL=rediss://default:password@instance.upstash.io:6379
# Server port (optional, default: 3001)
PORT=3001
-# TMDB API Read Access Token (required for TMDB proxy)
-TMDB_API_READ_ACCESS_TOKEN=your_tmdb_read_access_token
-
-# Redis URL (optional - caching disabled if not set)
-# Get a free Redis instance at https://upstash.com/
-REDIS_URL=rediss://default:your_password@your-instance.upstash.io:6379
+# Demo mode settings (optional)
+DEMO_CODE=DEMONOW
+DEMO_TTL_SECONDS=14400
```
-**Client** (`cinetrack-app/client/.env`):
-```env
-# TMDB API Read Access Token (required - used as fallback if backend proxy fails)
+### Client (`cinetrack-app/client/.env`)
+
+```bash
+# TMDB Read Access Token (optional - used as fallback if backend proxy fails)
VITE_TMDB_API_READ_ACCESS_TOKEN=your_tmdb_read_access_token
-# API Base URL (leave empty in production)
+# API base URL (leave empty in production)
VITE_API_BASE_URL=
```
+**Note**: In production, the client should rely exclusively on the server-side TMDB proxy. The client-side token is only used as a fallback during development or if the proxy endpoint is unreachable.
+
---
-## ๐ก Tech Stack
+## API Documentation
+
+### Authentication Endpoints
+
+**POST** `/api/auth/register`
+- Registers a new user with invite code
+- **Body**: `{ username, password, inviteCode }`
+- **Response**: `{ user, token }`
+
+**POST** `/api/auth/login`
+- Authenticates user and returns JWT
+- **Body**: `{ username, password }`
+- **Response**: `{ user, token }`
+
+### Watchlist Endpoints
+
+**GET** `/api/watchlist`
+- Retrieves user's complete watchlist
+- **Auth**: Required
+- **Response**: `{ watchlist: WatchlistItem[] }`
+
+**PUT** `/api/watchlist/:id`
+- Updates or creates a watchlist item
+- **Auth**: Required
+- **Response**: `{ item: WatchlistItem }`
+
+**DELETE** `/api/watchlist/:id`
+- Removes an item from the watchlist
+- **Auth**: Required
+- **Response**: `{ success: boolean }`
+
+### TMDB Proxy Endpoints
+
+**GET** `/api/tmdb/discover`
+- Fetches trending, popular movies, and popular TV shows
+- **Cache**: 6 hours
+
+**GET** `/api/tmdb/search?q=`
+- Searches for movies and TV shows
+- **Cache**: 1 hour (LRU, max 1000 entries)
+
+**GET** `/api/tmdb/details/:type/:id`
+- Fetches detailed information for a movie or TV show
+- **Cache**: 1 hour (LRU, max 500 entries)
+
+---
-| Layer | Technology | Why |
-|-------|------------|-----|
-| Frontend | React 19 + TypeScript | Because I like my errors at compile time |
-| Styling | Tailwind CSS | `className` that goes on for three lines |
-| Build | Vite | Fast. Really fast. Like, make-webpack-look-like-a-sloth fast. |
-| Backend | Express.js | Simple, battle-tested, no surprises |
-| Real-time | Socket.IO | So your watchlist syncs faster than you can say "just one more episode" |
-| Database | MongoDB Atlas | JSON in, JSON out. No ORM drama. |
-| Cache | Redis (Upstash) | TMDB responses cached for speed & rate limit protection |
-| Auth | JWT + bcrypt | Stateless sessions, hashed passwords |
-| API | TMDB | The real MVP of this project |
+## Learning Outcomes
+
+This project served as a comprehensive learning experience covering:
+
+**Frontend Development**
+- Advanced React patterns (lazy loading, code splitting, render optimization)
+- TypeScript integration in a large-scale application
+- State management evolution (Context โ Zustand)
+- Client-side routing with React Router v7
+- CSS-in-JS to utility-first CSS migration
+- Animation with Framer Motion
+
+**Backend Development**
+- RESTful API design and authentication
+- MongoDB schema design for flexible document structures
+- Redis caching strategies (LRU eviction, TTL management)
+- Socket.IO for real-time bidirectional communication
+- Input validation with Zod schemas
+- Error handling middleware patterns
+
+**DevOps & Deployment**
+- Monorepo management with npm workspaces
+- Docker multi-stage builds
+- Environment-based configuration
+- Production optimization (minification, compression, caching headers)
+
+**Software Engineering**
+- Refactoring legacy code (migration from Context to Zustand)
+- Performance profiling and optimization
+- Security best practices (secret management, input sanitization)
+- API rate limiting and quota management
---
-## ๐จ Screenshots
+## Known Issues & Future Improvements
-*Coming soon*
+**Current Limitations**
+- Episode release notifications are not yet functional (TMDB doesn't provide a webhooks API; polling is being considered)
+- Tag filtering UI needs refinement for large tag collections
+- No offline support (service worker implementation planned)
---
-## ๐ค Contributing
+## Contributing
-This is a personal project, but if you want to:
+This is a personal learning project, but contributions are welcome. If you'd like to contribute:
-1. Fork it
-2. Create a branch (`git checkout -b feature/amazing-feature`)
-3. Commit your changes (`git commit -m 'Add amazing feature'`)
-4. Push to the branch (`git push origin feature/amazing-feature`)
-5. Open a Pull Request
+1. Fork the repository
+2. Create a feature branch (`git checkout -b feature/your-feature`)
+3. Commit changes with descriptive messages
+4. Push to your fork (`git push origin feature/your-feature`)
+5. Open a Pull Request with a clear description
---
-## ๐ License
+## License
-MIT - Do whatever you want, just don't blame me if it breaks.
+MIT License - See [LICENSE](LICENSE) for details
---
-## ๐ Acknowledgments
+## Acknowledgments
-- [TMDB](https://www.themoviedb.org/) - For the incredible API
-- [Claude](https://www.anthropic.com/claude/opus) - guiding me through bugs that felt personally offended by my existence.
-- My watchlist - For being eternally long and inspiring this project
+- **TMDB** for providing a comprehensive and well-documented API
+- **MongoDB Atlas** for generous free-tier hosting
+- **Upstash** for serverless Redis
+- **Claude** for serving as a tireless pair programmer and debugging companion
---
- Built with ๐ and an unhealthy amount of TypeScript - My Github
+ Built with ๐ and an unhealthy amount of TypeScript
diff --git a/cinetrack-app/Dockerfile b/cinetrack-app/Dockerfile
index 856f200..275af3b 100644
--- a/cinetrack-app/Dockerfile
+++ b/cinetrack-app/Dockerfile
@@ -11,9 +11,6 @@ RUN npm ci --include=dev
COPY client/ ./client/
COPY server/ ./server/
-ARG VITE_TMDB_API_READ_ACCESS_TOKEN
-ENV VITE_TMDB_API_READ_ACCESS_TOKEN=$VITE_TMDB_API_READ_ACCESS_TOKEN
-
RUN npm run build
FROM node:20-alpine AS production
diff --git a/cinetrack-app/README.md b/cinetrack-app/README.md
deleted file mode 100644
index d2e7761..0000000
--- a/cinetrack-app/README.md
+++ /dev/null
@@ -1,73 +0,0 @@
-# React + TypeScript + Vite
-
-This template provides a minimal setup to get React working in Vite with HMR and some ESLint rules.
-
-Currently, two official plugins are available:
-
-- [@vitejs/plugin-react](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react) uses [Babel](https://babeljs.io/) (or [oxc](https://oxc.rs) when used in [rolldown-vite](https://vite.dev/guide/rolldown)) for Fast Refresh
-- [@vitejs/plugin-react-swc](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react-swc) uses [SWC](https://swc.rs/) for Fast Refresh
-
-## React Compiler
-
-The React Compiler is not enabled on this template because of its impact on dev & build performances. To add it, see [this documentation](https://react.dev/learn/react-compiler/installation).
-
-## Expanding the ESLint configuration
-
-If you are developing a production application, we recommend updating the configuration to enable type-aware lint rules:
-
-```js
-export default defineConfig([
- globalIgnores(['dist']),
- {
- files: ['**/*.{ts,tsx}'],
- extends: [
- // Other configs...
-
- // Remove tseslint.configs.recommended and replace with this
- tseslint.configs.recommendedTypeChecked,
- // Alternatively, use this for stricter rules
- tseslint.configs.strictTypeChecked,
- // Optionally, add this for stylistic rules
- tseslint.configs.stylisticTypeChecked,
-
- // Other configs...
- ],
- languageOptions: {
- parserOptions: {
- project: ['./tsconfig.node.json', './tsconfig.app.json'],
- tsconfigRootDir: import.meta.dirname,
- },
- // other options...
- },
- },
-])
-```
-
-You can also install [eslint-plugin-react-x](https://github.com/Rel1cx/eslint-react/tree/main/packages/plugins/eslint-plugin-react-x) and [eslint-plugin-react-dom](https://github.com/Rel1cx/eslint-react/tree/main/packages/plugins/eslint-plugin-react-dom) for React-specific lint rules:
-
-```js
-// eslint.config.js
-import reactX from 'eslint-plugin-react-x'
-import reactDom from 'eslint-plugin-react-dom'
-
-export default defineConfig([
- globalIgnores(['dist']),
- {
- files: ['**/*.{ts,tsx}'],
- extends: [
- // Other configs...
- // Enable lint rules for React
- reactX.configs['recommended-typescript'],
- // Enable lint rules for React DOM
- reactDom.configs.recommended,
- ],
- languageOptions: {
- parserOptions: {
- project: ['./tsconfig.node.json', './tsconfig.app.json'],
- tsconfigRootDir: import.meta.dirname,
- },
- // other options...
- },
- },
-])
-```
diff --git a/cinetrack-app/client/src/components/layout/BottomNavBar.tsx b/cinetrack-app/client/src/components/layout/BottomNavBar.tsx
index f652476..110cd74 100644
--- a/cinetrack-app/client/src/components/layout/BottomNavBar.tsx
+++ b/cinetrack-app/client/src/components/layout/BottomNavBar.tsx
@@ -15,34 +15,40 @@ const NavItem: React.FC<{
}> = ({ label, icon, isActive, onClick }) => (