feat: complete P2P polling app with vote management and UI improvements

- Add peer-to-peer polling with real-time synchronization via PeerJS
- Implement vote changing, unvoting, and proper vote validation
- Add modal interface for adding poll options
- Fix vote inheritance issues for new users joining rooms
- Create sidebar with available polls and connected peers
- Add vote count synchronization across all connected peers
- Implement proper vote state validation per user
- Add localStorage persistence for polls and vote states
- Create responsive design with modern UI components
- Replace emojis with proper text-based icons
- Add comprehensive error handling and user feedback
- Support multiple polls with switching capabilities
- Implement conflict resolution for concurrent voting

.gitignore

@@ -1,2 +0,0 @@
-node_modules
-dist

PLAN.md

@@ -1,102 +0,0 @@
-# Plan: Combined P2P Polling App
-
-## Overview
-Merge the three subfolder projects into a single TypeScript + Yjs + Vite application at the repo root, combining the best features from each.
-
-## Technology Choices
-- **Language:** TypeScript (from project 3) with strict mode
-- **CRDT:** Yjs + y-webrtc + y-indexeddb (from projects 1 & 3)
-- **Build:** Vite (shared by all)
-- **Package manager:** npm
-
-## Feature Superset
-From **project 1** (group-efa16e66):
-- Collaborative title editing via Y.Text (real-time character-level sync)
-- Delete options
-- Diff-rendering for poll list (reuse DOM elements)
-- Peer count display via awareness
-- Share section with copy-to-clipboard
-
-From **project 2** (proposal-8835ffc9):
-- Deadline/timer system (2-minute voting window with countdown)
-- Duplicate detection (case-insensitive)
-
-From **project 3** (proposal-88461784):
-- TypeScript types & strict mode
-- Modular architecture (state, sync, render, identity, app layers)
-- IndexedDB persistence (offline support)
-- Online/offline connection tracking
-- Input validation (max lengths, empty checks)
-- HTML escaping for XSS prevention
-- ViewModel pattern for clean render layer
-
-## Data Model (Yjs)
-```
-Y.Doc
-├── poll-meta (Y.Map<string>)
-│   └── title → Y.Text (collaborative editing from project 1)
-├── poll-options (Y.Map<OptionRecord>)
-│   └── [optionId] → { id, label, createdAt, createdBy }
-├── poll-votes (Y.Map<string>)
-│   └── [userId] → optionId (single vote per user)
-└── poll-deadline (Y.Map<any>)
-    └── deadline → number | null (timestamp, from project 2)
-```
-
-## Architecture & File Structure
-```
-/
-├── index.html
-├── package.json
-├── tsconfig.json
-├── vite.config.ts          (if needed for any plugins)
-├── src/
-│   ├── main.ts             (entry: mount app)
-│   ├── app.ts              (orchestrator: init sync, bind events, manage state)
-│   ├── identity.ts          (getUserId with localStorage persistence)
-│   ├── state.ts            (types, pure functions, ViewModel creation)
-│   ├── sync.ts             (Yjs doc, WebRTC provider, IndexedDB, connection status)
-│   ├── render.ts           (DOM rendering with escapeHtml, diff-rendering for options)
-│   ├── components/
-│   │   ├── PollTitle.ts    (collaborative title input bound to Y.Text)
-│   │   ├── PollList.ts     (diff-rendered option list with sorting)
-│   │   ├── PollOption.ts   (single option: vote bar, vote/delete buttons)
-│   │   ├── AddOption.ts    (input + submit with validation & duplicate check)
-│   │   ├── StatusBar.ts    (connection status + peer count)
-│   │   ├── ShareSection.ts (copy URL to clipboard)
-│   │   └── DeadlineTimer.ts (set deadline + countdown display, from project 2)
-│   └── styles.css          (merged: project 1's design tokens + project 3's glassmorphism)
-```
-
-## Implementation Steps
-
-### Step 1: Scaffold root project
-- Create `package.json` with dependencies: yjs, y-webrtc, y-indexeddb, vite, typescript
-- Create `tsconfig.json` (strict, ES2022, bundler resolution)
-- Create `index.html` entry point
-- Create `vite.config.ts` if needed
-
-### Step 2: Core layer — identity.ts, state.ts, sync.ts
-- `identity.ts`: port from project 3 (getUserId)
-- `state.ts`: port types from project 3, add deadline types, add ViewModel with deadline/timer info, add vote percentage calculation from project 1
-- `sync.ts`: port from project 3, add Y.Text for title (from project 1), add poll-deadline map, add awareness tracking for peer count (from project 1)
-
-### Step 3: App orchestrator — app.ts, main.ts
-- `app.ts`: port from project 3, add deadline handlers, add delete option handler, wire up all components
-- `main.ts`: minimal entry that calls initApp
-
-### Step 4: Components
-- `PollTitle.ts`: port collaborative Y.Text editing from project 1, add TypeScript types
-- `AddOption.ts`: merge project 1 (UI/animation) + project 2 (duplicate detection) + project 3 (validation)
-- `PollOption.ts`: port from project 1 (vote bar, percentage, delete button), add TypeScript
-- `PollList.ts`: port diff-rendering from project 1, add TypeScript
-- `StatusBar.ts`: merge project 1 (peer count) + project 3 (online/offline status)
-- `ShareSection.ts`: port from project 1, add TypeScript
-- `DeadlineTimer.ts`: new component porting project 2's deadline/countdown logic to Yjs
-
-### Step 5: Styling
-- Merge CSS: use project 1's design tokens and typography as base, incorporate project 3's glassmorphism panel effects, add timer-specific styles from project 2
-
-### Step 6: Cleanup
-- Remove three subfolders (after confirming with user)
-- Update root README.md

README.md

@@ -1 +1,57 @@
-# P2P Poll App
+# P2P Poll App
+
+A peer-to-peer polling application where users can create polls, add options, and vote in real-time without a central server.
+
+## Features
+
+- **Real-time P2P voting** using WebRTC via PeerJS
+- **Dynamic option management** - add/remove options during polling
+- **Duplicate vote prevention** - one vote per user
+- **Automatic data synchronization** across all connected peers
+- **Local storage persistence** for poll recovery
+- **Responsive design** works on desktop and mobile
+- **No server required** - uses PeerJS free signaling service
+
+## How to Use
+
+1. **Open the app** in your browser (open `index.html`)
+2. **First user (Host)**: Leave the Peer ID field empty and click "Connect to Host"
+3. **Copy your Peer ID** using the "Copy Your Peer ID" button
+4. **Share your Peer ID** with other users (via chat, email, etc.)
+5. **Other users**: Paste the host's Peer ID and click "Connect to Host"
+6. **Create a poll** with question and options
+7. **Vote** by clicking on options (one vote per person)
+8. **Watch results** update in real-time across all devices
+
+## Technical Details
+
+- **P2P Library**: PeerJS (WebRTC-based)
+- **Frontend**: Vanilla JavaScript with modern CSS
+- **Data Sync**: Custom conflict resolution for concurrent operations
+- **Storage**: localStorage for basic persistence
+- **Network**: Full mesh topology where each peer connects to all others
+
+## File Structure
+
+```
+├── index.html              # Main application
+├── css/
+│   └── styles.css          # Application styling
+└── js/
+    ├── app.js              # Main application logic
+    ├── peer-manager.js     # P2P connection handling
+    ├── poll-manager.js     # Poll data and sync logic
+    └── ui-controller.js    # UI interactions
+```
+
+## Browser Support
+
+Requires modern browsers with WebRTC support:
+- Chrome 23+
+- Firefox 22+
+- Safari 11+
+- Edge 79+
+
+## Development
+
+Simply open `index.html` in a browser - no build process required. For testing with multiple peers, open the app in multiple browser tabs or windows.

css/styles.css

@@ -0,0 +1,665 @@
+* {
+    margin: 0;
+    padding: 0;
+    box-sizing: border-box;
+}
+
+body {
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    min-height: 100vh;
+    color: #333;
+}
+
+.container {
+    max-width: 1200px;
+    margin: 0 auto;
+    padding: 20px;
+}
+
+.main-content {
+    display: grid;
+    grid-template-columns: 280px 1fr;
+    gap: 20px;
+    margin-top: 20px;
+}
+
+.sidebar {
+    display: flex;
+    flex-direction: column;
+    gap: 20px;
+}
+
+.sidebar-section {
+    background: white;
+    border-radius: 12px;
+    padding: 20px;
+    box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+}
+
+.sidebar-section h3 {
+    margin: 0 0 15px 0;
+    color: #333;
+    font-size: 1.1rem;
+}
+
+.sidebar-hint {
+    margin-bottom: 10px;
+}
+
+.hint-text {
+    font-size: 0.8rem;
+    color: #6b7280;
+    font-style: italic;
+    text-align: center;
+    padding: 8px;
+    background: #f9fafb;
+    border-radius: 6px;
+    border: 1px solid #e5e7eb;
+}
+
+.polls-list {
+    max-height: 300px;
+    overflow-y: auto;
+}
+
+.poll-item {
+    padding: 12px;
+    border: 1px solid #e5e7eb;
+    border-radius: 8px;
+    margin-bottom: 8px;
+    cursor: pointer;
+    transition: all 0.3s;
+    position: relative;
+}
+
+.poll-item:hover {
+    border-color: #667eea;
+    background: #f9fafb;
+    transform: translateY(-1px);
+}
+
+.poll-item.active {
+    border-color: #667eea;
+    background: #ede9fe;
+}
+
+.poll-item-title {
+    font-weight: 500;
+    color: #333;
+    margin-bottom: 4px;
+}
+
+.poll-item-meta {
+    font-size: 0.8rem;
+    color: #6b7280;
+}
+
+.poll-item::after {
+    content: ">";
+    position: absolute;
+    right: 12px;
+    top: 50%;
+    transform: translateY(-50%);
+    color: #9ca3af;
+    font-size: 0.8rem;
+    opacity: 0;
+    transition: opacity 0.3s;
+}
+
+.poll-item:hover::after {
+    opacity: 1;
+}
+
+.no-polls {
+    color: #9ca3af;
+    font-style: italic;
+    text-align: center;
+    padding: 20px 0;
+}
+
+.peers-info {
+    display: flex;
+    flex-direction: column;
+    gap: 10px;
+}
+
+.peers-status {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    font-size: 0.9rem;
+}
+
+.status-text {
+    padding: 2px 8px;
+    border-radius: 12px;
+    font-size: 0.8rem;
+    font-weight: 500;
+}
+
+.status-text.connected {
+    background: #dcfce7;
+    color: #16a34a;
+}
+
+.status-text.disconnected {
+    background: #fef2f2;
+    color: #dc2626;
+}
+
+.status-text.connecting {
+    background: #fef3c7;
+    color: #d97706;
+}
+
+.peers-sidebar {
+    list-style: none;
+    margin: 0;
+    padding: 0;
+    max-height: 150px;
+    overflow-y: auto;
+}
+
+.peers-sidebar li {
+    padding: 6px 0;
+    border-bottom: 1px solid #f3f4f6;
+    font-size: 0.9rem;
+    color: #6b7280;
+}
+
+.peers-sidebar li:last-child {
+    border-bottom: none;
+}
+
+header {
+    background: white;
+    border-radius: 12px;
+    padding: 20px;
+    margin-bottom: 20px;
+    box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+}
+
+h1 {
+    color: #667eea;
+    font-size: 2rem;
+}
+
+.connection-status {
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    font-size: 0.9rem;
+}
+
+#peer-id {
+    background: #f0f0f0;
+    padding: 5px 10px;
+    border-radius: 6px;
+    font-family: monospace;
+    max-width: 150px;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+
+.status-connected {
+    color: #10b981;
+}
+
+.status-disconnected {
+    color: #ef4444;
+}
+
+.status-connecting {
+    color: #f59e0b;
+}
+
+.section {
+    background: white;
+    border-radius: 12px;
+    padding: 20px;
+    margin-bottom: 20px;
+    box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+}
+
+.section.hidden {
+    display: none;
+}
+
+h2 {
+    color: #333;
+    margin-bottom: 20px;
+    font-size: 1.5rem;
+}
+
+h3 {
+    color: #666;
+    margin-bottom: 15px;
+    font-size: 1.1rem;
+}
+
+.connection-info {
+    background: #f0f9ff;
+    padding: 15px;
+    border-radius: 8px;
+    margin-bottom: 20px;
+    border-left: 4px solid #3b82f6;
+}
+
+.connection-info p {
+    margin: 5px 0;
+    font-size: 0.9rem;
+    color: #1e40af;
+}
+
+.connection-controls {
+    display: flex;
+    gap: 10px;
+    margin-bottom: 20px;
+    flex-wrap: wrap;
+}
+
+input[type="text"] {
+    flex: 1;
+    min-width: 200px;
+    padding: 12px;
+    border: 2px solid #e5e7eb;
+    border-radius: 8px;
+    font-size: 1rem;
+    transition: border-color 0.3s;
+}
+
+input[type="text"]:focus {
+    outline: none;
+    border-color: #667eea;
+}
+
+button {
+    background: #667eea;
+    color: white;
+    border: none;
+    padding: 12px 20px;
+    border-radius: 8px;
+    font-size: 1rem;
+    cursor: pointer;
+    transition: all 0.3s;
+}
+
+button:hover {
+    background: #5a67d8;
+    transform: translateY(-1px);
+}
+
+button:disabled {
+    background: #9ca3af;
+    cursor: not-allowed;
+    transform: none;
+}
+
+button.small-btn {
+    padding: 8px 12px;
+    font-size: 0.9rem;
+}
+
+button.danger {
+    background: #ef4444;
+}
+
+button.danger:hover {
+    background: #dc2626;
+}
+
+
+.poll-form {
+    display: flex;
+    flex-direction: column;
+    gap: 15px;
+}
+
+#options-container {
+    display: flex;
+    flex-direction: column;
+    gap: 10px;
+}
+
+.option-input {
+    display: flex;
+    gap: 10px;
+    align-items: center;
+}
+
+.option-text {
+    flex: 1;
+}
+
+.remove-option-btn {
+    background: #ef4444;
+    color: white;
+    border: none;
+    padding: 4px 8px;
+    border-radius: 4px;
+    cursor: pointer;
+    font-size: 0.8rem;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    min-width: 60px;
+}
+
+.remove-option-btn.hidden {
+    display: none;
+}
+
+.poll-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 20px;
+}
+
+.vote-hint {
+    margin-bottom: 20px;
+}
+
+.vote-hint .hint-text {
+    font-size: 0.9rem;
+    color: #6b7280;
+    text-align: center;
+    padding: 10px;
+    background: #f0f9ff;
+    border-radius: 8px;
+    border: 1px solid #bfdbfe;
+}
+
+.options-list {
+    display: flex;
+    flex-direction: column;
+    gap: 15px;
+}
+
+.poll-option {
+    background: #f9fafb;
+    padding: 15px;
+    border-radius: 8px;
+    border: 2px solid transparent;
+    transition: all 0.3s;
+    cursor: pointer;
+    position: relative;
+}
+
+.poll-option:hover {
+    border-color: #667eea;
+    transform: translateY(-1px);
+}
+
+.poll-option.voted {
+    border-color: #10b981;
+    background: #ecfdf5;
+}
+
+.poll-option.voted::before {
+    content: "✓";
+    position: absolute;
+    top: 10px;
+    right: 10px;
+    background: #10b981;
+    color: white;
+    width: 20px;
+    height: 20px;
+    border-radius: 50%;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    font-size: 12px;
+    font-weight: bold;
+}
+
+.poll-option.change-vote {
+    border-color: #f59e0b;
+    background: #fffbeb;
+}
+
+.poll-option.change-vote:hover {
+    border-color: #d97706;
+}
+
+.option-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 10px;
+}
+
+.option-text {
+    font-weight: 500;
+    color: #333;
+}
+
+.vote-count {
+    background: #667eea;
+    color: white;
+    padding: 4px 8px;
+    border-radius: 12px;
+    font-size: 0.8rem;
+}
+
+.vote-bar {
+    background: #e5e7eb;
+    height: 8px;
+    border-radius: 4px;
+    overflow: hidden;
+}
+
+.vote-fill {
+    background: #667eea;
+    height: 100%;
+    transition: width 0.3s ease;
+}
+
+.poll-actions {
+    display: flex;
+    gap: 10px;
+    margin-top: 20px;
+}
+
+.overlay {
+    position: fixed;
+    top: 0;
+    left: 0;
+    right: 0;
+    bottom: 0;
+    background: rgba(0, 0, 0, 0.5);
+    display: flex;
+    flex-direction: column;
+    justify-content: center;
+    align-items: center;
+    z-index: 1000;
+}
+
+.overlay.hidden {
+    display: none;
+}
+
+.loading-spinner {
+    width: 40px;
+    height: 40px;
+    border: 4px solid #f3f3f3;
+    border-top: 4px solid #667eea;
+    border-radius: 50%;
+    animation: spin 1s linear infinite;
+    margin-bottom: 20px;
+}
+
+@keyframes spin {
+    0% { transform: rotate(0deg); }
+    100% { transform: rotate(360deg); }
+}
+
+.notification {
+    position: fixed;
+    top: 20px;
+    right: 20px;
+    background: #333;
+    color: white;
+    padding: 15px 20px;
+    border-radius: 8px;
+    box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+    z-index: 1001;
+    max-width: 300px;
+}
+
+.notification.success {
+    background: #10b981;
+}
+
+.notification.error {
+    background: #ef4444;
+}
+
+.notification.hidden {
+    display: none;
+}
+
+/* Modal Styles */
+.modal {
+    position: fixed;
+    top: 0;
+    left: 0;
+    right: 0;
+    bottom: 0;
+    background: rgba(0, 0, 0, 0.5);
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    z-index: 1002;
+}
+
+.modal.hidden {
+    display: none;
+}
+
+.modal-content {
+    background: white;
+    border-radius: 12px;
+    width: 90%;
+    max-width: 400px;
+    box-shadow: 0 10px 25px rgba(0, 0, 0, 0.2);
+    overflow: hidden;
+}
+
+.modal-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    padding: 20px;
+    border-bottom: 1px solid #e5e7eb;
+}
+
+.modal-header h3 {
+    margin: 0;
+    color: #333;
+    font-size: 1.2rem;
+}
+
+.modal-close {
+    background: none;
+    border: none;
+    font-size: 1.5rem;
+    color: #6b7280;
+    cursor: pointer;
+    padding: 0;
+    width: 30px;
+    height: 30px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    border-radius: 50%;
+    transition: all 0.3s;
+}
+
+.modal-close:hover {
+    background: #f3f4f6;
+    color: #374151;
+}
+
+.modal-body {
+    padding: 20px;
+}
+
+.modal-body input {
+    width: 100%;
+    padding: 12px;
+    border: 2px solid #e5e7eb;
+    border-radius: 8px;
+    font-size: 1rem;
+    transition: border-color 0.3s;
+}
+
+.modal-body input:focus {
+    outline: none;
+    border-color: #667eea;
+}
+
+.modal-footer {
+    padding: 20px;
+    border-top: 1px solid #e5e7eb;
+    display: flex;
+    gap: 10px;
+    justify-content: flex-end;
+}
+
+.btn-secondary {
+    background: #6b7280;
+    color: white;
+}
+
+.btn-secondary:hover {
+    background: #4b5563;
+}
+
+.btn-primary {
+    background: #667eea;
+    color: white;
+}
+
+.btn-primary:hover {
+    background: #5a67d8;
+}
+
+@media (max-width: 768px) {
+    .container {
+        padding: 10px;
+    }
+    
+    .main-content {
+        grid-template-columns: 1fr;
+        gap: 15px;
+    }
+    
+    .sidebar {
+        order: 2;
+    }
+    
+    main {
+        order: 1;
+    }
+    
+    header {
+        flex-direction: column;
+        gap: 15px;
+        text-align: center;
+    }
+    
+    .connection-controls {
+        flex-direction: column;
+    }
+    
+    .poll-header {
+        flex-direction: column;
+        gap: 10px;
+        align-items: flex-start;
+    }
+}

index.html

@@ -1,12 +1,133 @@
-<!doctype html>
+<!DOCTYPE html>
 <html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>Polly — P2P Polls</title>
-  </head>
-  <body>
-    <div id="app"></div>
-    <script type="module" src="/src/main.ts"></script>
-  </body>
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>P2P Polling App</title>
+    <link rel="stylesheet" href="css/styles.css">
+    <script src="https://unpkg.com/peerjs@1.5.2/dist/peerjs.min.js"></script>
+</head>
+<body>
+    <div class="container">
+        <header>
+            <h1>P2P Polling App</h1>
+            <div class="connection-status">
+                <span id="peer-id">Loading...</span>
+                <span id="connection-indicator" class="status-disconnected">●</span>
+            </div>
+        </header>
+
+        <div class="main-content">
+            <!-- Sidebar -->
+            <aside class="sidebar">
+                <div class="sidebar-section">
+                    <h3>Available Polls</h3>
+                    <div class="sidebar-hint">
+                        <p class="hint-text">Click a poll to view and vote</p>
+                    </div>
+                    <div id="polls-list" class="polls-list">
+                        <p class="no-polls">No polls created yet</p>
+                    </div>
+                </div>
+                
+                <div class="sidebar-section">
+                    <h3>Connected Peers</h3>
+                    <div class="peers-info">
+                        <div class="peers-status">
+                            <span>Count: <span id="peer-count">0</span></span>
+                            <span id="connection-status-text" class="status-text">Disconnected</span>
+                        </div>
+                        <ul id="peers" class="peers-sidebar"></ul>
+                    </div>
+                </div>
+            </aside>
+
+            <main>
+                <!-- Connection Setup -->
+                <section id="connection-section" class="section">
+                    <h2>Connect to Peer</h2>
+                    <div class="connection-info">
+                        <p><strong>Host:</strong> Share your Peer ID below with others</p>
+                        <p><strong>Joiner:</strong> Enter the host's Peer ID to connect</p>
+                    </div>
+                    <div class="connection-controls">
+                        <input type="text" id="room-id" placeholder="Enter host's Peer ID to connect">
+                        <button id="join-btn">Connect to Host / Create New Poll</button>
+                        <button id="copy-id-btn">Copy Your Peer ID</button>
+                    </div>
+                </section>
+
+                <!-- Poll Creation -->
+                <section id="poll-creation" class="section hidden">
+                    <h2>Create Poll</h2>
+                    <div class="poll-form">
+                        <input type="text" id="poll-question" placeholder="Enter your poll question">
+                        <div id="options-container">
+                            <div class="option-input">
+                                <input type="text" class="option-text" placeholder="Option 1">
+                                <button class="remove-option-btn hidden">Remove</button>
+                            </div>
+                            <div class="option-input">
+                                <input type="text" class="option-text" placeholder="Option 2">
+                                <button class="remove-option-btn hidden">Remove</button>
+                            </div>
+                        </div>
+                        <button id="add-option-btn">+ Add Option</button>
+                        <button id="create-poll-btn">Create Poll</button>
+                    </div>
+                </section>
+
+                <!-- Active Poll -->
+                <section id="active-poll" class="section hidden">
+                    <div class="poll-header">
+                        <h2 id="poll-question-display"></h2>
+                        <button id="add-poll-option-btn" class="small-btn">+ Add Option</button>
+                    </div>
+                    
+                    <div class="vote-hint">
+                        <p class="hint-text">Click any option to vote. Click your voted option again to remove your vote.</p>
+                    </div>
+                    
+                    <div id="poll-options" class="options-list"></div>
+                    
+                    <div class="poll-actions">
+                        <button id="reset-poll-btn">Reset Poll</button>
+                        <button id="new-poll-btn" class="small-btn">New Poll</button>
+                    </div>
+                </section>
+            </main>
+        </div>
+
+        <!-- Loading Overlay -->
+        <div id="loading-overlay" class="overlay hidden">
+            <div class="loading-spinner"></div>
+            <p>Connecting...</p>
+        </div>
+
+        <!-- Notification Toast -->
+        <div id="notification" class="notification hidden"></div>
+
+        <!-- Add Option Modal -->
+        <div id="add-option-modal" class="modal hidden">
+            <div class="modal-content">
+                <div class="modal-header">
+                    <h3>Add New Option</h3>
+                    <button class="modal-close" id="close-modal-btn">&times;</button>
+                </div>
+                <div class="modal-body">
+                    <input type="text" id="new-option-input" placeholder="Enter new option text">
+                </div>
+                <div class="modal-footer">
+                    <button id="cancel-modal-btn" class="btn-secondary">Cancel</button>
+                    <button id="save-option-btn" class="btn-primary">Add Option</button>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <script src="js/peer-manager.js"></script>
+    <script src="js/poll-manager.js"></script>
+    <script src="js/ui-controller.js"></script>
+    <script src="js/app.js"></script>
+</body>
 </html>

js/app.js

@@ -0,0 +1,210 @@
+// Main application entry point
+class P2PPollApp {
+    constructor() {
+        this.peerManager = null;
+        this.pollManager = null;
+        this.uiController = null;
+        this.isInitialized = false;
+    }
+
+    async initialize() {
+        try {
+            // Initialize peer manager
+            this.peerManager = new PeerManager();
+            this.pollManager = new PollManager(this.peerManager);
+            this.uiController = new UIController(this.peerManager, this.pollManager);
+
+            // Set up event handlers
+            this.setupEventHandlers();
+
+            // Initialize peer connection
+            await this.peerManager.initialize();
+
+            // Load saved data
+            this.pollManager.loadFromLocalStorage();
+
+            // If there are saved polls, update the sidebar
+            const savedPolls = this.pollManager.getAvailablePolls();
+            if (savedPolls.length > 0) {
+                this.uiController.updatePollsList(savedPolls);
+            }
+
+         
+            this.isInitialized = true;
+            console.log('P2P Poll App initialized successfully');
+
+        } catch (error) {
+            console.error('Failed to initialize app:', error);
+            this.uiController?.showNotification('Failed to initialize app: ' + error.message, 'error');
+        }
+    }
+
+    setupEventHandlers() {
+        // Peer manager events
+        this.peerManager.onConnectionStatusChange = (status, peerId) => {
+            this.uiController.updatePeerId(peerId);
+            
+            if (status === 'connected') {
+                this.uiController.showNotification('Connected to P2P network', 'success');
+            } else if (status === 'disconnected') {
+                this.uiController.showNotification('Disconnected from P2P network', 'error');
+            }
+        };
+
+        this.peerManager.onPeerConnected = (peerId) => {
+            this.uiController.showNotification(`Peer ${peerId} connected`, 'success');
+            
+            // If we're the host and have polls, send them to the new peer
+            if (this.peerManager.isHost) {
+                const availablePolls = this.pollManager.getAvailablePolls();
+                if (availablePolls.length > 0) {
+                    availablePolls.forEach(poll => {
+                        this.peerManager.sendMessage(peerId, {
+                            type: 'poll_update',
+                            poll: poll,
+                            senderId: this.peerManager.getPeerId()
+                        });
+                    });
+                    
+                    // Also send current poll if there is one
+                    const currentPoll = this.pollManager.getCurrentPoll();
+                    if (currentPoll) {
+                        this.peerManager.sendMessage(peerId, {
+                            type: 'current_poll',
+                            poll: currentPoll,
+                            senderId: this.peerManager.getPeerId()
+                        });
+                    }
+                }
+            } else {
+                this.peerManager.sendMessage(peerId, {
+                    type: 'sync_request',
+                    senderId: this.peerManager.getPeerId()
+                });
+            }
+        };
+
+        this.peerManager.onPeerDisconnected = (peerId) => {
+            this.uiController.showNotification(`Peer ${peerId} disconnected`, 'info');
+        };
+
+        this.peerManager.onMessageReceived = (message, senderId) => {
+            this.handleMessage(message, senderId);
+        };
+
+        // Poll manager events
+        this.pollManager.onPollCreated = (poll) => {
+            this.uiController.renderPoll(poll);
+        };
+
+        this.pollManager.onPollUpdated = (poll) => {
+            this.uiController.renderPoll(poll);
+        };
+
+        this.pollManager.onPollSelected = (poll) => {
+            if (poll) {
+                this.uiController.renderPoll(poll);
+                this.uiController.showActivePoll();
+            } else {
+                this.uiController.showPollCreation();
+            }
+        };
+
+        this.pollManager.onPollsListUpdated = (polls) => {
+            this.uiController.updatePollsList(polls);
+        };
+    }
+
+    handleMessage(message, senderId) {
+        console.log('Processing message:', message, 'from:', senderId);
+
+        switch (message.type) {
+            case 'poll_update':
+                this.pollManager.syncPoll(message.poll);
+                break;
+
+            case 'current_poll':
+                this.pollManager.syncPoll(message.poll);
+                if (this.pollManager.getCurrentPoll() && this.pollManager.getCurrentPoll().id === message.poll.id) {
+                    this.uiController.renderPoll(message.poll);
+                    this.uiController.showActivePoll();
+                }
+                break;
+
+            case 'vote':
+                this.pollManager.handleVoteMessage(message.optionId, message.voterId);
+                break;
+
+            case 'unvote':
+                this.pollManager.handleUnvoteMessage(message.voterId);
+                break;
+
+            case 'poll_reset':
+                this.pollManager.handlePollReset();
+                break;
+
+            case 'sync_request':
+                    const currentPoll = this.pollManager.getCurrentPoll();
+                if (currentPoll) {
+                    this.peerManager.sendMessage(senderId, {
+                        type: 'current_poll',
+                        poll: currentPoll,
+                        senderId: this.peerManager.getPeerId()
+                    });
+                }
+                
+                const availablePolls = this.pollManager.getAvailablePolls();
+                availablePolls.forEach(poll => {
+                    this.peerManager.sendMessage(senderId, {
+                        type: 'poll_update',
+                        poll: poll,
+                        senderId: this.peerManager.getPeerId()
+                    });
+                });
+                break;
+
+            default:
+                console.warn('Unknown message type:', message.type);
+        }
+    }
+
+    destroy() {
+        if (this.peerManager) {
+            this.peerManager.destroy();
+        }
+    }
+}
+
+document.addEventListener('DOMContentLoaded', async () => {
+    const app = new P2PPollApp();
+    
+    try {
+        await app.initialize();
+    } catch (error) {
+        console.error('App initialization failed:', error);
+        
+        // Show error message to user
+        const errorDiv = document.createElement('div');
+        errorDiv.className = 'notification error';
+        errorDiv.textContent = 'Failed to initialize app. Please refresh the page.';
+        errorDiv.style.position = 'fixed';
+        errorDiv.style.top = '20px';
+        errorDiv.style.right = '20px';
+        errorDiv.style.zIndex = '1001';
+        document.body.appendChild(errorDiv);
+    }
+
+    // Cleanup on page unload
+    window.addEventListener('beforeunload', () => {
+        app.destroy();
+    });
+});
+
+// Handle page visibility changes
+document.addEventListener('visibilitychange', () => {
+    if (document.hidden) {
+        console.log('Page hidden - connection may become unstable');
+    } else {
+        console.log('Page visible - checking connection status');
+    }
+});

js/peer-manager.js

@@ -0,0 +1,233 @@
+class PeerManager {
+    constructor() {
+        this.peer = null;
+        this.connections = new Map();
+        this.roomId = null;
+        this.isHost = false;
+        this.onPeerConnected = null;
+        this.onPeerDisconnected = null;
+        this.onMessageReceived = null;
+        this.onConnectionStatusChange = null;
+    }
+
+    async initialize() {
+        try {
+            this.peer = new Peer({
+                debug: 2,
+                config: {
+                    iceServers: [
+                        { urls: 'stun:stun.l.google.com:19302' },
+                        { urls: 'stun:stun1.l.google.com:19302' }
+                    ]
+                }
+            });
+
+            this.peer.on('open', (id) => {
+                console.log('My peer ID is:', id);
+                this.updateConnectionStatus('connected');
+                this.updatePeersList(); 
+                if (this.onConnectionStatusChange) {
+                    this.onConnectionStatusChange('connected', id);
+                }
+            });
+
+            this.peer.on('connection', (conn) => {
+                this.handleIncomingConnection(conn);
+            });
+
+            this.peer.on('disconnected', () => {
+                this.updateConnectionStatus('disconnected');
+                this.updatePeersList(); 
+            });
+
+            this.peer.on('error', (err) => {
+                console.error('Peer error:', err);
+                this.updateConnectionStatus('error');
+            });
+
+        } catch (error) {
+            console.error('Failed to initialize peer:', error);
+            throw error;
+        }
+    }
+
+    async createRoom() {
+        if (!this.peer) {
+            throw new Error('Peer not initialized');
+        }
+
+        this.roomId = this.generateRoomId();
+        this.isHost = true;
+        
+        console.log('Created room:', this.roomId);
+        return this.roomId;
+    }
+
+    async joinRoom(roomId) {
+        if (!this.peer) {
+            throw new Error('Peer not initialized');
+        }
+
+        this.roomId = roomId;
+        this.isHost = false;
+
+        console.log('Attempting to join room:', roomId);
+        
+
+        try {
+            const conn = this.peer.connect(roomId);
+            await this.setupConnection(conn);
+            console.log('Successfully joined room');
+            return true;
+        } catch (error) {
+            console.error('Failed to join room:', error);
+            throw new Error('Could not connect to host. Make sure the host is online and you have the correct peer ID.');
+        }
+    }
+
+    handleIncomingConnection(conn) {
+        this.setupConnection(conn);
+    }
+
+    async setupConnection(conn) {
+        return new Promise((resolve, reject) => {
+            conn.on('open', () => {
+                console.log('Connected to:', conn.peer);
+                this.connections.set(conn.peer, conn);
+                this.updatePeersList();
+
+                if (this.isHost) {
+                    if (this.onPeerConnected) {
+                        this.onPeerConnected(conn.peer);
+                    }
+                } else {
+                    if (this.onPeerConnected) {
+                        this.onPeerConnected(conn.peer);
+                    }
+                }
+
+                resolve(conn);
+            });
+
+            conn.on('data', (data) => {
+                this.handleMessage(data, conn.peer);
+            });
+
+            conn.on('close', () => {
+                console.log('Connection closed:', conn.peer);
+                this.connections.delete(conn.peer);
+                this.updatePeersList();
+                
+                if (this.onPeerDisconnected) {
+                    this.onPeerDisconnected(conn.peer);
+                }
+            });
+
+            conn.on('error', (err) => {
+                console.error('Connection error:', err);
+                reject(err);
+            });
+        });
+    }
+
+    handleMessage(data, senderId) {
+        console.log('Received message:', data, 'from:', senderId);
+        
+        if (this.onMessageReceived) {
+            this.onMessageReceived(data, senderId);
+        }
+    }
+
+    sendMessage(peerId, message) {
+        const conn = this.connections.get(peerId);
+        if (conn && conn.open) {
+            conn.send(message);
+            return true;
+        }
+        return false;
+    }
+
+    broadcastMessage(message) {
+        let sentCount = 0;
+        this.connections.forEach((conn, peerId) => {
+            if (conn.open) {
+                conn.send(message);
+                sentCount++;
+            }
+        });
+        return sentCount;
+    }
+
+    getPeerId() {
+        return this.peer ? this.peer.id : null;
+    }
+
+    getRoomId() {
+        return this.roomId;
+    }
+
+    getConnectedPeers() {
+        return Array.from(this.connections.keys());
+    }
+
+    getPeerCount() {
+        return this.connections.size;
+    }
+
+    isConnected() {
+        return this.peer && this.peer.disconnected !== true;
+    }
+
+    generateRoomId() {
+        return Math.random().toString(36).substr(2, 9).toUpperCase();
+    }
+
+    updateConnectionStatus(status) {
+        const indicator = document.getElementById('connection-indicator');
+        const statusText = document.getElementById('connection-status-text');
+        
+        if (indicator) {
+            indicator.className = `status-${status}`;
+        }
+        
+        if (statusText) {
+            statusText.textContent = status.charAt(0).toUpperCase() + status.slice(1);
+            statusText.className = `status-text ${status}`;
+        }
+    }
+
+    updatePeersList() {
+        const peersList = document.getElementById('peers');
+        const peerCount = document.getElementById('peer-count');
+        
+        if (peersList && peerCount) {
+            peerCount.textContent = this.getPeerCount();
+            peersList.innerHTML = '';
+            
+            if (this.getPeerCount() === 0) {
+                const li = document.createElement('li');
+                li.textContent = 'No connected peers';
+                li.style.fontStyle = 'italic';
+                li.style.color = '#9ca3af';
+                peersList.appendChild(li);
+            } else {
+                this.getConnectedPeers().forEach(peerId => {
+                    const li = document.createElement('li');
+                    li.textContent = `${peerId} ${peerId === this.peer.id ? '(You)' : ''}`;
+                    li.style.fontWeight = peerId === this.peer.id ? 'bold' : 'normal';
+                    li.style.color = peerId === this.peer.id ? '#667eea' : '#6b7280';
+                    peersList.appendChild(li);
+                });
+            }
+        }
+    }
+
+    destroy() {
+        if (this.peer) {
+            this.connections.forEach(conn => conn.close());
+            this.peer.destroy();
+            this.peer = null;
+            this.connections.clear();
+        }
+    }
+}

js/poll-manager.js

@@ -0,0 +1,428 @@
+class PollManager {
+    constructor(peerManager) {
+        this.peerManager = peerManager;
+        this.currentPoll = null;
+        this.availablePolls = new Map(); // pollId -> poll
+        this.myVotes = new Set();
+        this.onPollUpdated = null;
+        this.onPollCreated = null;
+        this.onPollSelected = null;
+        this.onPollsListUpdated = null;
+    }
+
+    createPoll(question, options) {
+        const poll = {
+            id: this.generatePollId(),
+            question: question.trim(),
+            options: options.map((text, index) => ({
+                id: `opt-${index}`,
+                text: text.trim(),
+                votes: 0,
+                voters: []
+            })),
+            createdBy: this.peerManager.getPeerId(),
+            createdAt: Date.now()
+        };
+
+        // Clear any existing votes when creating a new poll
+        this.myVotes.clear();
+        
+        this.currentPoll = poll;
+        this.availablePolls.set(poll.id, poll);
+        this.saveToLocalStorage();
+        
+        if (this.onPollCreated) {
+            this.onPollCreated(poll);
+        }
+        
+        if (this.onPollsListUpdated) {
+            this.onPollsListUpdated(Array.from(this.availablePolls.values()));
+        }
+
+        // Broadcast new poll to all peers
+        this.broadcastPollUpdate();
+        
+        return poll;
+    }
+
+    addOption(text) {
+        if (!this.currentPoll) {
+            throw new Error('No active poll');
+        }
+
+        const newOption = {
+            id: `opt-${Date.now()}`,
+            text: text.trim(),
+            votes: 0,
+            voters: []
+        };
+
+        this.currentPoll.options.push(newOption);
+        this.saveToLocalStorage();
+        this.notifyPollUpdated();
+        this.broadcastPollUpdate();
+        
+        return newOption;
+    }
+
+    vote(optionId) {
+        if (!this.currentPoll) {
+            throw new Error('No active poll');
+        }
+
+        const myPeerId = this.peerManager.getPeerId();
+        
+        // Check if already voted for this option
+        if (this.myVotes.has(optionId)) {
+            return false; 
+        }
+
+        this.removePreviousVote(myPeerId);
+
+        // Add new vote
+        const option = this.currentPoll.options.find(opt => opt.id === optionId);
+        if (!option) {
+            throw new Error('Option not found');
+        }
+
+        option.votes++;
+        option.voters.push(myPeerId);
+        this.myVotes.add(optionId);
+        
+        this.saveToLocalStorage();
+        this.notifyPollUpdated();
+        this.broadcastVote(optionId, myPeerId);
+        
+        return true;
+    }
+
+    removePreviousVote(peerId) {
+        if (!this.currentPoll) return;
+
+        this.currentPoll.options.forEach(option => {
+            const voterIndex = option.voters.indexOf(peerId);
+            if (voterIndex !== -1) {
+                option.votes--;
+                option.voters.splice(voterIndex, 1);
+                
+                // Remove from my votes if it's my vote
+                if (peerId === this.peerManager.getPeerId()) {
+                    this.myVotes.delete(option.id);
+                }
+            }
+        });
+    }
+
+    resetPoll() {
+        if (!this.currentPoll) {
+            throw new Error('No active poll');
+        }
+
+        this.currentPoll.options.forEach(option => {
+            option.votes = 0;
+            option.voters = [];
+        });
+
+        this.myVotes.clear();
+        this.saveToLocalStorage();
+        this.notifyPollUpdated();
+        this.broadcastPollReset();
+    }
+
+    syncPoll(pollData) {
+        if (!this.availablePolls.has(pollData.id)) {
+            this.availablePolls.set(pollData.id, pollData);
+            this.saveToLocalStorage();
+            
+            if (this.onPollsListUpdated) {
+                this.onPollsListUpdated(Array.from(this.availablePolls.values()));
+            }
+        }
+        
+        if (!this.currentPoll || this.currentPoll.id === pollData.id) {
+            this.currentPoll = pollData;
+            this.availablePolls.set(pollData.id, pollData);
+            
+            this.validateMyVotes(pollData);
+            
+            this.saveToLocalStorage();
+            if (this.onPollCreated) {
+                this.onPollCreated(pollData);
+            }
+        } else if (this.currentPoll.id === pollData.id) {
+            this.mergePollData(pollData);
+            this.availablePolls.set(pollData.id, this.currentPoll);
+            
+            this.validateMyVotes(this.currentPoll);
+            
+            this.saveToLocalStorage();
+            this.notifyPollUpdated();
+        }
+    }
+
+    mergePollData(remotePoll) {
+        const localOptions = new Map(this.currentPoll.options.map(opt => [opt.id, opt]));
+        const remoteOptions = new Map(remotePoll.options.map(opt => [opt.id, opt]));
+
+        remoteOptions.forEach((remoteOpt, id) => {
+            if (!localOptions.has(id)) {
+                this.currentPoll.options.push(remoteOpt);
+                localOptions.set(id, remoteOpt);
+            }
+        });
+
+        this.currentPoll.options.forEach(localOpt => {
+            const remoteOpt = remoteOptions.get(localOpt.id);
+            if (remoteOpt) {
+                const allVoters = new Set([...localOpt.voters, ...remoteOpt.voters]);
+                localOpt.voters = Array.from(allVoters);
+                localOpt.votes = localOpt.voters.length;
+            }
+        });
+    }
+
+    handleVoteMessage(optionId, voterId) {
+        if (!this.currentPoll) return;
+
+        this.removePreviousVote(voterId);
+
+        const option = this.currentPoll.options.find(opt => opt.id === optionId);
+        if (option && !option.voters.includes(voterId)) {
+            option.votes++;
+            option.voters.push(voterId);
+            
+            // Update my votes if this is my vote
+            if (voterId === this.peerManager.getPeerId()) {
+                this.myVotes.add(optionId);
+            }
+            
+            this.saveToLocalStorage();
+            this.notifyPollUpdated();
+        }
+    }
+
+    handleUnvoteMessage(voterId) {
+        if (!this.currentPoll) return;
+
+        // Remove vote from this voter
+        this.removePreviousVote(voterId);
+        
+        // Update my votes if this is my vote
+        if (voterId === this.peerManager.getPeerId()) {
+            this.myVotes.clear();
+        }
+        
+        this.saveToLocalStorage();
+        this.notifyPollUpdated();
+    }
+
+    handlePollReset() {
+        if (!this.currentPoll) return;
+
+        this.currentPoll.options.forEach(option => {
+            option.votes = 0;
+            option.voters = [];
+        });
+
+        this.myVotes.clear();
+        this.saveToLocalStorage();
+        this.notifyPollUpdated();
+    }
+
+    broadcastPollUpdate() {
+        if (!this.currentPoll) return;
+
+        this.peerManager.broadcastMessage({
+            type: 'poll_update',
+            poll: this.currentPoll,
+            senderId: this.peerManager.getPeerId()
+        });
+    }
+
+    broadcastVote(optionId, voterId) {
+        this.peerManager.broadcastMessage({
+            type: 'vote',
+            optionId: optionId,
+            voterId: voterId,
+            senderId: this.peerManager.getPeerId()
+        });
+    }
+
+    broadcastPollReset() {
+        this.peerManager.broadcastMessage({
+            type: 'poll_reset',
+            senderId: this.peerManager.getPeerId()
+        });
+    }
+
+    selectPoll(pollId) {
+        const poll = this.availablePolls.get(pollId);
+        if (poll) {
+            this.currentPoll = poll;
+            
+            // Clear votes when switching to a different poll
+            // Only clear if this is a different poll than what we had voted in
+            const currentVotedOption = this.getMyVotedOption();
+            if (currentVotedOption && !poll.options.some(opt => opt.id === currentVotedOption)) {
+                this.myVotes.clear();
+            }
+            
+            this.saveToLocalStorage();
+            
+            if (this.onPollSelected) {
+                this.onPollSelected(poll);
+            }
+            
+            if (this.onPollUpdated) {
+                this.onPollUpdated(poll);
+            }
+            
+            return true;
+        }
+        return false;
+    }
+
+    createNewPoll() {
+        this.currentPoll = null;
+        // Clear current poll inputs but keep available polls
+        if (this.onPollSelected) {
+            this.onPollSelected(null);
+        }
+    }
+
+    getAvailablePolls() {
+        return Array.from(this.availablePolls.values());
+    }
+
+    unvote() {
+        if (!this.currentPoll) {
+            throw new Error('No active poll');
+        }
+
+        const myPeerId = this.peerManager.getPeerId();
+        const myVotedOption = this.getMyVotedOption();
+        
+        if (!myVotedOption) {
+            return false; // No vote to remove
+        }
+
+        // Remove vote from current option
+        this.removePreviousVote(myPeerId);
+        
+        this.saveToLocalStorage();
+        this.notifyPollUpdated();
+        this.broadcastUnvote(myPeerId);
+        
+        return true;
+    }
+
+    validateMyVotes(poll) {
+        const myPeerId = this.peerManager.getPeerId();
+        const validVotes = new Set();
+        
+        console.log('Validating votes for peer:', myPeerId);
+        console.log('Current myVotes:', Array.from(this.myVotes));
+        console.log('Poll voters:', poll.options.map(opt => ({ id: opt.id, voters: opt.voters })));
+        
+        // Check each vote in myVotes to see if it's actually mine
+        this.myVotes.forEach(optionId => {
+            const option = poll.options.find(opt => opt.id === optionId);
+            if (option && option.voters.includes(myPeerId)) {
+                // This vote is actually mine
+                validVotes.add(optionId);
+                console.log(`Vote ${optionId} is valid for peer ${myPeerId}`);
+            } else {
+                console.log(`Vote ${optionId} is NOT valid for peer ${myPeerId}`);
+            }
+        });
+        
+        // Replace myVotes with only the valid votes
+        this.myVotes = validVotes;
+        console.log('Final valid votes:', Array.from(this.myVotes));
+    }
+
+    getCurrentPoll() {
+        return this.currentPoll;
+    }
+
+    broadcastUnvote(peerId) {
+        this.peerManager.broadcastMessage({
+            type: 'unvote',
+            voterId: peerId,
+            senderId: this.peerManager.getPeerId()
+        });
+    }
+
+    hasVoted(optionId) {
+        return this.myVotes.has(optionId);
+    }
+
+    getMyVotedOption() {
+        return Array.from(this.myVotes)[0] || null;
+    }
+
+    generatePollId() {
+        return `poll-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    }
+
+    saveToLocalStorage() {
+        // Save all available polls
+        const pollsData = Array.from(this.availablePolls.values());
+        localStorage.setItem('p2p-polls-list', JSON.stringify(pollsData));
+        
+        // Save current poll separately
+        if (this.currentPoll) {
+            localStorage.setItem('p2p-poll-current', JSON.stringify(this.currentPoll));
+        } else {
+            localStorage.removeItem('p2p-poll-current');
+        }
+        
+        localStorage.setItem('p2p-poll-my-votes', JSON.stringify(Array.from(this.myVotes)));
+    }
+
+    loadFromLocalStorage() {
+        try {
+            const savedPollsList = localStorage.getItem('p2p-polls-list');
+            const savedVotes = localStorage.getItem('p2p-poll-my-votes');
+            
+            if (savedPollsList) {
+                const polls = JSON.parse(savedPollsList);
+                this.availablePolls.clear();
+                polls.forEach(poll => {
+                    this.availablePolls.set(poll.id, poll);
+                });
+                
+                if (this.onPollsListUpdated) {
+                    this.onPollsListUpdated(polls);
+                }
+            }
+            
+            if (savedVotes) {
+                this.myVotes = new Set(JSON.parse(savedVotes));
+                
+                // Validate votes against current poll
+                const currentPoll = this.currentPoll || this.availablePolls.values().next().value;
+                if (currentPoll) {
+                    this.validateMyVotes(currentPoll);
+                }
+            }
+        } catch (error) {
+            console.error('Failed to load from localStorage:', error);
+        }
+    }
+
+    clearData() {
+        this.currentPoll = null;
+        this.availablePolls.clear();
+        this.myVotes.clear();
+        localStorage.removeItem('p2p-poll-current');
+        localStorage.removeItem('p2p-polls-list');
+        localStorage.removeItem('p2p-poll-my-votes');
+    }
+
+    notifyPollUpdated() {
+        if (this.onPollUpdated) {
+            this.onPollUpdated(this.currentPoll);
+        }
+    }
+}

js/ui-controller.js

@@ -0,0 +1,419 @@
+class UIController {
+    constructor(peerManager, pollManager) {
+        this.peerManager = peerManager;
+        this.pollManager = pollManager;
+        this.initializeEventListeners();
+    }
+
+    initializeEventListeners() {
+        // Connection controls
+        document.getElementById('join-btn').addEventListener('click', () => this.handleJoinRoom());
+        document.getElementById('copy-id-btn').addEventListener('click', () => this.copyPeerId());
+        
+        // Poll creation
+        document.getElementById('create-poll-btn').addEventListener('click', () => this.handleCreatePoll());
+        document.getElementById('add-option-btn').addEventListener('click', () => this.addOptionInput());
+        
+        // Active poll
+        document.getElementById('add-poll-option-btn').addEventListener('click', () => this.showAddOptionModal());
+        document.getElementById('reset-poll-btn').addEventListener('click', () => this.handleResetPoll());
+        document.getElementById('new-poll-btn').addEventListener('click', () => this.handleNewPoll());
+        
+        // Modal controls
+        document.getElementById('close-modal-btn').addEventListener('click', () => this.hideAddOptionModal());
+        document.getElementById('cancel-modal-btn').addEventListener('click', () => this.hideAddOptionModal());
+        document.getElementById('save-option-btn').addEventListener('click', () => this.handleAddOptionFromModal());
+        
+        // Enter key handlers
+        document.getElementById('room-id').addEventListener('keypress', (e) => {
+            if (e.key === 'Enter') this.handleJoinRoom();
+        });
+        
+        document.getElementById('poll-question').addEventListener('keypress', (e) => {
+            if (e.key === 'Enter') this.handleCreatePoll();
+        });
+        
+        document.getElementById('new-option-input').addEventListener('keypress', (e) => {
+            if (e.key === 'Enter') this.handleAddOptionFromModal();
+        });
+        
+        // Close modal on background click
+        document.getElementById('add-option-modal').addEventListener('click', (e) => {
+            if (e.target.id === 'add-option-modal') {
+                this.hideAddOptionModal();
+            }
+        });
+    }
+
+    handleJoinRoom() {
+        const roomIdInput = document.getElementById('room-id');
+        const peerId = roomIdInput.value.trim();
+        
+        this.showLoading(true);
+        
+        if (peerId) {
+            // Connect to existing peer (host)
+            this.peerManager.joinRoom(peerId)
+                .then(() => {
+                    this.showNotification('Connected to host successfully!', 'success');
+                    this.showPollCreation();
+                })
+                .catch(error => {
+                    this.showNotification('Failed to connect: ' + error.message, 'error');
+                    console.error('Connect error:', error);
+                })
+                .finally(() => {
+                    this.showLoading(false);
+                });
+        } else {
+            // Act as host - just show poll creation
+            this.peerManager.createRoom();
+            this.showNotification('You are the host. Share your Peer ID with others to connect.', 'success');
+            this.showPollCreation();
+            this.showLoading(false);
+        }
+    }
+
+    async copyPeerId() {
+        const peerId = this.peerManager.getPeerId();
+        if (peerId) {
+            try {
+                await navigator.clipboard.writeText(peerId);
+                this.showNotification('Peer ID copied to clipboard!', 'success');
+            } catch (error) {
+                // Fallback for older browsers
+                const textArea = document.createElement('textarea');
+                textArea.value = peerId;
+                document.body.appendChild(textArea);
+                textArea.select();
+                document.execCommand('copy');
+                document.body.removeChild(textArea);
+                this.showNotification('Peer ID copied to clipboard!', 'success');
+            }
+        }
+    }
+
+    handleCreatePoll() {
+        const questionInput = document.getElementById('poll-question');
+        const optionInputs = document.querySelectorAll('.option-text');
+        const options = [];
+
+        console.log('Question input:', questionInput);
+        console.log('Found option inputs:', optionInputs.length);
+
+        // Check if question input exists
+        if (!questionInput) {
+            console.error('Question input not found!');
+            this.showNotification('Error: Question input not found', 'error');
+            return;
+        }
+
+        const question = questionInput.value ? questionInput.value.trim() : '';
+        console.log('Question:', question);
+
+        optionInputs.forEach((input, index) => {
+            console.log(`Input ${index}:`, input, 'value:', input?.value);
+            if (input && typeof input.value !== 'undefined') {
+                const text = input.value.trim();
+                if (text) {
+                    options.push(text);
+                }
+            } else {
+                console.warn(`Input ${index} is invalid or has no value property`);
+            }
+        });
+
+        console.log('Final options:', options);
+
+        if (!question) {
+            this.showNotification('Please enter a poll question', 'error');
+            return;
+        }
+
+        if (options.length < 2) {
+            this.showNotification('Please enter at least 2 options', 'error');
+            return;
+        }
+
+        try {
+            this.pollManager.createPoll(question, options);
+            this.showNotification('Poll created successfully!', 'success');
+        } catch (error) {
+            console.error('Create poll error:', error);
+            this.showNotification('Failed to create poll: ' + error.message, 'error');
+        }
+    }
+
+    showAddOptionModal() {
+        const modal = document.getElementById('add-option-modal');
+        const input = document.getElementById('new-option-input');
+        modal.classList.remove('hidden');
+        input.value = '';
+        input.focus();
+    }
+
+    hideAddOptionModal() {
+        const modal = document.getElementById('add-option-modal');
+        const input = document.getElementById('new-option-input');
+        modal.classList.add('hidden');
+        input.value = '';
+    }
+
+    handleAddOptionFromModal() {
+        const input = document.getElementById('new-option-input');
+        const optionText = input.value.trim();
+        
+        if (!optionText) {
+            this.showNotification('Please enter an option text', 'error');
+            return;
+        }
+        
+        try {
+            this.pollManager.addOption(optionText);
+            this.hideAddOptionModal();
+            this.showNotification('Option added successfully!', 'success');
+        } catch (error) {
+            this.showNotification('Failed to add option: ' + error.message, 'error');
+        }
+    }
+
+    handleAddPollOption() {
+        this.showAddOptionModal();
+    }
+
+    handleResetPoll() {
+        if (confirm('Are you sure you want to reset all votes?')) {
+            try {
+                this.pollManager.resetPoll();
+                this.showNotification('Poll reset successfully!', 'success');
+            } catch (error) {
+                this.showNotification('Failed to reset poll: ' + error.message, 'error');
+            }
+        }
+    }
+
+    handleNewPoll() {
+        this.pollManager.createNewPoll();
+        this.showPollCreation();
+        this.clearPollForm();
+    }
+
+    addOptionInput() {
+        const container = document.getElementById('options-container');
+        const optionCount = container.children.length;
+        
+        const optionDiv = document.createElement('div');
+        optionDiv.className = 'option-input';
+        optionDiv.innerHTML = `
+            <input type="text" class="option-text" placeholder="Option ${optionCount + 1}">
+            <button class="remove-option-btn">Remove</button>
+        `;
+
+        container.appendChild(optionDiv);
+        this.updateOptionRemoveButtons();
+
+        // Add event listener to new input
+        const newInput = optionDiv.querySelector('.option-text');
+        newInput.addEventListener('keypress', (e) => {
+            if (e.key === 'Enter') this.handleCreatePoll();
+        });
+
+        // Add event listener to remove button
+        const removeBtn = optionDiv.querySelector('.remove-option-btn');
+        removeBtn.addEventListener('click', () => {
+            optionDiv.remove();
+            this.updateOptionRemoveButtons();
+            this.updateOptionPlaceholders();
+        });
+
+        // Focus on new input
+        newInput.focus();
+    }
+
+    updateOptionRemoveButtons() {
+        const optionInputs = document.querySelectorAll('.option-input');
+        const removeButtons = document.querySelectorAll('.remove-option-btn');
+        
+        removeButtons.forEach((btn, index) => {
+            if (optionInputs.length <= 2) {
+                btn.classList.add('hidden');
+            } else {
+                btn.classList.remove('hidden');
+            }
+        });
+    }
+
+    updateOptionPlaceholders() {
+        const optionInputs = document.querySelectorAll('.option-text');
+        optionInputs.forEach((input, index) => {
+            input.placeholder = `Option ${index + 1}`;
+        });
+    }
+
+    clearPollForm() {
+        document.getElementById('poll-question').value = '';
+        const container = document.getElementById('options-container');
+        container.innerHTML = `
+            <div class="option-input">
+                <input type="text" class="option-text" placeholder="Option 1">
+                <button class="remove-option-btn hidden">Remove</button>
+            </div>
+            <div class="option-input">
+                <input type="text" class="option-text" placeholder="Option 2">
+                <button class="remove-option-btn hidden">Remove</button>
+            </div>
+        `;
+        this.updateOptionRemoveButtons();
+    }
+
+    showPollCreation() {
+        document.getElementById('connection-section').classList.add('hidden');
+        document.getElementById('poll-creation').classList.remove('hidden');
+        document.getElementById('active-poll').classList.add('hidden');
+    }
+
+    showActivePoll() {
+        document.getElementById('connection-section').classList.add('hidden');
+        document.getElementById('poll-creation').classList.add('hidden');
+        document.getElementById('active-poll').classList.remove('hidden');
+    }
+
+    updatePeerId(peerId) {
+        const element = document.getElementById('peer-id');
+        if (element) {
+            element.textContent = peerId || 'Loading...';
+        }
+    }
+
+    renderPoll(poll) {
+        if (!poll) return;
+
+        this.showActivePoll();
+        
+        // Update poll question
+        document.getElementById('poll-question-display').textContent = poll.question;
+        
+        // Render options
+        const optionsContainer = document.getElementById('poll-options');
+        optionsContainer.innerHTML = '';
+        
+        const totalVotes = poll.options.reduce((sum, opt) => sum + opt.votes, 0);
+        const myVotedOption = this.pollManager.getMyVotedOption();
+        
+        poll.options.forEach(option => {
+            const optionDiv = document.createElement('div');
+            optionDiv.className = 'poll-option';
+            
+            const hasVoted = this.pollManager.hasVoted(option.id);
+            const myVotedOption = this.pollManager.getMyVotedOption();
+            
+            console.log(`Option ${option.id}: hasVoted=${hasVoted}, myVotedOption=${myVotedOption}`);
+            
+            if (hasVoted) {
+                optionDiv.classList.add('voted');
+            } else if (myVotedOption) {
+                // User has voted but not for this option - this is a change vote option
+                optionDiv.classList.add('change-vote');
+            }
+            
+            const percentage = totalVotes > 0 ? (option.votes / totalVotes * 100).toFixed(1) : 0;
+            
+            optionDiv.innerHTML = `
+                <div class="option-header">
+                    <span class="option-text">${option.text}</span>
+                    <span class="vote-count">${option.votes} votes</span>
+                </div>
+                <div class="vote-bar">
+                    <div class="vote-fill" style="width: ${percentage}%"></div>
+                </div>
+            `;
+            
+            optionDiv.addEventListener('click', () => {
+                const myVotedOption = this.pollManager.getMyVotedOption();
+                
+                if (this.pollManager.hasVoted(option.id)) {
+                    // Clicking your current vote - unvote
+                    if (confirm('Remove your vote?')) {
+                        const success = this.pollManager.unvote();
+                        if (success) {
+                            this.showNotification('Vote removed!', 'success');
+                        }
+                    }
+                } else {
+                    // Either first vote or changing vote
+                    const success = this.pollManager.vote(option.id);
+                    if (success) {
+                        if (myVotedOption) {
+                            this.showNotification('Vote changed successfully!', 'success');
+                        } else {
+                            this.showNotification('Vote recorded!', 'success');
+                        }
+                    }
+                }
+            });
+            
+            optionsContainer.appendChild(optionDiv);
+        });
+    }
+
+    showNotification(message, type = 'info') {
+        const notification = document.getElementById('notification');
+        notification.textContent = message;
+        notification.className = `notification ${type}`;
+        notification.classList.remove('hidden');
+        
+        setTimeout(() => {
+            notification.classList.add('hidden');
+        }, 3000);
+    }
+
+    showLoading(show) {
+        const overlay = document.getElementById('loading-overlay');
+        if (show) {
+            overlay.classList.remove('hidden');
+        } else {
+            overlay.classList.add('hidden');
+        }
+    }
+
+    updatePeersList() {
+        // Use the peer manager's updatePeersList method
+        this.peerManager.updatePeersList();
+    }
+
+    updatePollsList(polls) {
+        const pollsList = document.getElementById('polls-list');
+        
+        if (!pollsList) return;
+        
+        if (polls.length === 0) {
+            pollsList.innerHTML = '<p class="no-polls">No polls created yet</p>';
+            return;
+        }
+        
+        pollsList.innerHTML = '';
+        
+        polls.forEach(poll => {
+            const pollDiv = document.createElement('div');
+            pollDiv.className = 'poll-item';
+            
+            if (this.pollManager.getCurrentPoll() && this.pollManager.getCurrentPoll().id === poll.id) {
+                pollDiv.classList.add('active');
+            }
+            
+            const totalVotes = poll.options.reduce((sum, opt) => sum + opt.votes, 0);
+            const createdDate = new Date(poll.createdAt).toLocaleString();
+            
+            pollDiv.innerHTML = `
+                <div class="poll-item-title">${poll.question}</div>
+                <div class="poll-item-meta">${totalVotes} votes • ${createdDate}</div>
+            `;
+            
+            pollDiv.addEventListener('click', () => {
+                this.pollManager.selectPoll(poll.id);
+            });
+            
+            pollsList.appendChild(pollDiv);
+        });
+    }
+}

package.json

@@ -1,20 +0,0 @@
-{
-  "name": "polly-p2p-poll",
-  "version": "1.0.0",
-  "private": true,
-  "type": "module",
-  "scripts": {
-    "dev": "vite",
-    "build": "tsc --noEmit && vite build",
-    "preview": "vite preview"
-  },
-  "dependencies": {
-    "y-indexeddb": "^9.0.12",
-    "y-webrtc": "^10.3.0",
-    "yjs": "^13.6.27"
-  },
-  "devDependencies": {
-    "typescript": "^5.9.2",
-    "vite": "^7.1.5"
-  }
-}

src/app.ts

@@ -1,139 +0,0 @@
-import { getUserId } from "./identity";
-import {
-  addOption,
-  toggleVote,
-  deleteOption,
-  setDeadline,
-  clearDeadline,
-  createViewModel,
-} from "./state";
-import { initSync } from "./sync";
-import { StatusBar } from "./components/StatusBar";
-import { PollTitle } from "./components/PollTitle";
-import { AddOption } from "./components/AddOption";
-import { PollList } from "./components/PollList";
-import { ShareSection } from "./components/ShareSection";
-import { DeadlineTimer } from "./components/DeadlineTimer";
-
-const ROOM_PARAM = "room";
-
-function createRoomId(): string {
-  if (typeof crypto.randomUUID === "function") {
-    return `poll-${crypto.randomUUID().slice(0, 8)}`;
-  }
-  return `poll-${Math.random().toString(36).slice(2, 10)}`;
-}
-
-function ensureRoomId(): string {
-  const url = new URL(window.location.href);
-  let roomId = url.searchParams.get(ROOM_PARAM)?.trim();
-
-  if (!roomId) {
-    roomId = createRoomId();
-    url.searchParams.set(ROOM_PARAM, roomId);
-    window.history.replaceState({}, "", url);
-  }
-
-  return roomId;
-}
-
-export function initApp(container: HTMLElement): () => void {
-  const roomId = ensureRoomId();
-  const userId = getUserId();
-  const sync = initSync(roomId);
-
-  const shareUrl = window.location.href;
-
-  // --- Actions ---
-
-  const actions = {
-    addOption: (label: string) => {
-      const vm = createViewModel(getViewModelParams());
-      if (vm.votingClosed) return;
-      return addOption(sync.options, label, userId);
-    },
-    toggleVote: (optionId: string) => {
-      const vm = createViewModel(getViewModelParams());
-      if (vm.votingClosed) return;
-      toggleVote(sync.votes, userId, optionId);
-    },
-    deleteOption: (optionId: string) => {
-      deleteOption(sync.options, sync.votes, optionId);
-    },
-    startDeadline: (durationMs: number) => {
-      setDeadline(sync.deadlineMap, durationMs);
-    },
-    clearDeadline: () => {
-      clearDeadline(sync.deadlineMap);
-    },
-  };
-
-  function getViewModelParams() {
-    return {
-      yTitle: sync.yTitle,
-      options: sync.options,
-      votes: sync.votes,
-      deadlineMap: sync.deadlineMap,
-      roomId,
-      shareUrl,
-      connectionStatus: sync.getConnectionStatus(),
-      peerCount: sync.getPeerCount(),
-      userId,
-    };
-  }
-
-  // --- Build UI ---
-
-  // Header
-  const header = document.createElement("header");
-  header.className = "app-header";
-
-  const wordmark = document.createElement("div");
-  wordmark.className = "app-wordmark";
-  wordmark.innerHTML = `
-    <svg width="20" height="20" viewBox="0 0 20 20" fill="none" xmlns="http://www.w3.org/2000/svg" aria-hidden="true">
-      <rect x="2" y="4" width="16" height="2.5" rx="1.25" fill="currentColor"/>
-      <rect x="2" y="8.75" width="11" height="2.5" rx="1.25" fill="currentColor" opacity="0.6"/>
-      <rect x="2" y="13.5" width="13" height="2.5" rx="1.25" fill="currentColor" opacity="0.35"/>
-    </svg>
-    <span>Polly</span>
-  `;
-
-  const statusBar = StatusBar(sync.provider);
-  header.append(wordmark, statusBar);
-
-  // Main card
-  const card = document.createElement("main");
-  card.className = "app-card";
-
-  const pollTitle = PollTitle(sync.doc, sync.yTitle);
-  const addOptionComponent = AddOption((label: string) => {
-    const result = actions.addOption(label);
-    if (result && !result.ok) return result.error;
-    return null;
-  });
-  const pollList = PollList(sync.options, sync.votes, userId, () => {
-    const vm = createViewModel(getViewModelParams());
-    return vm.votingClosed;
-  }, actions.toggleVote, actions.deleteOption);
-  const deadlineTimer = DeadlineTimer(
-    sync.deadlineMap,
-    actions.startDeadline,
-    actions.clearDeadline,
-  );
-
-  card.append(pollTitle, addOptionComponent, deadlineTimer, pollList);
-
-  // Footer
-  const footer = document.createElement("footer");
-  footer.className = "app-footer";
-  footer.appendChild(ShareSection(roomId));
-
-  container.append(header, card, footer);
-
-  // --- Cleanup ---
-
-  return () => {
-    sync.destroy();
-  };
-}

src/components/AddOption.ts

@@ -1,66 +0,0 @@
-export function AddOption(
-  onSubmit: (label: string) => string | null,
-): HTMLElement {
-  const wrapper = document.createElement("div");
-  wrapper.className = "add-option-wrapper";
-
-  const input = document.createElement("input");
-  input.type = "text";
-  input.className = "add-option-input";
-  input.placeholder = "Add an option\u2026";
-  input.maxLength = 100;
-  input.setAttribute("aria-label", "New poll option");
-
-  const btn = document.createElement("button");
-  btn.className = "add-option-btn";
-  btn.setAttribute("aria-label", "Add option");
-  btn.innerHTML = `
-    <svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg" aria-hidden="true">
-      <path d="M8 2v12M2 8h12" stroke="currentColor" stroke-width="1.75" stroke-linecap="round"/>
-    </svg>
-    <span>Add</span>
-  `;
-
-  const feedback = document.createElement("div");
-  feedback.className = "add-option-feedback";
-  feedback.setAttribute("aria-live", "polite");
-
-  wrapper.append(input, btn, feedback);
-
-  function submit() {
-    const name = input.value.trim();
-    if (!name) {
-      input.focus();
-      input.classList.add("shake");
-      input.addEventListener("animationend", () => input.classList.remove("shake"), { once: true });
-      return;
-    }
-
-    const error = onSubmit(name);
-    if (error) {
-      feedback.textContent = error;
-      feedback.style.display = "";
-      setTimeout(() => {
-        feedback.textContent = "";
-        feedback.style.display = "none";
-      }, 3000);
-      return;
-    }
-
-    input.value = "";
-    feedback.textContent = "";
-    feedback.style.display = "none";
-    input.focus();
-  }
-
-  btn.addEventListener("click", submit);
-  input.addEventListener("keydown", (e) => {
-    if (e.key === "Enter") submit();
-  });
-  input.addEventListener("input", () => {
-    feedback.textContent = "";
-    feedback.style.display = "none";
-  });
-
-  return wrapper;
-}

src/components/DeadlineTimer.ts

@@ -1,86 +0,0 @@
-import * as Y from "yjs";
-import { getDeadline } from "../state";
-
-const DEADLINE_DURATION_MS = 2 * 60 * 1000; // 2 minutes
-
-export function DeadlineTimer(
-  deadlineMap: Y.Map<unknown>,
-  onStartDeadline: (durationMs: number) => void,
-  onClearDeadline: () => void,
-): HTMLElement {
-  const wrapper = document.createElement("div");
-  wrapper.className = "deadline-wrapper";
-
-  const timerEl = document.createElement("span");
-  timerEl.className = "deadline-timer";
-
-  const startBtn = document.createElement("button");
-  startBtn.className = "deadline-btn";
-  startBtn.textContent = "Start 2-min vote";
-  startBtn.setAttribute("aria-label", "Start a 2-minute voting deadline");
-
-  const clearBtn = document.createElement("button");
-  clearBtn.className = "deadline-btn deadline-btn--clear";
-  clearBtn.textContent = "Clear";
-  clearBtn.setAttribute("aria-label", "Remove voting deadline");
-
-  wrapper.append(timerEl, startBtn, clearBtn);
-
-  let interval: ReturnType<typeof setInterval> | undefined;
-
-  function render() {
-    const deadline = getDeadline(deadlineMap);
-    const now = Date.now();
-
-    if (deadline === null) {
-      // No deadline set
-      timerEl.textContent = "";
-      timerEl.className = "deadline-timer";
-      startBtn.hidden = false;
-      clearBtn.hidden = true;
-      if (interval) {
-        clearInterval(interval);
-        interval = undefined;
-      }
-      return;
-    }
-
-    startBtn.hidden = true;
-    clearBtn.hidden = false;
-
-    if (now >= deadline) {
-      // Voting closed
-      timerEl.textContent = "Voting closed";
-      timerEl.className = "deadline-timer deadline-timer--closed";
-      if (interval) {
-        clearInterval(interval);
-        interval = undefined;
-      }
-      return;
-    }
-
-    // Counting down
-    const remaining = Math.ceil((deadline - now) / 1000);
-    const mins = Math.floor(remaining / 60);
-    const secs = remaining % 60;
-    timerEl.textContent = `Voting closes in ${mins}:${secs.toString().padStart(2, "0")}`;
-    timerEl.className = "deadline-timer deadline-timer--active";
-
-    if (!interval) {
-      interval = setInterval(() => render(), 1000);
-    }
-  }
-
-  startBtn.addEventListener("click", () => {
-    onStartDeadline(DEADLINE_DURATION_MS);
-  });
-
-  clearBtn.addEventListener("click", () => {
-    onClearDeadline();
-  });
-
-  deadlineMap.observe(() => render());
-  render();
-
-  return wrapper;
-}

src/components/PollList.ts

@@ -1,127 +0,0 @@
-import * as Y from "yjs";
-import type { OptionRecord } from "../state";
-import { PollOption } from "./PollOption";
-
-export function PollList(
-  yOptions: Y.Map<OptionRecord>,
-  yVotes: Y.Map<string>,
-  userId: string,
-  isVotingClosed: () => boolean,
-  onVote: (optionId: string) => void,
-  onDelete: (optionId: string) => void,
-): HTMLElement {
-  const wrapper = document.createElement("div");
-  wrapper.className = "poll-list-wrapper";
-
-  const meta = document.createElement("div");
-  meta.className = "poll-list-meta";
-
-  const list = document.createElement("div");
-  list.className = "poll-list";
-
-  const empty = document.createElement("div");
-  empty.className = "poll-list-empty";
-  empty.innerHTML = `
-    <div class="empty-icon">
-      <svg width="32" height="32" viewBox="0 0 32 32" fill="none" xmlns="http://www.w3.org/2000/svg">
-        <rect x="4" y="10" width="24" height="3" rx="1.5" fill="currentColor" opacity="0.15"/>
-        <rect x="4" y="16" width="18" height="3" rx="1.5" fill="currentColor" opacity="0.1"/>
-        <rect x="4" y="22" width="21" height="3" rx="1.5" fill="currentColor" opacity="0.07"/>
-      </svg>
-    </div>
-    <p>No options yet — add the first one above.</p>
-  `;
-
-  wrapper.append(meta, list, empty);
-
-  function getEntries() {
-    const entries: Array<{
-      id: string;
-      name: string;
-      votes: number;
-      voted: boolean;
-    }> = [];
-
-    // Tally votes per option
-    const tally = new Map<string, number>();
-    for (const optionId of yVotes.values()) {
-      tally.set(optionId, (tally.get(optionId) ?? 0) + 1);
-    }
-
-    const myVote = yVotes.get(userId) ?? null;
-
-    yOptions.forEach((record, id) => {
-      entries.push({
-        id,
-        name: record.label,
-        votes: tally.get(id) ?? 0,
-        voted: myVote === id,
-      });
-    });
-
-    entries.sort((a, b) => b.votes - a.votes || a.name.localeCompare(b.name));
-    return entries;
-  }
-
-  function getTotalVotes(): number {
-    return yVotes.size;
-  }
-
-  function render() {
-    const entries = getEntries();
-    const total = getTotalVotes();
-    const votingClosed = isVotingClosed();
-
-    // Meta line
-    if (entries.length > 0) {
-      meta.textContent = `${entries.length} option${entries.length !== 1 ? "s" : ""} \u00b7 ${total} vote${total !== 1 ? "s" : ""} total`;
-      meta.style.display = "";
-    } else {
-      meta.style.display = "none";
-    }
-
-    // Empty state
-    empty.style.display = entries.length === 0 ? "" : "none";
-
-    // Diff-render: reuse existing rows when possible
-    const existing = new Map(
-      [...list.querySelectorAll<HTMLElement>(".poll-option")].map((el) => [
-        el.dataset.id,
-        el,
-      ]),
-    );
-
-    // Remove stale rows
-    existing.forEach((el, id) => {
-      if (!entries.find((e) => e.id === id)) el.remove();
-    });
-
-    // Update or insert rows in sorted order
-    entries.forEach((entry, i) => {
-      const newEl = PollOption({
-        ...entry,
-        totalVotes: total,
-        votingClosed,
-        onVote,
-        onDelete,
-      });
-      const currentEl = list.children[i] as HTMLElement | undefined;
-
-      if (!currentEl) {
-        list.appendChild(newEl);
-      } else if (currentEl.dataset.id !== entry.id) {
-        list.insertBefore(newEl, currentEl);
-        const old = existing.get(entry.id);
-        if (old && old !== currentEl) old.remove();
-      } else {
-        list.replaceChild(newEl, currentEl);
-      }
-    });
-  }
-
-  yOptions.observeDeep(() => render());
-  yVotes.observe(() => render());
-  render();
-
-  return wrapper;
-}

src/components/PollOption.ts

@@ -1,46 +0,0 @@
-import { escapeHtml } from "../state";
-
-export interface PollOptionProps {
-  id: string;
-  name: string;
-  votes: number;
-  voted: boolean;
-  totalVotes: number;
-  votingClosed: boolean;
-  onVote: (id: string) => void;
-  onDelete: (id: string) => void;
-}
-
-export function PollOption(props: PollOptionProps): HTMLElement {
-  const { id, name, votes, voted, totalVotes, votingClosed, onVote, onDelete } = props;
-
-  const row = document.createElement("div");
-  row.className = `poll-option${voted ? " poll-option--voted" : ""}`;
-  row.dataset.id = id;
-
-  const pct = totalVotes > 0 ? Math.round((votes / totalVotes) * 100) : 0;
-
-  row.innerHTML = `
-    <div class="poll-option__bar" style="width: ${pct}%"></div>
-    <div class="poll-option__content">
-      <span class="poll-option__name">${escapeHtml(name)}</span>
-      <div class="poll-option__actions">
-        <span class="poll-option__pct">${pct}%</span>
-        <span class="poll-option__count">${votes} vote${votes !== 1 ? "s" : ""}</span>
-        <button class="poll-option__vote-btn" aria-pressed="${voted}"${votingClosed ? " disabled" : ""}>
-          ${voted ? "Voted" : "Vote"}
-        </button>
-        <button class="poll-option__delete-btn" aria-label="Remove option">
-          <svg width="14" height="14" viewBox="0 0 14 14" fill="none" xmlns="http://www.w3.org/2000/svg">
-            <path d="M2 2l10 10M12 2L2 12" stroke="currentColor" stroke-width="1.5" stroke-linecap="round"/>
-          </svg>
-        </button>
-      </div>
-    </div>
-  `;
-
-  row.querySelector(".poll-option__vote-btn")!.addEventListener("click", () => onVote(id));
-  row.querySelector(".poll-option__delete-btn")!.addEventListener("click", () => onDelete(id));
-
-  return row;
-}

src/components/PollTitle.ts

@@ -1,34 +0,0 @@
-import * as Y from "yjs";
-
-export function PollTitle(ydoc: Y.Doc, yTitle: Y.Text): HTMLElement {
-  const wrapper = document.createElement("div");
-  wrapper.className = "poll-title-wrapper";
-
-  const input = document.createElement("input");
-  input.type = "text";
-  input.id = "poll-title";
-  input.className = "poll-title-input";
-  input.placeholder = "Untitled Poll";
-  input.maxLength = 120;
-  input.setAttribute("aria-label", "Poll title");
-  input.value = yTitle.toString();
-
-  wrapper.appendChild(input);
-
-  // Sync from Yjs → input (only when not focused to avoid cursor jump)
-  yTitle.observe(() => {
-    if (document.activeElement !== input) {
-      input.value = yTitle.toString();
-    }
-  });
-
-  // Sync from input → Yjs
-  input.addEventListener("input", () => {
-    ydoc.transact(() => {
-      yTitle.delete(0, yTitle.length);
-      yTitle.insert(0, input.value);
-    });
-  });
-
-  return wrapper;
-}

src/components/ShareSection.ts

@@ -1,39 +0,0 @@
-export function ShareSection(roomName: string): HTMLElement {
-  const url = `${window.location.origin}${window.location.pathname}?room=${encodeURIComponent(roomName)}`;
-
-  const section = document.createElement("div");
-  section.className = "share-section";
-
-  section.innerHTML = `
-    <p class="share-label">Share this poll</p>
-    <div class="share-row">
-      <code class="share-url" title="${url}">${url}</code>
-      <button class="share-copy-btn">Copy link</button>
-    </div>
-  `;
-
-  const copyBtn = section.querySelector<HTMLButtonElement>(".share-copy-btn")!;
-
-  copyBtn.addEventListener("click", async () => {
-    try {
-      await navigator.clipboard.writeText(url);
-      copyBtn.textContent = "Copied!";
-      copyBtn.classList.add("share-copy-btn--success");
-      setTimeout(() => {
-        copyBtn.textContent = "Copy link";
-        copyBtn.classList.remove("share-copy-btn--success");
-      }, 2000);
-    } catch {
-      // Fallback: select the text
-      const range = document.createRange();
-      const urlEl = section.querySelector(".share-url");
-      if (urlEl) {
-        range.selectNode(urlEl);
-        window.getSelection()?.removeAllRanges();
-        window.getSelection()?.addRange(range);
-      }
-    }
-  });
-
-  return section;
-}

src/components/StatusBar.ts

@@ -1,67 +0,0 @@
-import type { WebrtcProvider } from "y-webrtc";
-
-export function StatusBar(provider: WebrtcProvider): HTMLElement {
-  const el = document.createElement("div");
-  el.className = "status-bar";
-
-  const dot = document.createElement("span");
-  dot.className = "status-dot connecting";
-
-  const statusText = document.createElement("span");
-  statusText.className = "status-text";
-  statusText.textContent = "Connecting";
-
-  const divider = document.createElement("span");
-  divider.className = "status-divider";
-  divider.textContent = "\u00b7";
-
-  const peerText = document.createElement("span");
-  peerText.className = "status-peers";
-
-  el.append(dot, statusText, divider, peerText);
-
-  // --- Connection state ---
-
-  let syncTimeout: ReturnType<typeof setTimeout> | undefined = setTimeout(() => {
-    statusText.textContent = "Ready";
-    dot.className = "status-dot ready";
-  }, 3000);
-
-  provider.on("synced", ({ synced }: { synced: boolean }) => {
-    if (syncTimeout) {
-      clearTimeout(syncTimeout);
-      syncTimeout = undefined;
-    }
-    dot.className = `status-dot ${synced ? "connected" : "connecting"}`;
-    statusText.textContent = synced ? "Connected" : "Connecting";
-  });
-
-  // Online/offline awareness
-  const handleOffline = () => {
-    dot.className = "status-dot connecting";
-    statusText.textContent = "Offline";
-  };
-  const handleOnline = () => {
-    dot.className = "status-dot connecting";
-    statusText.textContent = "Reconnecting";
-  };
-
-  window.addEventListener("offline", handleOffline);
-  window.addEventListener("online", handleOnline);
-
-  // --- Peer count ---
-
-  function updatePeerCount() {
-    const total = provider.awareness.getStates().size;
-    const others = total - 1;
-    peerText.textContent =
-      others === 0
-        ? "Only you"
-        : `${others} other${others !== 1 ? "s" : ""}`;
-  }
-
-  provider.awareness.on("change", updatePeerCount);
-  updatePeerCount();
-
-  return el;
-}

src/identity.ts

@@ -1,17 +0,0 @@
-const USER_ID_KEY = "polly:user-id";
-
-function createUserId(): string {
-  if (typeof crypto.randomUUID === "function") {
-    return crypto.randomUUID();
-  }
-  return `user-${Math.random().toString(36).slice(2, 10)}`;
-}
-
-export function getUserId(): string {
-  const existing = localStorage.getItem(USER_ID_KEY);
-  if (existing) return existing;
-
-  const next = createUserId();
-  localStorage.setItem(USER_ID_KEY, next);
-  return next;
-}

src/main.ts

@@ -1,9 +0,0 @@
-import "./styles.css";
-import { initApp } from "./app";
-
-const container = document.querySelector<HTMLElement>("#app");
-if (!container) {
-  throw new Error("App container not found.");
-}
-
-initApp(container);

src/state.ts

@@ -1,207 +0,0 @@
-import * as Y from "yjs";
-
-// --- Types ---
-
-export type ConnectionStatus = "connecting" | "connected" | "offline";
-
-export interface OptionRecord {
-  id: string;
-  label: string;
-  createdAt: number;
-  createdBy: string;
-}
-
-export interface PollOptionViewModel extends OptionRecord {
-  voteCount: number;
-  isVotedByMe: boolean;
-  percentage: number;
-}
-
-export interface PollViewModel {
-  title: string;
-  roomId: string;
-  shareUrl: string;
-  connectionStatus: ConnectionStatus;
-  peerCount: number;
-  options: PollOptionViewModel[];
-  totalVotes: number;
-  myVoteOptionId: string | null;
-  deadline: number | null;
-  votingClosed: boolean;
-}
-
-// --- Helpers ---
-
-export function createOptionId(): string {
-  if (typeof crypto.randomUUID === "function") {
-    return crypto.randomUUID();
-  }
-  return `option-${Math.random().toString(36).slice(2, 10)}`;
-}
-
-function normalizeLabel(label: string): string {
-  return label.trim().replace(/\s+/g, " ");
-}
-
-export function escapeHtml(value: string): string {
-  return value
-    .replaceAll("&", "&")
-    .replaceAll("<", "&lt;")
-    .replaceAll(">", "&gt;")
-    .replaceAll('"', "&quot;")
-    .replaceAll("'", "&#39;");
-}
-
-// --- Title ---
-
-export function getPollTitle(yTitle: Y.Text): string {
-  const title = yTitle.toString();
-  return title || "Untitled Poll";
-}
-
-// --- Options ---
-
-export function addOption(
-  options: Y.Map<OptionRecord>,
-  rawLabel: string,
-  userId: string,
-): { ok: true; optionId: string } | { ok: false; error: string } {
-  const label = normalizeLabel(rawLabel);
-  if (!label) {
-    return { ok: false, error: "Option cannot be empty." };
-  }
-
-  const normalizedTarget = label.toLocaleLowerCase();
-  const duplicate = Array.from(options.values()).some(
-    (option) => option.label.trim().toLocaleLowerCase() === normalizedTarget,
-  );
-
-  if (duplicate) {
-    return { ok: false, error: "That option already exists." };
-  }
-
-  const option: OptionRecord = {
-    id: createOptionId(),
-    label,
-    createdAt: Date.now(),
-    createdBy: userId,
-  };
-
-  options.set(option.id, option);
-  return { ok: true, optionId: option.id };
-}
-
-export function toggleVote(
-  votes: Y.Map<string>,
-  userId: string,
-  optionId: string,
-): void {
-  const current = votes.get(userId);
-  if (current === optionId) {
-    votes.delete(userId);
-  } else {
-    votes.set(userId, optionId);
-  }
-}
-
-export function deleteOption(
-  options: Y.Map<OptionRecord>,
-  votes: Y.Map<string>,
-  optionId: string,
-): void {
-  options.delete(optionId);
-  // Clean up votes pointing to this option
-  for (const [userId, votedOptionId] of votes.entries()) {
-    if (votedOptionId === optionId) {
-      votes.delete(userId);
-    }
-  }
-}
-
-// --- Deadline ---
-
-export function setDeadline(
-  deadlineMap: Y.Map<unknown>,
-  durationMs: number,
-): void {
-  deadlineMap.set("deadline", Date.now() + durationMs);
-}
-
-export function clearDeadline(deadlineMap: Y.Map<unknown>): void {
-  deadlineMap.delete("deadline");
-}
-
-export function getDeadline(deadlineMap: Y.Map<unknown>): number | null {
-  const val = deadlineMap.get("deadline");
-  return typeof val === "number" ? val : null;
-}
-
-// --- ViewModel ---
-
-export function createViewModel(params: {
-  yTitle: Y.Text;
-  options: Y.Map<OptionRecord>;
-  votes: Y.Map<string>;
-  deadlineMap: Y.Map<unknown>;
-  roomId: string;
-  shareUrl: string;
-  connectionStatus: ConnectionStatus;
-  peerCount: number;
-  userId: string;
-}): PollViewModel {
-  const {
-    yTitle,
-    options,
-    votes,
-    deadlineMap,
-    roomId,
-    shareUrl,
-    connectionStatus,
-    peerCount,
-    userId,
-  } = params;
-
-  // Tally votes per option
-  const tally = new Map<string, number>();
-  for (const optionId of votes.values()) {
-    tally.set(optionId, (tally.get(optionId) ?? 0) + 1);
-  }
-
-  let totalVotes = 0;
-  for (const count of tally.values()) {
-    totalVotes += count;
-  }
-
-  const myVoteOptionId = votes.get(userId) ?? null;
-  const deadline = getDeadline(deadlineMap);
-  const votingClosed = deadline !== null && Date.now() >= deadline;
-
-  // Sort by votes desc, then alphabetically
-  const sortedOptions = Array.from(options.values()).sort((a, b) => {
-    const aVotes = tally.get(a.id) ?? 0;
-    const bVotes = tally.get(b.id) ?? 0;
-    if (bVotes !== aVotes) return bVotes - aVotes;
-    return a.label.localeCompare(b.label);
-  });
-
-  return {
-    title: getPollTitle(yTitle),
-    roomId,
-    shareUrl,
-    connectionStatus,
-    peerCount,
-    myVoteOptionId,
-    totalVotes,
-    deadline,
-    votingClosed,
-    options: sortedOptions.map((option) => ({
-      ...option,
-      voteCount: tally.get(option.id) ?? 0,
-      isVotedByMe: myVoteOptionId === option.id,
-      percentage:
-        totalVotes > 0
-          ? Math.round(((tally.get(option.id) ?? 0) / totalVotes) * 100)
-          : 0,
-    })),
-  };
-}

src/styles.css

@@ -1,469 +0,0 @@
-/* ── Fonts ─────────────────────────────────────────────── */
-@import url('https://fonts.googleapis.com/css2?family=DM+Sans:wght@300;400;500;600&family=Playfair+Display:wght@500&display=swap');
-
-/* ── Tokens ────────────────────────────────────────────── */
-:root {
-  --bg:            #F7F6F2;
-  --surface:       #FFFFFF;
-  --surface-hover: #FAFAF8;
-  --border:        #E8E5DF;
-  --border-focus:  #1A1A1A;
-
-  --text-primary:   #1A1A1A;
-  --text-secondary: #6B6860;
-  --text-muted:     #AAA79F;
-
-  --accent:         #1A1A1A;
-  --accent-text:    #FFFFFF;
-
-  --vote-bar:       rgba(26, 26, 26, 0.07);
-  --vote-bar-voted: rgba(26, 26, 26, 0.12);
-
-  --success:        #2D7D46;
-  --danger:         #C0392B;
-  --warning:        #8c5300;
-
-  --radius-sm:  6px;
-  --radius-md:  10px;
-  --radius-lg:  14px;
-
-  --font-display: 'Playfair Display', Georgia, serif;
-  --font-body:    'DM Sans', system-ui, sans-serif;
-
-  --shadow-card: 0 1px 3px rgba(0,0,0,0.06), 0 4px 16px rgba(0,0,0,0.05);
-}
-
-/* ── Reset ─────────────────────────────────────────────── */
-*, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
-
-/* ── Base ──────────────────────────────────────────────── */
-html { font-size: 16px; }
-
-body {
-  font-family: var(--font-body);
-  background: var(--bg);
-  color: var(--text-primary);
-  min-height: 100vh;
-  -webkit-font-smoothing: antialiased;
-}
-
-button, input { font: inherit; }
-button { cursor: pointer; }
-
-/* ── Layout ────────────────────────────────────────────── */
-#app {
-  max-width: 580px;
-  margin: 0 auto;
-  padding: 2rem 1.25rem 4rem;
-  display: flex;
-  flex-direction: column;
-  gap: 1.25rem;
-}
-
-/* ── Header ────────────────────────────────────────────── */
-.app-header {
-  display: flex;
-  align-items: center;
-  justify-content: space-between;
-  padding: 0 0.25rem;
-}
-
-.app-wordmark {
-  display: flex;
-  align-items: center;
-  gap: 0.5rem;
-  font-family: var(--font-display);
-  font-size: 1.1rem;
-  color: var(--text-primary);
-  letter-spacing: -0.01em;
-}
-
-/* ── Status bar ────────────────────────────────────────── */
-.status-bar {
-  display: flex;
-  align-items: center;
-  gap: 0.4rem;
-  font-size: 0.8rem;
-  color: var(--text-secondary);
-}
-
-.status-dot {
-  width: 6px;
-  height: 6px;
-  border-radius: 50%;
-  flex-shrink: 0;
-  transition: background 0.3s;
-}
-
-.status-dot.connecting { background: var(--text-muted); }
-.status-dot.ready      { background: var(--text-muted); }
-.status-dot.connected  { background: var(--success); }
-
-.status-divider { color: var(--text-muted); }
-
-/* ── Card ──────────────────────────────────────────────── */
-.app-card {
-  background: var(--surface);
-  border: 1px solid var(--border);
-  border-radius: var(--radius-lg);
-  box-shadow: var(--shadow-card);
-  overflow: hidden;
-}
-
-/* ── Poll Title ────────────────────────────────────────── */
-.poll-title-wrapper {
-  padding: 1.75rem 1.75rem 1.25rem;
-  border-bottom: 1px solid var(--border);
-}
-
-.poll-title-input {
-  width: 100%;
-  font-family: var(--font-display);
-  font-size: 1.5rem;
-  font-weight: 500;
-  color: var(--text-primary);
-  background: transparent;
-  border: none;
-  outline: none;
-  line-height: 1.3;
-  letter-spacing: -0.02em;
-}
-
-.poll-title-input::placeholder { color: var(--text-muted); }
-
-/* ── Add Option ────────────────────────────────────────── */
-.add-option-wrapper {
-  display: flex;
-  flex-wrap: wrap;
-  gap: 0.625rem;
-  padding: 1.25rem 1.75rem;
-  border-bottom: 1px solid var(--border);
-}
-
-.add-option-input {
-  flex: 1;
-  min-width: 0;
-  height: 2.5rem;
-  padding: 0 0.875rem;
-  font-size: 0.9rem;
-  color: var(--text-primary);
-  background: var(--bg);
-  border: 1px solid var(--border);
-  border-radius: var(--radius-sm);
-  outline: none;
-  transition: border-color 0.15s;
-}
-
-.add-option-input::placeholder { color: var(--text-muted); }
-.add-option-input:focus { border-color: var(--border-focus); }
-
-.add-option-input.shake {
-  animation: shake 0.3s ease;
-}
-
-@keyframes shake {
-  0%, 100% { transform: translateX(0); }
-  25%       { transform: translateX(-4px); }
-  75%       { transform: translateX(4px); }
-}
-
-.add-option-btn {
-  display: flex;
-  align-items: center;
-  gap: 0.375rem;
-  height: 2.5rem;
-  padding: 0 1rem;
-  font-size: 0.875rem;
-  font-weight: 500;
-  color: var(--accent-text);
-  background: var(--accent);
-  border: none;
-  border-radius: var(--radius-sm);
-  transition: opacity 0.15s;
-  white-space: nowrap;
-}
-
-.add-option-btn:hover { opacity: 0.85; }
-.add-option-btn:active { opacity: 0.7; }
-
-.add-option-feedback {
-  width: 100%;
-  font-size: 0.8rem;
-  color: var(--danger);
-  display: none;
-}
-
-/* ── Deadline Timer ────────────────────────────────────── */
-.deadline-wrapper {
-  display: flex;
-  align-items: center;
-  gap: 0.75rem;
-  padding: 0.75rem 1.75rem;
-  border-bottom: 1px solid var(--border);
-  font-size: 0.85rem;
-}
-
-.deadline-timer {
-  flex: 1;
-  font-weight: 500;
-}
-
-.deadline-timer--active {
-  color: var(--success);
-}
-
-.deadline-timer--closed {
-  color: var(--danger);
-  font-weight: 600;
-}
-
-.deadline-btn {
-  height: 2rem;
-  padding: 0 0.875rem;
-  font-size: 0.8rem;
-  font-weight: 500;
-  color: var(--text-secondary);
-  background: var(--surface);
-  border: 1px solid var(--border);
-  border-radius: var(--radius-sm);
-  transition: all 0.15s;
-  white-space: nowrap;
-}
-
-.deadline-btn:hover {
-  border-color: var(--accent);
-  color: var(--accent);
-}
-
-.deadline-btn--clear:hover {
-  border-color: var(--danger);
-  color: var(--danger);
-}
-
-/* ── Poll List ─────────────────────────────────────────── */
-.poll-list-wrapper {
-  padding: 0.5rem 0;
-}
-
-.poll-list-meta {
-  padding: 0.5rem 1.75rem 0.75rem;
-  font-size: 0.775rem;
-  color: var(--text-muted);
-  letter-spacing: 0.02em;
-  text-transform: uppercase;
-  font-weight: 500;
-}
-
-.poll-list-empty {
-  padding: 3rem 1.75rem;
-  text-align: center;
-  color: var(--text-muted);
-  font-size: 0.875rem;
-}
-
-.empty-icon {
-  margin-bottom: 0.75rem;
-  opacity: 0.6;
-}
-
-/* ── Poll Option ───────────────────────────────────────── */
-.poll-option {
-  position: relative;
-  overflow: hidden;
-  transition: background 0.15s;
-}
-
-.poll-option:hover {
-  background: var(--surface-hover);
-}
-
-.poll-option__bar {
-  position: absolute;
-  inset: 0 auto 0 0;
-  background: var(--vote-bar);
-  transition: width 0.5s cubic-bezier(0.4, 0, 0.2, 1);
-  pointer-events: none;
-}
-
-.poll-option--voted .poll-option__bar {
-  background: var(--vote-bar-voted);
-}
-
-.poll-option__content {
-  position: relative;
-  display: flex;
-  align-items: center;
-  gap: 0.75rem;
-  padding: 0.875rem 1.75rem;
-}
-
-.poll-option__name {
-  flex: 1;
-  font-size: 0.9375rem;
-  font-weight: 400;
-  color: var(--text-primary);
-  word-break: break-word;
-}
-
-.poll-option--voted .poll-option__name {
-  font-weight: 500;
-}
-
-.poll-option__actions {
-  display: flex;
-  align-items: center;
-  gap: 0.625rem;
-  flex-shrink: 0;
-}
-
-.poll-option__pct {
-  font-size: 0.8125rem;
-  font-weight: 500;
-  color: var(--text-secondary);
-  min-width: 2.5rem;
-  text-align: right;
-}
-
-.poll-option__count {
-  font-size: 0.775rem;
-  color: var(--text-muted);
-  min-width: 3.5rem;
-}
-
-.poll-option__vote-btn {
-  height: 1.875rem;
-  padding: 0 0.875rem;
-  font-size: 0.8125rem;
-  font-weight: 500;
-  border-radius: var(--radius-sm);
-  transition: all 0.15s;
-  white-space: nowrap;
-  background: transparent;
-  color: var(--text-secondary);
-  border: 1px solid var(--border);
-}
-
-.poll-option__vote-btn:hover:not(:disabled) {
-  border-color: var(--accent);
-  color: var(--accent);
-}
-
-.poll-option__vote-btn:disabled {
-  opacity: 0.5;
-  cursor: default;
-}
-
-.poll-option--voted .poll-option__vote-btn {
-  background: var(--accent);
-  color: var(--accent-text);
-  border-color: var(--accent);
-}
-
-.poll-option--voted .poll-option__vote-btn:hover:not(:disabled) {
-  opacity: 0.8;
-}
-
-.poll-option__delete-btn {
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  width: 1.625rem;
-  height: 1.625rem;
-  background: transparent;
-  border: none;
-  border-radius: var(--radius-sm);
-  color: var(--text-muted);
-  opacity: 0;
-  transition: opacity 0.15s, color 0.15s, background 0.15s;
-}
-
-.poll-option:hover .poll-option__delete-btn { opacity: 1; }
-.poll-option__delete-btn:hover {
-  color: var(--danger);
-  background: rgba(192, 57, 43, 0.07);
-}
-
-/* ── Footer ────────────────────────────────────────────── */
-.app-footer {
-  padding: 0 0.25rem;
-}
-
-/* ── Share Section ─────────────────────────────────────── */
-.share-section {
-  background: var(--surface);
-  border: 1px solid var(--border);
-  border-radius: var(--radius-lg);
-  box-shadow: var(--shadow-card);
-  padding: 1.25rem 1.5rem;
-}
-
-.share-label {
-  font-size: 0.775rem;
-  font-weight: 500;
-  color: var(--text-muted);
-  text-transform: uppercase;
-  letter-spacing: 0.05em;
-  margin-bottom: 0.625rem;
-}
-
-.share-row {
-  display: flex;
-  align-items: center;
-  gap: 0.625rem;
-}
-
-.share-url {
-  flex: 1;
-  font-family: 'DM Mono', 'Fira Mono', monospace;
-  font-size: 0.8rem;
-  color: var(--text-secondary);
-  background: var(--bg);
-  border: 1px solid var(--border);
-  border-radius: var(--radius-sm);
-  padding: 0.5rem 0.75rem;
-  overflow: hidden;
-  text-overflow: ellipsis;
-  white-space: nowrap;
-  display: block;
-  user-select: all;
-}
-
-.share-copy-btn {
-  height: 2rem;
-  padding: 0 0.875rem;
-  font-size: 0.8125rem;
-  font-weight: 500;
-  color: var(--text-secondary);
-  background: var(--surface);
-  border: 1px solid var(--border);
-  border-radius: var(--radius-sm);
-  transition: all 0.15s;
-  white-space: nowrap;
-  flex-shrink: 0;
-}
-
-.share-copy-btn:hover {
-  border-color: var(--accent);
-  color: var(--accent);
-}
-
-.share-copy-btn--success {
-  color: var(--success) !important;
-  border-color: var(--success) !important;
-}
-
-/* ── Responsive ────────────────────────────────────────── */
-@media (max-width: 480px) {
-  #app { padding: 1rem 0.75rem 3rem; }
-
-  .poll-title-wrapper  { padding: 1.25rem 1.25rem 1rem; }
-  .add-option-wrapper  { padding: 1rem 1.25rem; }
-  .poll-option__content { padding: 0.875rem 1.25rem; }
-  .poll-list-meta      { padding: 0.5rem 1.25rem 0.625rem; }
-  .poll-list-empty     { padding: 2.5rem 1.25rem; }
-  .deadline-wrapper    { padding: 0.75rem 1.25rem; }
-
-  .poll-option__count  { display: none; }
-
-  .share-section { padding: 1rem 1.25rem; }
-}

src/sync.ts

@@ -1,77 +0,0 @@
-import { IndexeddbPersistence } from "y-indexeddb";
-import { WebrtcProvider } from "y-webrtc";
-import * as Y from "yjs";
-
-import type { ConnectionStatus, OptionRecord } from "./state";
-
-export interface AppSync {
-  doc: Y.Doc;
-  yTitle: Y.Text;
-  options: Y.Map<OptionRecord>;
-  votes: Y.Map<string>;
-  deadlineMap: Y.Map<unknown>;
-  provider: WebrtcProvider;
-  persistence: IndexeddbPersistence;
-  getConnectionStatus: () => ConnectionStatus;
-  getPeerCount: () => number;
-  destroy: () => void;
-}
-
-export function initSync(roomId: string): AppSync {
-  const doc = new Y.Doc();
-  const yTitle = doc.getText("poll-title");
-  const options = doc.getMap<OptionRecord>("poll-options");
-  const votes = doc.getMap<string>("poll-votes");
-  const deadlineMap = doc.getMap<unknown>("poll-deadline");
-
-  let connectionStatus: ConnectionStatus = navigator.onLine
-    ? "connecting"
-    : "offline";
-
-  const provider = new WebrtcProvider(roomId, doc);
-  const persistence = new IndexeddbPersistence(roomId, doc);
-
-  const syncConnectionStatus = (status: ConnectionStatus) => {
-    connectionStatus = navigator.onLine ? status : "offline";
-  };
-
-  const handleOnline = () => {
-    syncConnectionStatus(provider.connected ? "connected" : "connecting");
-  };
-  const handleOffline = () => {
-    connectionStatus = "offline";
-  };
-
-  provider.on("status", (event: { connected: boolean }) => {
-    syncConnectionStatus(event.connected ? "connected" : "connecting");
-  });
-
-  provider.on("synced", ({ synced }: { synced: boolean }) => {
-    if (synced) syncConnectionStatus("connected");
-  });
-
-  window.addEventListener("online", handleOnline);
-  window.addEventListener("offline", handleOffline);
-
-  return {
-    doc,
-    yTitle,
-    options,
-    votes,
-    deadlineMap,
-    provider,
-    persistence,
-    getConnectionStatus: () => connectionStatus,
-    getPeerCount: () => {
-      const total = provider.awareness.getStates().size;
-      return Math.max(0, total - 1);
-    },
-    destroy: () => {
-      window.removeEventListener("online", handleOnline);
-      window.removeEventListener("offline", handleOffline);
-      persistence.destroy();
-      provider.destroy();
-      doc.destroy();
-    },
-  };
-}

tsconfig.json

@@ -1,15 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "ESNext",
-    "moduleResolution": "Bundler",
-    "lib": ["DOM", "DOM.Iterable", "ES2022"],
-    "strict": true,
-    "noEmit": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "allowSyntheticDefaultImports": true,
-    "useDefineForClassFields": true
-  },
-  "include": ["src"]
-}