docs: Update documentation for OAuth-based architecture and easy fork/deploy

- Update WARP.md to reflect OAuth authentication flow
- Add comprehensive fork & deploy instructions for Railway, Render
- Document React frontend architecture and chunked uploads
- Add troubleshooting section and usage tips
- Highlight AT Protocol benefits for podcasting
- Remove hardcoded credential references

README.md

···
-# AT Protocol Podcast Host
+# ATCast - AT Protocol Podcast Host
 
-A podcast hosting platform that stores media files and RSS feeds using AT Protocol blob storage. Stream your podcasts directly from `at://` URIs!
+A podcast hosting platform that stores media files and RSS feeds using AT Protocol blob storage. Each user hosts their podcast on their own Bluesky/AT Protocol account - no centralized storage needed!
 
-## Features
+## ✨ Features
 
-- 🎙️ Upload podcast episodes to AT Protocol blob storage
-- 📡 Generate RSS feeds from AT Protocol-stored content
-- 🎵 Stream media files from `at://` URIs
-- 🔐 Secure authentication with Bluesky/AT Protocol
-- 📱 RESTful API for podcast management
-- 🌐 CORS-enabled for web player integration
+- 🎙️ **OAuth Authentication** - Users log in with their own Bluesky account
+- 📤 **Large File Support** - Automatic chunking for files over 5MB
+- 📡 **RSS Feed Generation** - Standard RSS 2.0 feeds with AT Protocol extensions
+- 🎵 **Direct Streaming** - Stream episodes from `at://` URIs
+- 📝 **Episode Management** - Full CRUD operations for podcast episodes
+- 🎨 **Modern UI** - React frontend with dark/light mode
+- 🌐 **Decentralized** - Each user's podcast data stored on their own PDS
+- 🔓 **Open Access** - Public RSS feeds accessible by DID
 
-## Prerequisites
+## 🚀 Quick Start: Fork & Deploy
 
-- Node.js 18+ 
-- An AT Protocol account (e.g., Bluesky account)
-- App password for your AT Protocol account
+### Option 1: Deploy to Railway (Recommended)
 
-## Setup
+[![Deploy on Railway](https://railway.app/button.svg)](https://railway.app/template/new)
 
-### 1. Clone and Install
+1. **Click the Deploy button** or go to [Railway](https://railway.app)
+2. **Fork this repository** to your GitHub account
+3. **Create a new project** in Railway from your forked repo
+4. **Set environment variables** (see below)
+5. **Deploy!** Railway will automatically build and start your app
 
-```bash
-cd atproto-podcast
-npm install
+**Required Environment Variables for Railway:**
+```
+NODE_ENV=production
+SESSION_SECRET=your-random-secret-key-here
+PUBLIC_URL=https://your-app.up.railway.app
 ```
 
-### 2. Configure Environment
+### Option 2: Deploy to Render
 
-Copy the example environment file:
+1. **Fork this repository** to your GitHub account
+2. Go to [Render Dashboard](https://dashboard.render.com)
+3. **New** → **Web Service**
+4. Connect your forked repository
+5. **Configure:**
+   - **Build Command:** `npm run build`
+   - **Start Command:** `npm start`
+   - **Environment Variables:** (see below)
 
-```bash
-cp .env.example .env
+**Required Environment Variables for Render:**
 ```
-
-Edit `.env` with your AT Protocol credentials:
-
-```env
-PORT=3000
-ATPROTO_SERVICE=https://bsky.social
-ATPROTO_IDENTIFIER=your-handle.bsky.social
-ATPROTO_PASSWORD=your-app-password
+NODE_ENV=production
+SESSION_SECRET=your-random-secret-key-here
+PUBLIC_URL=https://your-app.onrender.com
 ```
 
-**Note:** Get an app password from your Bluesky account settings, not your main password.
+### Option 3: Deploy to any Node.js host
 
-### 3. Run the Application
+1. **Fork and clone** this repository
+2. **Install dependencies:** `npm install`
+3. **Build frontend:** `npm run build`
+4. **Set environment variables** (create `.env` file)
+5. **Start:** `npm start`
 
-#### Development Mode (React + API)
+## 🔐 Environment Variables
 
-Run both the React frontend and backend API concurrently:
-```bash
-npm run dev:all
-```
+| Variable | Description | Example |
+|----------|-------------|----------|
+| `PORT` | Server port | `5000` (default) |
+| `NODE_ENV` | Environment | `production` or `development` |
+| `SESSION_SECRET` | Secret for session encryption | Generate with `openssl rand -base64 32` |
+| `PUBLIC_URL` | Your app's public URL | `https://your-app.railway.app` |
 
-This starts:
-- Backend API on `http://localhost:5000`
-- React frontend on `http://localhost:3000` (with proxy to API)
+**Important:** 
+- Generate a strong `SESSION_SECRET` - **never use the example value in production**
+- Set `PUBLIC_URL` to your actual deployed URL for OAuth to work correctly
+- No AT Protocol credentials needed - users authenticate with their own accounts!
 
-Or run them separately:
-```bash
-# Terminal 1 - Backend API
-npm run dev
+## 📋 Prerequisites for Local Development
 
-# Terminal 2 - React Frontend
-npm run client
-```
+- Node.js 18+ 
+- A Bluesky/AT Protocol account (for testing)
 
-#### Production Mode
+## 🛠️ Local Development Setup
 
-First, build the React application:
+### 1. Fork and Clone
+
 ```bash
-npm run build
+git clone https://github.com/YOUR-USERNAME/atproto-podcast-host.git
+cd atproto-podcast-host
 ```
 
-Then start the server:
+### 2. Install Dependencies
+
 ```bash
-npm start
+npm install
 ```
 
-The server will serve the built React app and API on `http://localhost:5000`
+This will install both backend and frontend dependencies automatically.
 
-## API Endpoints
+### 3. Configure Environment
 
-### Upload Episode
+```bash
+cp .env.example .env
 ```
-POST /api/upload/episode
-Content-Type: multipart/form-data
 
-Fields:
-- audio: Audio file (required)
-- title: Episode title (required)
-- description: Episode description (optional)
-- pubDate: Publication date (optional, defaults to now)
-```
+Edit `.env`:
 
-### Get RSS Feed
+```env
+PORT=5000
+NODE_ENV=development
+SESSION_SECRET=your-random-secret-for-local-dev
+PUBLIC_URL=http://localhost:5000
 ```
-GET /api/feed/rss
 
-Returns: RSS 2.0 XML feed with podcast episodes
-```
+### 4. Run the Application
 
-### Update Feed Metadata
+**Development Mode** (runs both frontend and backend):
+```bash
+npm run dev:all
 ```
-POST /api/feed/metadata
-Content-Type: application/json
 
-{
-  "title": "Your Podcast Name",
-  "description": "Podcast description",
-  "link": "https://yoursite.com",
-  "language": "en"
-}
-```
+This starts:
+- **Backend API** on `http://localhost:5000`
+- **React frontend** on `http://localhost:3000` (proxies API requests to backend)
 
-### Get Feed Metadata
-```
-GET /api/feed/metadata
+**Or run separately:**
+```bash
+# Terminal 1 - Backend only
+npm run dev
 
-Returns: Current feed metadata
+# Terminal 2 - Frontend only
+npm run client
 ```
 
-### Stream Media
+**Production Mode:**
+```bash
+npm run build  # Build React frontend
+npm start      # Start production server
 ```
-GET /api/media/stream/:did/:cid
 
-Parameters:
-- did: Decentralized identifier
-- cid: Content identifier (from AT Protocol blob)
-```
+The server serves both the React app and API on the same port.
 
-### Get All Episodes
-```
-GET /api/media/episodes
+## 🎯 How It Works
 
-Returns: List of all episodes with streaming URLs
-```
+1. **User logs in** with their Bluesky handle via OAuth
+2. **Upload episodes** - Files are stored as blobs in the user's PDS
+3. **Episodes stored as records** - Metadata saved in `app.podcast.episode` collection
+4. **RSS feed generated** - Standard RSS 2.0 with AT Protocol extensions
+5. **Anyone can access** - Public RSS feeds available via DID
 
-### Get Episode by ID
-```
-GET /api/media/episodes/:id
+## 📡 Key API Endpoints
+
+### Authentication
+- `GET /api/auth/login?handle=user.bsky.social` - Start OAuth login
+- `GET /api/auth/callback` - OAuth callback (automatic)
+- `GET /api/auth/session` - Check current session
+- `POST /api/auth/logout` - Log out
+
+### Episodes
+- `POST /api/upload/episode` - Upload new episode (multipart/form-data)
+- `GET /api/media/episodes` - List all episodes
+- `GET /api/media/episodes/:id` - Get specific episode
+- `PUT /api/media/episodes/:id` - Update episode metadata
+- `DELETE /api/media/episodes/:id` - Delete episode
+- `GET /api/media/stream/:did/:cid` - Stream episode audio
+
+### RSS Feed
+- `GET /api/feed/rss` - Get RSS feed (authenticated)
+- `POST /api/feed/publish` - Publish feed to AT Protocol
+- `GET /api/feed/at-rss` - Get published AT Protocol feed
+- `GET /api/feed/at-rss/:did` - Get any user's feed by DID (public)
+- `GET /api/feed/uri` - Get AT URI for published feed
 
-Returns: Single episode details
-```
+### Feed Settings
+- `GET /api/feed/metadata` - Get podcast metadata
+- `POST /api/feed/metadata` - Update podcast metadata
+
+## 💡 Usage Tips
 
-## Usage Example
+### For Podcast Creators
 
-### Upload an Episode
+1. **Log in** with your Bluesky handle at the deployed URL
+2. **Set podcast metadata** in Settings (title, description, etc.)
+3. **Upload episodes** - supports MP3, WAV, and other audio formats
+4. **Publish RSS feed** to AT Protocol for decentralized hosting
+5. **Share your feed** - Give listeners your AT URI or HTTP feed URL
 
-```bash
-curl -X POST http://localhost:3000/api/upload/episode \
-  -F "audio=@/path/to/episode.mp3" \
-  -F "title=My First Episode" \
-  -F "description=This is my first podcast episode!"
-```
+### For Podcast Listeners
 
-### Get RSS Feed
+- **HTTP Feed URL:** `https://your-app.com/api/feed/at-rss/did:plc:creator-did`
+- **AT Protocol URI:** `at://did:plc:creator-did/app.podcast.feed/self`
+- Compatible with any podcast player that supports RSS feeds
 
-```bash
-curl http://localhost:3000/api/feed/rss
-```
+### Accessing Other Users' Feeds
 
-### Stream an Episode
+Anyone can access a published podcast feed without authentication:
 
 ```bash
-curl http://localhost:3000/api/media/stream/{did}/{cid} --output episode.mp3
+# Get feed by DID
+curl https://your-app.com/api/feed/at-rss/did:plc:user-did
+
+# Stream episode
+curl https://your-app.com/api/media/stream/did:plc:user-did/episode-cid
 ```
 
 ## Project Structure
···
 └── README.md
 ```
 
-## How It Works
+## 🏗️ Technical Architecture
 
-1. **Upload**: Audio files are uploaded via multipart form data
-2. **Store**: Files are uploaded to AT Protocol as blobs, receiving a CID (Content Identifier)
-3. **Metadata**: Episode metadata (title, description, CID) is stored locally
-4. **RSS**: RSS feed is dynamically generated from stored metadata
-5. **Stream**: Episodes are streamed directly from AT Protocol blob storage using `at://` URIs
+### AT Protocol Integration
 
-## AT Protocol Integration
+**Data Storage:**
+- `app.podcast.episode` - Episode records with audio blob references
+- `app.podcast.settings` - Podcast metadata (title, description, etc.)
+- `app.podcast.feed` - Published RSS feed XML
 
-This project uses AT Protocol's blob storage to host podcast files:
+**Blob Storage:**
+- Audio files stored as blobs in user's Personal Data Server (PDS)
+- Files >5MB automatically chunked for PDS blob limits
+- Each blob receives a unique CID (Content Identifier)
+- Accessible via `at://` URIs or HTTP streaming endpoint
 
-- Audio files are stored as blobs in your AT Protocol repository
-- Each blob gets a unique CID (Content Identifier)
-- Files are accessible via `at://{did}/{cid}` URIs
-- The server acts as a bridge between HTTP and AT Protocol
+**Authentication:**
+- OAuth 2.0 flow with user's AT Protocol PDS
+- No centralized credentials - each user authenticates independently
+- Session management with file-based store (upgrade to Redis for production scale)
 
-## Development
+## 🔧 Technology Stack
 
-The project uses ES modules and includes:
+**Backend:**
+- Express.js - Web server
+- @atproto/oauth-client-node - OAuth authentication
+- @atcute/client - AT Protocol XRPC operations
+- @atproto/api - Public AT Protocol API access
+- Multer - File upload handling
+- RSS - Feed generation
 
-- Express.js for the web server
-- React + Vite for the frontend
-- @atproto/api for AT Protocol integration
-- Multer for file uploads
-- RSS package for feed generation
+**Frontend:**
+- React 18 - UI framework
+- Vite - Build tool and dev server
+- React Router - Client-side routing
+- Modern CSS with dark/light mode support
+
+## 🌟 Why AT Protocol for Podcasting?
+
+- **Decentralized Ownership** - Your podcast data lives on your PDS, not a platform
+- **Portable** - Move your podcast to any AT Protocol host
+- **Censorship Resistant** - No central authority can remove your content
+- **Built-in Identity** - Your Bluesky handle is your podcast identity
+- **Composable** - Other apps can build on your podcast data
+- **No Storage Limits** - Limited only by your PDS provider
 
-## Deployment
+## 📚 Additional Resources
 
-### Quick Deploy to Railway
+- [AT Protocol Documentation](https://atproto.com/)
+- [Bluesky Developer Portal](https://docs.bsky.app/)
+- [OAuth Client Documentation](https://github.com/bluesky-social/atproto/tree/main/packages/oauth)
 
-1. Push your code to GitHub
-2. Connect to Railway: https://railway.app
-3. Set environment variables (see [DEPLOYMENT.md](DEPLOYMENT.md))
-4. Railway will automatically build and deploy
+## 🤝 Contributing
 
-**One Command Production Build:**
-```bash
-npm run build  # Builds React app
-npm start      # Serves production app on port 5000
-```
+Contributions welcome! Please feel free to submit a Pull Request.
 
-### Deployment Platforms
+1. Fork the repository
+2. Create your feature 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
 
-This app works on:
-- ✅ Railway (recommended)
-- ✅ Render
-- ✅ Heroku
-- ✅ DigitalOcean App Platform
-- ✅ Any Node.js hosting
+## 🐛 Troubleshooting
 
-See [DEPLOYMENT.md](DEPLOYMENT.md) for detailed instructions.
+**OAuth callback fails:**
+- Ensure `PUBLIC_URL` matches your actual deployment URL
+- Check that your app is accessible at that URL
+- Verify session storage is working (check `sessions/` directory)
 
-## RSS Feed on AT Protocol
+**Upload fails:**
+- Check file size (max 500MB, chunks at 5MB)
+- Verify your PDS has available storage
+- Check console logs for specific error messages
 
-Your podcast RSS feed can be published as a decentralized AT Protocol record:
+**RSS feed not found:**
+- Publish the feed first using "Publish Feed" button in Settings
+- Check that episodes exist before publishing
 
-- Get an `at://` URI for your feed
-- Access it from any AT Protocol node
-- Maintain full ownership and portability
+## 📄 License
 
-See [RSS_AT_PROTOCOL.md](RSS_AT_PROTOCOL.md) for details.
+MIT License - see LICENSE file for details
 
-## License
+## ⭐ Show Your Support
 
-MIT
+If you find this project useful, please consider:
+- Giving it a star on GitHub
+- Sharing it with other podcast creators
+- Contributing improvements
+- Reporting bugs or suggesting features
 
-## Contributing
+---
 
-Contributions welcome! Please feel free to submit a Pull Request.
+Built with ❤️ for the AT Protocol ecosystem

WARP.md

···
 
 ## Project Overview
 
-AT Protocol Podcast Host is a podcast hosting platform that stores media files and RSS feeds using AT Protocol blob storage. Audio files are uploaded as blobs to AT Protocol, generating unique CIDs (Content Identifiers) accessible via `at://` URIs. The server acts as a bridge between HTTP clients and AT Protocol storage.
+**ATCast** is a podcast hosting platform that stores media files and RSS feeds using AT Protocol blob storage. It features:
+- OAuth-based per-user authentication (no hardcoded credentials)
+- React frontend with Vite
+- Episode management stored as AT Protocol records
+- Chunked blob uploads for large files (>5MB)
+- RSS feed generation and publishing to AT Protocol
+- Public RSS feed access via `at://` URIs
+
+Audio files are uploaded as blobs to each user's AT Protocol Personal Data Server (PDS), generating unique CIDs (Content Identifiers) accessible via `at://` URIs. The server acts as a bridge between HTTP clients and AT Protocol storage.
 
 ## Common Development Commands
 
 ### Running the Server
-- **Development mode** (with auto-reload): `npm run dev`
-- **Production mode**: `npm start`
-- Server runs on `http://localhost:3000` by default
+- **Development mode (backend only)**: `npm run dev` (runs on port 5000)
+- **Development mode (frontend only)**: `npm run client` (runs on port 3000 with proxy)
+- **Development mode (both)**: `npm run dev:all` (runs both concurrently)
+- **Production mode**: `npm run build && npm start`
+- Backend API runs on `http://localhost:5000` by default
+- React dev server runs on `http://localhost:3000` with proxy to backend
 
 ### Installation
-- Install dependencies: `npm install`
+- Install dependencies: `npm install` (also installs client dependencies via postinstall)
 - Copy environment template: `cp .env.example .env`
+- Configure `SESSION_SECRET` and `PUBLIC_URL` in `.env`
 
-### Testing API Endpoints
-- **Upload episode**: 
-  ```powershell
-  curl -X POST http://localhost:3000/api/upload/episode `
-    -F "audio=@/path/to/episode.mp3" `
-    -F "title=Episode Title" `
-    -F "description=Episode description"
-  ```
-- **Get RSS feed**: `curl http://localhost:3000/api/feed/rss`
-- **Stream episode**: `curl http://localhost:3000/api/media/stream/{did}/{cid} --output episode.mp3`
+### Building for Production
+- **Build React app**: `npm run build` (or `npm run client:build`)
+- **Railway build**: `npm run railway:build` (installs & builds)
+- **Railway start**: `npm run railway:start`
 
 ## Architecture
 
 ### Core Components
 
+**OAuth Authentication** (`src/oauth-client.js` & `src/routes/auth.js`):
+- Uses `@atproto/oauth-client-node` for per-user OAuth authentication
+- Users log in with their own Bluesky/AT Protocol credentials
+- Sessions stored in file-based session store (`sessions/` directory)
+- OAuth state and session management with in-memory stores (use Redis in production)
+- Middleware `requireAuth` protects authenticated routes
+- Key endpoints: `/api/auth/login`, `/api/auth/callback`, `/api/auth/session`, `/api/auth/logout`
+
 **AT Protocol Integration** (`src/atproto-client.js`):
-- Uses `@atproto/api` BskyAgent for authentication and blob operations
-- Manages session state with `isAuthenticated` flag
-- Key methods: `getAgent()`, `uploadBlob()`, `getBlob()`
-- Authenticates once per server lifecycle using credentials from `.env`
+- Simple unauthenticated client for public blob fetching via XRPC
+- Uses `@atcute/client` for authenticated operations (via OAuth session's fetchHandler)
+- Uses `@atproto/api` Agent for public API access
+- Key method: `getBlob(did, cid)` for streaming media
 
 **Storage Layer** (`src/storage/metadata.js`):
-- File-based metadata storage in `podcast-metadata.json` at project root
-- Stores episode metadata (title, description, CID, pubDate) and feed configuration
-- Episodes sorted by pubDate in descending order
-- No database required; metadata persists locally
+- **Primary storage**: AT Protocol records in user's PDS
+  - `app.podcast.episode` collection: Episode metadata + audio blob references
+  - `app.podcast.settings` collection: Feed metadata (title, description, etc.)
+  - `app.podcast.feed` collection: Published RSS feed XML
+- **Local fallback**: `podcast-metadata.json` for legacy compatibility
+- All episode data now stored as AT Protocol records, accessible via `at://` URIs
 
 **Route Structure** (`src/routes/`):
-- **upload.js**: Handles multipart file uploads via Multer, uploads blobs to AT Protocol, stores metadata, cleans up temp files
-- **feed.js**: Generates RSS 2.0 XML feeds dynamically from stored metadata, includes custom `atproto:cid` elements
-- **media.js**: Streams blobs from AT Protocol using DID/CID pairs, provides episode listing endpoints
+- **auth.js**: OAuth login flow, session management, user authentication middleware
+- **upload.js**: Multipart file uploads via Multer, chunked blob uploads (>5MB), creates AT Protocol episode records
+- **feed.js**: RSS generation from AT Protocol records, feed publishing, public feed access by DID
+- **media.js**: Streams blobs (single or chunked), episode CRUD operations via AT Protocol
+
+**React Frontend** (`client/`):
+- Vite + React application with modern component architecture
+- Key pages: Login, Dashboard, Episodes, Settings, Podcast Player
+- Theme system with dark/light mode (ThemeContext)
+- Components: Header, Sidebar, Upload/Edit modals, Episode cards
+- API service layer for backend communication
 
 ### Key Architectural Patterns
 
-1. **Blob Storage Flow**: Client uploads → Multer temp storage → AT Protocol blob upload → CID generation → Local metadata storage → Temp file cleanup
-2. **Streaming Flow**: Client requests DID/CID → Server fetches from AT Protocol XRPC endpoint → Proxies binary data to client
-3. **Authentication**: Single agent instance shared across all modules, lazy authentication on first API call
-4. **URL Construction**: RSS feed and API responses construct full URLs using `req.protocol` and `req.get('host')` for proper streaming links
+1. **OAuth Flow**: User enters handle → Server resolves handle to DID/PDS → Redirect to user's PDS for auth → Callback with tokens → Session stored
+2. **Blob Storage Flow**: Client uploads → Multer temp storage → Chunked if >5MB → Upload to user's PDS → Create episode record → CID generation → Temp file cleanup
+3. **Streaming Flow**: Client requests DID/CID → Server resolves PDS → Fetches blob(s) from PDS → Streams to client (reassembling chunks if needed)
+4. **Authentication**: Per-request authentication via OAuth session's fetchHandler, authenticated operations use user's own credentials
+5. **Record Storage**: Episodes, settings, and feeds stored as AT Protocol records in user's repository
+6. **URL Construction**: RSS feeds and API responses use `req.protocol` and `req.get('host')` for proper URL generation
 
 ## Environment Configuration
 
 Required environment variables in `.env`:
-- `PORT`: Server port (default: 3000)
-- `ATPROTO_SERVICE`: AT Protocol service URL (usually `https://bsky.social`)
-- `ATPROTO_IDENTIFIER`: Your Bluesky/AT Protocol handle
-- `ATPROTO_PASSWORD`: App password (NOT main account password) from Bluesky settings
+- `PORT`: Server port (default: 5000)
+- `NODE_ENV`: Environment (`development` or `production`)
+- `SESSION_SECRET`: Secret key for session encryption (change in production!)
+- `PUBLIC_URL`: Public URL for OAuth callbacks (e.g., `http://localhost:5000` or `https://yourdomain.com`)
 
-The server requires valid AT Protocol credentials to start. Obtain an app password from Bluesky account settings for secure authentication.
+**Note**: No hardcoded AT Protocol credentials needed! Users authenticate with their own Bluesky/AT Protocol accounts via OAuth.
 
 ## Project Structure
 
 ```
-src/
-├── index.js              # Express server initialization, route registration
-├── atproto-client.js     # AT Protocol authentication and blob operations
-├── routes/
-│   ├── upload.js         # Episode upload endpoint
-│   ├── feed.js           # RSS feed generation and metadata management
-│   └── media.js          # Blob streaming and episode retrieval
-└── storage/
-    └── metadata.js       # JSON-based metadata persistence
+atproto-podcast-host/
+├── client/                   # React Frontend (Vite)
+│   ├── src/
+│   │   ├── components/       # React components (Header, Sidebar, modals, etc.)
+│   │   ├── pages/            # Page components (Dashboard, Episodes, Settings, etc.)
+│   │   ├── contexts/         # React contexts (ThemeContext)
+│   │   ├── App.jsx           # Main App component with routing
+│   │   └── main.jsx          # Entry point
+│   ├── public/               # Static assets
+│   ├── package.json
+│   └── vite.config.js        # Vite configuration with proxy
+├── src/                      # Backend API (Express)
+│   ├── index.js              # Express server, session config, route registration
+│   ├── oauth-client.js       # OAuth client setup, session management
+│   ├── atproto-client.js     # Unauthenticated AT Protocol client for public blob access
+│   ├── routes/
+│   │   ├── auth.js           # OAuth authentication endpoints
+│   │   ├── upload.js         # Episode upload with chunking support
+│   │   ├── feed.js           # RSS generation and publishing
+│   │   └── media.js          # Media streaming and episode CRUD
+│   └── storage/
+│       └── metadata.js       # Local metadata storage (fallback)
+├── sessions/                 # File-based session store
+├── public/                   # Legacy static files (deprecated)
+├── .env.example              # Environment template
+├── package.json              # Root package.json with build scripts
+├── WARP.md                   # This file
+└── README.md                 # User documentation
 ```
 
 ## Important Notes
···
 - No test framework is currently configured
 - No linter or type checker configured
 - Temporary uploads go to `public/uploads/` (cleaned up after blob upload)
-- Metadata file `podcast-metadata.json` is created automatically if missing
+- Sessions stored in `sessions/` directory (file-based, consider Redis for production)
 - AT Protocol blobs are immutable; reuploading creates new CIDs
-- DID (Decentralized Identifier) comes from authenticated agent session
+- Each user's data (episodes, settings, feeds) stored in their own PDS
+- Large files (>5MB) are automatically chunked into smaller blobs
+- DID (Decentralized Identifier) comes from OAuth session
+- Frontend built with React + Vite, served from `client/dist` in production
+- CORS configured for production (`PUBLIC_URL`) and development (`http://localhost:3000`)
+- Session cookies use `secure: true` in production, require HTTPS
+
+## Key Dependencies
+
+**Backend**:
+- `@atproto/api`: AT Protocol SDK for Agent-based operations
+- `@atproto/oauth-client-node`: OAuth client for user authentication
+- `@atcute/client`: Lightweight AT Protocol client for XRPC operations
+- `express`: Web server framework
+- `express-session`: Session management
+- `session-file-store`: File-based session storage
+- `multer`: Multipart file upload handling
+- `rss`: RSS feed generation
+- `cors`: Cross-origin resource sharing
+
+**Frontend**:
+- `react`: UI framework
+- `react-router-dom`: Client-side routing
+- `vite`: Build tool and dev server