add proposal

.gitignore

@@ -1 +1,3 @@
-node_modules/
+node_modules
+dist
+.DS_Store

MVP_PLAN.md

@@ -0,0 +1,310 @@
+# Minimal MVP Plan: P2P Poll App
+
+## Recommendation
+
+Build the MVP with:
+
+- Vanilla JS or TypeScript
+- Vite for local dev/build
+- Yjs for shared state
+- `y-webrtc` for browser-to-browser sync
+- `y-indexeddb` for local persistence/offline recovery
+
+This is the best fit for a small poll app because the data model is tiny, concurrent edits are possible, and Yjs already solves merge/conflict handling while `y-webrtc` gives a direct P2P transport with only signaling infrastructure.
+
+## Why This Stack
+
+### Recommended: Yjs + y-webrtc
+
+- Best balance of simplicity and correctness
+- Clients connect directly over WebRTC
+- No custom conflict-resolution logic needed
+- Easy to add offline persistence
+- Good fit for a single shared document/room
+
+### Not recommended for the first MVP
+
+#### PeerJS
+
+- Very simple transport layer
+- But you must design and maintain your own replication and merge rules
+- Fine for demos with a host-authoritative peer, weaker for true collaborative editing
+
+#### GUN
+
+- Fast to prototype realtime shared state
+- But official tutorials commonly use a GUN peer/relay server for shared data
+- For this app, its data model is less explicit than a CRDT and gives less control over vote semantics
+
+#### Automerge
+
+- Very capable CRDT and local-first model
+- But heavier than needed for a single small poll
+- Better choice if the project is expected to evolve into a richer collaborative app
+
+## MVP Scope
+
+Ship exactly one shared poll per room.
+
+Included:
+
+- Join a poll by opening a shared URL
+- Add a new option
+- Vote for one option
+- Change your vote
+- Realtime updates across peers
+- Local persistence in the browser
+- Basic connection status UI
+
+Excluded:
+
+- User accounts
+- Multiple polls per room
+- Option deletion/editing
+- Authentication/authorization
+- Rich presence
+- Advanced discovery
+- Production-grade TURN/signaling deployment
+
+## MVP UX
+
+Keep the interface intentionally small:
+
+- Poll title at the top
+- Option list with vote counts
+- One button per option to cast vote
+- Small form to add an option
+- Status line showing `connecting`, `connected`, or `offline`
+- Small label showing which option you voted for
+
+Join model:
+
+- Room ID in the URL, e.g. `/?room=poll-demo`
+- Users share the URL manually
+
+Identity model:
+
+- Generate a local `userId` once and store it in `localStorage`
+- Optional local display name, also stored locally
+
+## Shared Data Model
+
+Use a single Yjs document per room.
+
+Suggested structure:
+
+- `poll` as a `Y.Map`
+- `poll.title` as a string
+- `poll.options` as a `Y.Map<optionId, Y.Map>`
+- `poll.votes` as a `Y.Map<userId, optionId>`
+
+Each option record:
+
+- `id`
+- `label`
+- `createdBy`
+- `createdAt`
+
+Important design choice:
+
+Do not store vote counters as mutable shared numbers for the MVP.
+Instead, derive counts from `votes`.
+
+Why:
+
+- A user changing vote becomes a single write: `votes[userId] = optionId`
+- No double-counting logic
+- Concurrent writes are easier to reason about
+- Rendering counts from `votes` is trivial at this scale
+
+## Sync Model
+
+### Networking
+
+- Use `WebrtcProvider(roomId, ydoc)`
+- Start with the default public signaling servers for local development
+- If needed, swap to a self-hosted signaling server later without changing the app model
+
+### Persistence
+
+- Use `IndexeddbPersistence(roomId, ydoc)`
+- This preserves state across reloads and helps when reconnecting after temporary disconnects
+
+### Conflict behavior
+
+- Concurrent option additions merge naturally
+- Concurrent vote changes resolve at the per-user key level
+- Tally is recalculated from the merged vote map
+
+## Suggested Project Structure
+
+```text
+src/
+  main.ts
+  app.ts
+  state.ts
+  sync.ts
+  render.ts
+  identity.ts
+  styles.css
+index.html
+```
+
+Responsibilities:
+
+- `sync.ts`: create Yjs doc, WebRTC provider, IndexedDB provider
+- `state.ts`: shared structures, add option, cast vote, selectors
+- `identity.ts`: local `userId` and optional name
+- `render.ts`: DOM updates
+- `app.ts`: wire events to state and rendering
+
+## Implementation Plan
+
+### Phase 1: App shell
+
+- Create Vite app with vanilla TS or JS
+- Add a minimal single-page UI
+- Parse `room` from the URL
+- Generate and persist `userId`
+
+Success check:
+
+- App loads
+- Room ID appears in UI
+- User can type in the form
+
+### Phase 2: Shared state
+
+- Add Yjs document
+- Create root shared maps
+- Seed default poll title if missing
+- Observe document updates and re-render UI
+
+Success check:
+
+- State exists in one browser tab
+- Refresh keeps local state when IndexedDB is enabled
+
+### Phase 3: P2P sync
+
+- Add `y-webrtc`
+- Join room based on URL room ID
+- Show connection status from provider events
+
+Success check:
+
+- Two browsers on different tabs/devices see the same options
+- New options appear in near real time
+
+### Phase 4: Voting logic
+
+- Implement `castVote(optionId)` as `votes.set(userId, optionId)`
+- Derive tallies from `votes`
+- Highlight the local user’s current vote
+
+Success check:
+
+- Votes update live across peers
+- Changing vote updates counts correctly
+
+### Phase 5: Basic hardening
+
+- Trim/validate option labels
+- Prevent empty options
+- Ignore duplicate labels case-insensitively for MVP
+- Show simple offline/connecting text
+
+Success check:
+
+- Basic misuse does not break the UI
+- Reconnect restores updates
+
+## Minimal API Surface
+
+These functions are enough for the first build:
+
+- `getRoomId(): string`
+- `getUserId(): string`
+- `initSync(roomId): AppSync`
+- `ensurePollInitialized()`
+- `addOption(label: string)`
+- `castVote(optionId: string)`
+- `getViewModel(): PollViewModel`
+- `render(viewModel)`
+
+## Risks And MVP Mitigations
+
+### NAT / WebRTC connectivity
+
+Risk:
+
+- Some peer pairs may fail to connect in restrictive networks
+
+Mitigation:
+
+- Accept this for MVP
+- Keep signaling configurable
+- Add TURN only if testing shows frequent failures
+
+### Small public signaling dependency
+
+Risk:
+
+- Public signaling is fine for demos, not ideal for production
+
+Mitigation:
+
+- Treat it as replaceable infrastructure
+- Self-host later if the prototype is kept
+
+### Duplicate or messy options
+
+Risk:
+
+- Users may add near-duplicate entries
+
+Mitigation:
+
+- Normalize labels
+- Prevent exact duplicates for MVP
+
+### No trust/auth model
+
+Risk:
+
+- Any participant in the room can add options and vote
+
+Mitigation:
+
+- Accept for MVP
+- Frame rooms as small trusted groups
+
+## Estimated MVP Size
+
+For one developer:
+
+- Initial prototype: 0.5 to 1 day
+- Polished MVP with basic resilience: 1 to 2 days
+
+Rough code size:
+
+- 250 to 500 lines plus styles
+
+## Nice Next Steps After MVP
+
+- Copy-link button
+- Participant list / presence
+- Vote limit modes: single-choice or multi-choice
+- Option editing/deletion
+- QR code for room join
+- Self-hosted signaling server
+- PWA packaging for better offline behavior
+
+## Sources
+
+- PeerJS getting started: https://peerjs.com/client/getting-started
+- Yjs collaborative editor guide: https://docs.yjs.dev/getting-started/a-collaborative-editor
+- Yjs offline support: https://docs.yjs.dev/getting-started/allowing-offline-editing
+- y-webrtc README: https://github.com/yjs/y-webrtc
+- GUN tutorial showing shared data via a GUN peer: https://gun.eco/converse
+- Automerge network sync: https://automerge.org/docs/tutorial/network-sync/

README.md

@@ -1,28 +1,39 @@
-# P2P Poll App
+# P2P Poll App
-
+
-## Install npm packages
+Small peer-to-peer polling app built with `Vite`, `TypeScript`, `Yjs`, `y-webrtc`, and `y-indexeddb`.
-```
+
-npm init -y
+## Features
-npm install
+
-```
+- single shared poll per room
-
+- add options collaboratively
-Note: the frontend obtains the packages `yjs` and `y-websocket` dynamically.
+- one vote per user, changeable at any time
-
+- peer-to-peer sync over WebRTC
-## Run backend
+- local browser persistence for refresh/reconnect recovery
-```
+- shareable room URL
-node backend.js
+
-```
+## Run locally
-
+
-### Note on Yjs suggestion
+```bash
-Note that the following server setup is suggested in the Yjs docs (https://docs.yjs.dev/ecosystem/connection-provider/y-websocket):
+npm install
-```
+npm run dev
-npm install y-websocket-server
+```
-HOST=localhost PORT=1000 npx y-websocket
+
-```
+Open the local URL in two tabs or browsers and use the same `?room=` query string to join the same poll.
-
+
-However, across a range of npm versions, this does not work.
+Example:
-Nevertheless, the essential code from the `y-websocket-server` package is used here as provided in `utils.js`.
+
-
+```text
-## Run frontend
+http://localhost:5173/?room=poll-demo
-Open "frontend.html" in browser.
+```
-
+
+## Build
+
+```bash
+npm run build
+```
+
+## Notes
+
+- The app uses public signaling through `y-webrtc` for MVP simplicity.
+- Poll state is not stored on an application server.
+- WebRTC connectivity can still depend on the network environment of the participating peers.

backend.js

@@ -1,31 +0,0 @@
-import { WebSocketServer } from 'ws';
-import { setupWSConnection } from './utils.js'
-
-// Create a WebSocket server
-const WS_PORT = 8080;
-const wss = new WebSocketServer({ port: WS_PORT });
-
-console.log('WebSocket server is running on ws://localhost:' + String(WS_PORT));
-
-// Connection event handler
-wss.on('connection', setupWSConnection);
-/*
-wss.on('connection', (ws) => {
-  console.log('Client connected');
-
-  // Message event handler
-  ws.on('message', (message) => {
-    let msg_str = String(message);
-    console.log("Received: " + msg_str);
-    
-    // If this is a text or state message (no Yjs logic) - echo the message back to the client
-    if (msg_str.startsWith("TEXT_MESSAGE") | msg_str.startsWith("STATE_MESSAGE")) {
-      ws.send(msg_str);
-    }
-  });
-
-  // Close event handler
-  ws.on('close', () => {
-    console.log('Client disconnected');
-  });
-});*/

frontend.html

@@ -1,196 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-  <title>Poll Client</title>
-  <style>
-    body {
-      font-family: Arial, sans-serif;
-      max-width: 600px;
-      margin: 0 auto;
-      padding: 20px;
-    }
-    #messages {
-      height: 300px;
-      border: 1px solid #ccc;
-      overflow-y: auto;
-      padding: 10px;
-      margin-bottom: 10px;
-    }
-    .message { margin: 5px 0; }
-  </style>
-</head>
-<body>
-  <h1>Poll Client</h1>
-  <div id="status">Connecting to server...</div>
-  <div id="status2">Connecting to server...</div>
-  <div id="messages"></div>
-  <div>
-    <input type="text" id="messageInput" placeholder="Type your message">
-    <!--button onclick="sendMessage()">Send</button-->
-    <button id="sendBtn">Send</button>
-    <input id="optionInput" placeholder="Add option">
-    <button id="addBtn">Add</button>
-    <ul id="options"></ul>
-  </div>
-
-  <script type="module">
-    import * as Y from "https://esm.sh/yjs"
-    import { WebsocketProvider } from "https://esm.sh/y-websocket"
-
-    const WS_PORT = 8080;
-    const ydoc = new Y.Doc();
-    const status = document.getElementById('status');
-    const status2 = document.getElementById('status2');
-    const messages = document.getElementById('messages');
-    const messageInput = document.getElementById('messageInput');
-
-    // Connect to the backend (WebSocket server) via Yjs WebsocketProvider
-    const wsp = new WebsocketProvider(
-      'ws://localhost:' + String(WS_PORT), 'poll-room',
-      ydoc
-    )
-    wsp.on('status', event => {
-      //console.log("event.status =", event.status)
-      if (event.status == "connected") {
-        status.textContent = 'Yjs connected to WebSocket server';
-        status.style.color = 'green';
-      }
-      else {
-        status.textContent = 'Yjs disonnected from WebSocket server';
-        status.style.color = 'red';
-      }
-    })
-    wsp.onopen = () => {
-      console.log('connected to y-websocket server');
-    };
-    ydoc.on('update', () => {
-      console.log('Yjs document updated locally');
-    });
-    wsp.on('sync', isSynced => {
-      console.log("isSynced =", isSynced)
-    })
-
-    // Connect to the backend (WebSocket server) via common WebSocket (only for informative messages)
-    const ws = new WebSocket('ws://localhost:' + String(WS_PORT));
-    ws.onopen = () => {
-      status2.textContent = 'WebSocket client connected to WebSocket server';
-      status2.style.color = 'green';
-    };
-    ws.onmessage = (event) => {
-      const message = document.createElement('div');
-      message.className = 'message';
-      message.textContent = event.data;
-      messages.appendChild(message);
-      messages.scrollTop = messages.scrollHeight;
-    };
-    ws.onerror = (error) => {
-      status2.textContent = 'Error: ' + error.message;
-      status2.style.color = 'red';
-    };
-    ws.onclose = () => {
-      status2.textContent = 'WebSocket client disconnected from WebSocket server';
-      status2.style.color = 'red';
-    };
-
-    // Function to send a message
-    function sendMessage(command, payload) {
-        let message = "";
-        if (command === "TEXT_MESSAGE") {
-            message = command + ":" + messageInput.value.trim();
-            messageInput.value = "";
-        }
-        else if (command.startsWith("STATE_MESSAGE--")) {
-            message = command + ":" + payload;
-        }
-        else {
-            console.log("Error: unknown command '" + command + "'")
-        }
-
-        if (message) {
-            /* To make compatible with y-websocket-server API:
-            const encoder = encoding.createEncoder()
-            encoding.writeVarUint(encoder, messageTextMessage)
-            syncProtocol.writeUpdate(encoder, update)
-            enc_message = encoding.toUint8Array(encoder)*/
-            ws.send(message);
-        }
-    }
-
-     // Send message on button click
-    document.getElementById("sendBtn").onclick = () => {
-        sendMessage("TEXT_MESSAGE", "");
-    };
-
-    // Send message on Enter key
-    messageInput.addEventListener('keypress', (e) => {
-      if (e.key === 'Enter') {
-        sendMessage("TEXT_MESSAGE", "");
-      }
-    });
-    
-    // Actual poll logic
-    const optionsMap = ydoc.getMap("options");
-
-    const optionsList = document.getElementById("options");
-    const input = document.getElementById("optionInput");
-
-    function render() {
-        optionsList.innerHTML = ""
-
-        optionsMap.forEach((vote, name) => {
-            // List element for this option
-            const li = document.createElement("li")
-
-            // Label for this option
-            const label = document.createElement("span")
-            label.textContent = name + " — " + vote + " "
-
-            // "Vote"/"Unvote" button
-            const voteBtn = document.createElement("button")
-            if (vote == false) {
-                voteBtn.textContent = "Vote"
-            }
-            else {
-                voteBtn.textContent = "Unvote"
-            }
-            voteBtn.onclick = () => {
-                vote = !vote;
-                optionsMap.set(name, vote);
-                sendMessage("STATE_MESSAGE--" + (vote ? "VOTE" : "UNVOTE"), name);
-            }
-
-            // "Remove" button
-            const removeBtn = document.createElement("button")
-            removeBtn.textContent = "Remove"
-            removeBtn.onclick = () => {
-                optionsMap.delete(name);
-                sendMessage("STATE_MESSAGE--REMOVE", name);
-            }
-
-            li.appendChild(label)
-            li.appendChild(voteBtn)
-            li.appendChild(removeBtn)
-
-            optionsList.appendChild(li)
-        })
-    };
-
-    document.getElementById("addBtn").onclick = () => {
-        const name = input.value.trim()
-
-        if (!name) return
-
-        if (!optionsMap.has(name)) {
-            optionsMap.set(name, false);
-            sendMessage("STATE_MESSAGE--ADD_OPTION", name);
-        }
-
-        input.value = ""
-    };
-
-    optionsMap.observe(render);
-
-    render();
-  </script>
-</body>
-</html>

index.html

@@ -0,0 +1,12 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>P2P Poll</title>
+  </head>
+  <body>
+    <div id="app"></div>
+    <script type="module" src="/src/main.ts"></script>
+  </body>
+</html>

package.json

@@ -1,20 +1,20 @@
 {
-  "name": "yjs-poll",
+  "name": "p2p-poll-app",
-  "version": "1.0.0",
+  "version": "0.1.0",
-  "main": "index.js",
+  "private": true,
   "type": "module",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
+    "dev": "vite",
-    "y-websocket": "y-websocket"
+    "build": "tsc --noEmit && vite build",
+    "preview": "vite preview"
   },
-  "keywords": [],
-  "author": "",
-  "license": "ISC",
-  "description": "",
   "dependencies": {
-    "ws": "^8.19.0",
+    "y-indexeddb": "^9.0.12",
-    "@y/protocols": "^1.0.6-1",
+    "y-webrtc": "^10.3.0",
-    "lib0": "^0.2.102",
+    "yjs": "^13.6.27"
-    "yjs": "^14.0.0-7"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.2",
+    "vite": "^7.1.5"
   }
 }

src/app.ts

@@ -0,0 +1,107 @@
+import { getUserId } from "./identity";
+import { renderApp } from "./render";
+import { addOption, castVote, createViewModel } from "./state";
+import { initSync } from "./sync";
+
+const ROOM_PARAM = "room";
+
+function createRoomId() {
+  const seed = typeof crypto.randomUUID === "function"
+    ? crypto.randomUUID().slice(0, 8)
+    : Math.random().toString(36).slice(2, 10);
+
+  return `poll-${seed}`;
+}
+
+function ensureRoomId() {
+  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) {
+  const roomId = ensureRoomId();
+  const userId = getUserId();
+  const sync = initSync(roomId);
+  let feedbackMessage = "Ready to collaborate.";
+  let feedbackTimer: number | undefined;
+
+  const setFeedbackMessage = (message: string) => {
+    feedbackMessage = message;
+    render();
+
+    if (feedbackTimer) {
+      window.clearTimeout(feedbackTimer);
+    }
+
+    feedbackTimer = window.setTimeout(() => {
+      feedbackMessage = "Ready to collaborate.";
+      render();
+    }, 2400);
+  };
+
+  const render = () => {
+    const viewModel = createViewModel({
+      meta: sync.meta,
+      options: sync.options,
+      votes: sync.votes,
+      roomId,
+      shareUrl: window.location.href,
+      connectionStatus: sync.getConnectionStatus(),
+      userId,
+    });
+
+    renderApp(container, viewModel, feedbackMessage, {
+      onSubmitOption: (label) => {
+        const result = addOption(sync.options, label, userId);
+        if (!result.ok) {
+          setFeedbackMessage(result.error);
+          return;
+        }
+
+        setFeedbackMessage("Option added and syncing.");
+      },
+      onVote: (optionId) => {
+        castVote(sync.votes, userId, optionId);
+        setFeedbackMessage("Vote updated.");
+      },
+      onCopyLink: async () => {
+        try {
+          await navigator.clipboard.writeText(window.location.href);
+          setFeedbackMessage("Room link copied.");
+        } catch {
+          setFeedbackMessage("Could not copy the link in this browser.");
+        }
+      },
+    });
+  };
+
+  const rerender = () => render();
+  const observe = () => rerender();
+
+  sync.doc.on("update", observe);
+  sync.persistence.once("synced", rerender);
+  sync.provider.on("status", rerender);
+  window.addEventListener("online", rerender);
+  window.addEventListener("offline", rerender);
+
+  render();
+
+  return () => {
+    if (feedbackTimer) {
+      window.clearTimeout(feedbackTimer);
+    }
+    sync.doc.off("update", observe);
+    sync.provider.off("status", rerender);
+    window.removeEventListener("online", rerender);
+    window.removeEventListener("offline", rerender);
+    sync.destroy();
+  };
+}

src/identity.ts

@@ -0,0 +1,20 @@
+const USER_ID_KEY = "p2p-poll:user-id";
+
+function createUserId() {
+  if (typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+
+  return `user-${Math.random().toString(36).slice(2, 10)}`;
+}
+
+export function getUserId() {
+  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

@@ -0,0 +1,11 @@
+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/render.ts

@@ -0,0 +1,131 @@
+import type { PollViewModel } from "./state";
+
+interface RenderActions {
+  onSubmitOption: (label: string) => void;
+  onVote: (optionId: string) => void;
+  onCopyLink: () => void;
+}
+
+function escapeHtml(value: string) {
+  return value
+    .replaceAll("&", "&")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;")
+    .replaceAll("'", "&#39;");
+}
+
+export function renderApp(
+  container: HTMLElement,
+  viewModel: PollViewModel,
+  feedbackMessage: string,
+  actions: RenderActions,
+) {
+  const optionMarkup = viewModel.options.length
+    ? viewModel.options
+        .map((option) => {
+          const buttonLabel = option.isSelectedByMe ? "Selected" : "Vote";
+          const selectedClass = option.isSelectedByMe ? "option-card selected" : "option-card";
+
+          return `
+            <li class="${selectedClass}">
+              <div class="option-main">
+                <div>
+                  <p class="option-label">${escapeHtml(option.label)}</p>
+                  <p class="option-meta">${option.voteCount} vote${option.voteCount === 1 ? "" : "s"}</p>
+                </div>
+                <button class="vote-button" data-option-id="${option.id}">
+                  ${buttonLabel}
+                </button>
+              </div>
+            </li>
+          `;
+        })
+        .join("")
+    : `
+      <li class="empty-state">
+        No options yet. Add the first one and it will sync to everyone in this room.
+      </li>
+    `;
+
+  const statusClass = `status-pill ${viewModel.connectionStatus}`;
+  const myVoteLabel = viewModel.myVoteOptionId
+    ? "Your vote is currently synced."
+    : "You have not voted yet.";
+
+  container.innerHTML = `
+    <main class="shell">
+      <section class="hero">
+        <div class="hero-copy">
+          <p class="eyebrow">Peer-to-peer room</p>
+          <h1>${escapeHtml(viewModel.title)}</h1>
+          <p class="hero-text">
+            Share the room link, add options, and vote live without a central app server storing poll state.
+          </p>
+        </div>
+        <div class="hero-meta">
+          <span class="${statusClass}">${viewModel.connectionStatus}</span>
+          <p class="room-label">Room: <code>${escapeHtml(viewModel.roomId)}</code></p>
+        </div>
+      </section>
+
+      <section class="panel share-panel">
+        <label class="field-label" for="share-url">Share this room</label>
+        <div class="share-row">
+          <input id="share-url" class="share-input" type="text" readonly value="${escapeHtml(viewModel.shareUrl)}" />
+          <button id="copy-link-button" class="secondary-button" type="button">Copy link</button>
+        </div>
+      </section>
+
+      <section class="panel">
+        <div class="section-header">
+          <div>
+            <h2>Options</h2>
+            <p>${myVoteLabel}</p>
+          </div>
+        </div>
+        <ul class="options-list">${optionMarkup}</ul>
+      </section>
+
+      <section class="panel">
+        <h2>Add an option</h2>
+        <form id="add-option-form" class="option-form">
+          <input
+            id="option-input"
+            name="option"
+            type="text"
+            maxlength="80"
+            placeholder="Add an option"
+            autocomplete="off"
+            required
+          />
+          <button class="primary-button" type="submit">Add option</button>
+        </form>
+        <p class="feedback" aria-live="polite">${escapeHtml(feedbackMessage)}</p>
+      </section>
+    </main>
+  `;
+
+  const addOptionForm = container.querySelector<HTMLFormElement>("#add-option-form");
+  const optionInput = container.querySelector<HTMLInputElement>("#option-input");
+  const copyLinkButton = container.querySelector<HTMLButtonElement>("#copy-link-button");
+
+  addOptionForm?.addEventListener("submit", (event) => {
+    event.preventDefault();
+    const label = optionInput?.value ?? "";
+    actions.onSubmitOption(label);
+  });
+
+  copyLinkButton?.addEventListener("click", () => {
+    actions.onCopyLink();
+  });
+
+  container.querySelectorAll<HTMLButtonElement>("[data-option-id]").forEach((button) => {
+    button.addEventListener("click", () => {
+      const optionId = button.dataset.optionId;
+      if (optionId) {
+        actions.onVote(optionId);
+      }
+    });
+  });
+}

src/state.ts

@@ -0,0 +1,124 @@
+import * as Y from "yjs";
+
+export const DEFAULT_POLL_TITLE = "Shared Poll";
+
+export type ConnectionStatus = "connecting" | "connected" | "offline";
+
+export interface OptionRecord {
+  id: string;
+  label: string;
+  createdAt: number;
+  createdBy: string;
+}
+
+export interface PollOptionViewModel extends OptionRecord {
+  voteCount: number;
+  isSelectedByMe: boolean;
+}
+
+export interface PollViewModel {
+  title: string;
+  roomId: string;
+  shareUrl: string;
+  connectionStatus: ConnectionStatus;
+  options: PollOptionViewModel[];
+  myVoteOptionId: string | null;
+}
+
+const META_KEY_TITLE = "title";
+
+function createOptionId() {
+  if (typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+
+  return `option-${Math.random().toString(36).slice(2, 10)}`;
+}
+
+function normalizeLabel(label: string) {
+  return label.trim().replace(/\s+/g, " ");
+}
+
+function getPollTitle(meta: Y.Map<string>) {
+  return meta.get(META_KEY_TITLE) ?? DEFAULT_POLL_TITLE;
+}
+
+export function ensurePollInitialized(meta: Y.Map<string>) {
+  if (!meta.has(META_KEY_TITLE)) {
+    meta.set(META_KEY_TITLE, DEFAULT_POLL_TITLE);
+  }
+}
+
+export function addOption(
+  options: Y.Map<OptionRecord>,
+  rawLabel: string,
+  userId: string,
+) {
+  const label = normalizeLabel(rawLabel);
+  if (!label) {
+    return { ok: false as const, error: "Option label 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 as const, error: "That option already exists." };
+  }
+
+  const option: OptionRecord = {
+    id: createOptionId(),
+    label,
+    createdAt: Date.now(),
+    createdBy: userId,
+  };
+
+  options.set(option.id, option);
+  return { ok: true as const, optionId: option.id };
+}
+
+export function castVote(votes: Y.Map<string>, userId: string, optionId: string) {
+  votes.set(userId, optionId);
+}
+
+export function createViewModel(params: {
+  meta: Y.Map<string>;
+  options: Y.Map<OptionRecord>;
+  votes: Y.Map<string>;
+  roomId: string;
+  shareUrl: string;
+  connectionStatus: ConnectionStatus;
+  userId: string;
+}): PollViewModel {
+  const { meta, options, votes, roomId, shareUrl, connectionStatus, userId } =
+    params;
+
+  const tally = new Map<string, number>();
+  for (const optionId of votes.values()) {
+    tally.set(optionId, (tally.get(optionId) ?? 0) + 1);
+  }
+
+  const myVoteOptionId = votes.get(userId) ?? null;
+  const sortedOptions = Array.from(options.values()).sort((left, right) => {
+    if (left.createdAt !== right.createdAt) {
+      return left.createdAt - right.createdAt;
+    }
+
+    return left.label.localeCompare(right.label);
+  });
+
+  return {
+    title: getPollTitle(meta),
+    roomId,
+    shareUrl,
+    connectionStatus,
+    myVoteOptionId,
+    options: sortedOptions.map((option) => ({
+      ...option,
+      voteCount: tally.get(option.id) ?? 0,
+      isSelectedByMe: myVoteOptionId === option.id,
+    })),
+  };
+}

src/styles.css

@@ -0,0 +1,256 @@
+:root {
+  font-family: "IBM Plex Sans", "Segoe UI", sans-serif;
+  color: #132238;
+  background:
+    radial-gradient(circle at top left, rgba(255, 190, 120, 0.55), transparent 28%),
+    radial-gradient(circle at top right, rgba(86, 201, 166, 0.3), transparent 24%),
+    linear-gradient(180deg, #f9f4e8 0%, #f4efe6 48%, #ece5d8 100%);
+  line-height: 1.5;
+  font-weight: 400;
+  color-scheme: light;
+}
+
+* {
+  box-sizing: border-box;
+}
+
+body {
+  margin: 0;
+  min-height: 100vh;
+}
+
+button,
+input {
+  font: inherit;
+}
+
+button {
+  cursor: pointer;
+}
+
+#app {
+  min-height: 100vh;
+}
+
+.shell {
+  width: min(920px, calc(100% - 2rem));
+  margin: 0 auto;
+  padding: 2rem 0 3rem;
+}
+
+.hero {
+  display: flex;
+  justify-content: space-between;
+  gap: 1.5rem;
+  align-items: flex-start;
+  margin-bottom: 1.5rem;
+}
+
+.hero-copy h1 {
+  margin: 0.15rem 0 0.5rem;
+  font-size: clamp(2.4rem, 6vw, 4rem);
+  line-height: 0.95;
+  letter-spacing: -0.05em;
+}
+
+.hero-text,
+.section-header p,
+.feedback,
+.option-meta,
+.room-label {
+  color: #4a5a6a;
+}
+
+.eyebrow {
+  margin: 0;
+  text-transform: uppercase;
+  letter-spacing: 0.16em;
+  font-size: 0.8rem;
+  color: #915f00;
+}
+
+.hero-meta {
+  min-width: 15rem;
+  padding: 1rem 1.1rem;
+  border-radius: 1.2rem;
+  background: rgba(255, 255, 255, 0.68);
+  border: 1px solid rgba(19, 34, 56, 0.08);
+  backdrop-filter: blur(10px);
+}
+
+.status-pill {
+  display: inline-flex;
+  align-items: center;
+  padding: 0.35rem 0.75rem;
+  border-radius: 999px;
+  font-weight: 700;
+  text-transform: capitalize;
+  font-size: 0.9rem;
+}
+
+.status-pill.connected {
+  background: rgba(86, 201, 166, 0.18);
+  color: #135d43;
+}
+
+.status-pill.connecting {
+  background: rgba(255, 190, 120, 0.22);
+  color: #8c5300;
+}
+
+.status-pill.offline {
+  background: rgba(219, 82, 82, 0.16);
+  color: #8f1f1f;
+}
+
+.panel {
+  margin-bottom: 1.25rem;
+  padding: 1.25rem;
+  border-radius: 1.3rem;
+  background: rgba(255, 255, 255, 0.78);
+  border: 1px solid rgba(19, 34, 56, 0.08);
+  box-shadow: 0 14px 40px rgba(19, 34, 56, 0.08);
+  backdrop-filter: blur(10px);
+}
+
+.panel h2 {
+  margin: 0 0 0.45rem;
+  font-size: 1.1rem;
+}
+
+.share-row,
+.option-form,
+.option-main {
+  display: flex;
+  gap: 0.75rem;
+}
+
+.field-label {
+  display: block;
+  margin-bottom: 0.6rem;
+  font-weight: 700;
+}
+
+.share-input,
+.option-form input {
+  width: 100%;
+  min-width: 0;
+  border-radius: 0.95rem;
+  border: 1px solid rgba(19, 34, 56, 0.14);
+  background: rgba(255, 255, 255, 0.94);
+  padding: 0.85rem 1rem;
+  color: #132238;
+}
+
+.share-input:focus,
+.option-form input:focus {
+  outline: 2px solid rgba(255, 190, 120, 0.65);
+  outline-offset: 1px;
+}
+
+.primary-button,
+.secondary-button,
+.vote-button {
+  border: none;
+  border-radius: 0.95rem;
+  padding: 0.85rem 1rem;
+  font-weight: 700;
+  transition: transform 150ms ease, box-shadow 150ms ease, background-color 150ms ease;
+}
+
+.primary-button,
+.vote-button {
+  background: #132238;
+  color: #f9f4e8;
+  box-shadow: 0 10px 20px rgba(19, 34, 56, 0.14);
+}
+
+.secondary-button {
+  background: rgba(19, 34, 56, 0.08);
+  color: #132238;
+}
+
+.primary-button:hover,
+.secondary-button:hover,
+.vote-button:hover {
+  transform: translateY(-1px);
+}
+
+.options-list {
+  list-style: none;
+  margin: 1rem 0 0;
+  padding: 0;
+  display: grid;
+  gap: 0.75rem;
+}
+
+.option-card,
+.empty-state {
+  border-radius: 1.1rem;
+  padding: 1rem;
+  background: rgba(247, 244, 236, 0.95);
+  border: 1px solid rgba(19, 34, 56, 0.08);
+}
+
+.option-card.selected {
+  border-color: rgba(86, 201, 166, 0.85);
+  background: rgba(232, 249, 242, 0.95);
+}
+
+.option-main {
+  align-items: center;
+  justify-content: space-between;
+}
+
+.option-label {
+  margin: 0;
+  font-size: 1.05rem;
+  font-weight: 700;
+}
+
+.option-meta,
+.feedback,
+.room-label {
+  margin: 0.35rem 0 0;
+}
+
+.section-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: baseline;
+  gap: 1rem;
+}
+
+.feedback {
+  min-height: 1.5rem;
+}
+
+code {
+  font-family: "IBM Plex Mono", "SFMono-Regular", monospace;
+}
+
+@media (max-width: 720px) {
+  .shell {
+    width: min(100% - 1rem, 920px);
+    padding-top: 1rem;
+  }
+
+  .hero,
+  .share-row,
+  .option-form,
+  .option-main,
+  .section-header {
+    flex-direction: column;
+  }
+
+  .hero-meta {
+    width: 100%;
+    min-width: 0;
+  }
+
+  .primary-button,
+  .secondary-button,
+  .vote-button {
+    width: 100%;
+  }
+}

src/sync.ts

@@ -0,0 +1,64 @@
+import { IndexeddbPersistence } from "y-indexeddb";
+import { WebrtcProvider } from "y-webrtc";
+import * as Y from "yjs";
+
+import { type ConnectionStatus, ensurePollInitialized, type OptionRecord } from "./state";
+
+export interface AppSync {
+  doc: Y.Doc;
+  meta: Y.Map<string>;
+  options: Y.Map<OptionRecord>;
+  votes: Y.Map<string>;
+  provider: WebrtcProvider;
+  persistence: IndexeddbPersistence;
+  getConnectionStatus: () => ConnectionStatus;
+  destroy: () => void;
+}
+
+export function initSync(roomId: string): AppSync {
+  const doc = new Y.Doc();
+  const meta = doc.getMap<string>("poll-meta");
+  const options = doc.getMap<OptionRecord>("poll-options");
+  const votes = doc.getMap<string>("poll-votes");
+
+  ensurePollInitialized(meta);
+
+  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");
+  });
+
+  window.addEventListener("online", handleOnline);
+  window.addEventListener("offline", handleOffline);
+
+  return {
+    doc,
+    meta,
+    options,
+    votes,
+    provider,
+    persistence,
+    getConnectionStatus: () => connectionStatus,
+    destroy: () => {
+      window.removeEventListener("online", handleOnline);
+      window.removeEventListener("offline", handleOffline);
+      persistence.destroy();
+      provider.destroy();
+      doc.destroy();
+    },
+  };
+}

tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "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"]
+}

utils.js

@@ -1,291 +0,0 @@
-/* Adapted from https://github.com/yjs/y-websocket-server/blob/main/src/server.js, version of 2025-04-02
-   (author: dmonad/Kevin Jahns, MIT license) */
-
-import * as Y from 'yjs'
-import * as syncProtocol from '@y/protocols/sync'
-import * as awarenessProtocol from '@y/protocols/awareness'
-
-import * as encoding from 'lib0/encoding'
-import * as decoding from 'lib0/decoding'
-import * as map from 'lib0/map'
-
-import * as eventloop from 'lib0/eventloop'
-
-/*import { callbackHandler, isCallbackSet } from './callback.js'
-
-const CALLBACK_DEBOUNCE_WAIT = parseInt(process.env.CALLBACK_DEBOUNCE_WAIT || '2000')
-const CALLBACK_DEBOUNCE_MAXWAIT = parseInt(process.env.CALLBACK_DEBOUNCE_MAXWAIT || '10000')
-
-const debouncer = eventloop.createDebouncer(CALLBACK_DEBOUNCE_WAIT, CALLBACK_DEBOUNCE_MAXWAIT)*/
-
-const wsReadyStateConnecting = 0
-const wsReadyStateOpen = 1
-const wsReadyStateClosing = 2 // eslint-disable-line
-const wsReadyStateClosed = 3 // eslint-disable-line
-
-// disable gc when using snapshots!
-const gcEnabled = process.env.GC !== 'false' && process.env.GC !== '0'
-// const persistenceDir = process.env.YPERSISTENCE
-/**
- * @type {{bindState: function(string,WSSharedDoc):void, writeState:function(string,WSSharedDoc):Promise<any>, provider: any}|null}
- */
-let persistence = null
-
-/**
- * @param {{bindState: function(string,WSSharedDoc):void,
- * writeState:function(string,WSSharedDoc):Promise<any>,provider:any}|null} persistence_
- */
-export const setPersistence = persistence_ => {
-  persistence = persistence_
-}
-
-/**
- * @return {null|{bindState: function(string,WSSharedDoc):void,
-  * writeState:function(string,WSSharedDoc):Promise<any>}|null} used persistence layer
-  */
-export const getPersistence = () => persistence
-
-/**
- * @type {Map<string,WSSharedDoc>}
- */
-export const docs = new Map()
-
-const messageSync = 0
-const messageAwareness = 1
-// const messageAuth = 2
-//const messageTextMessage = 3
-//const messageStateMessage = 4
-
-/**
- * @param {Uint8Array} update
- * @param {any} _origin
- * @param {WSSharedDoc} doc
- * @param {any} _tr
- */
-const updateHandler = (update, _origin, doc, _tr) => {
-  const encoder = encoding.createEncoder()
-  encoding.writeVarUint(encoder, messageSync)
-  syncProtocol.writeUpdate(encoder, update)
-  const message = encoding.toUint8Array(encoder)
-  doc.conns.forEach((_, conn) => send(doc, conn, message))
-}
-
-/**
- * @type {(ydoc: Y.Doc) => Promise<void>}
- */
-let contentInitializor = _ydoc => Promise.resolve()
-
-/**
- * This function is called once every time a Yjs document is created. You can
- * use it to pull data from an external source or initialize content.
- *
- * @param {(ydoc: Y.Doc) => Promise<void>} f
- */
-export const setContentInitializor = (f) => {
-  contentInitializor = f
-}
-
-export class WSSharedDoc extends Y.Doc {
-  /**
-   * @param {string} name
-   */
-  constructor (name) {
-    super({ gc: gcEnabled })
-    this.name = name
-    /**
-     * Maps from conn to set of controlled user ids. Delete all user ids from awareness when this conn is closed
-     * @type {Map<Object, Set<number>>}
-     */
-    this.conns = new Map()
-    /**
-     * @type {awarenessProtocol.Awareness}
-     */
-    this.awareness = new awarenessProtocol.Awareness(this)
-    this.awareness.setLocalState(null)
-    /**
-     * @param {{ added: Array<number>, updated: Array<number>, removed: Array<number> }} changes
-     * @param {Object | null} conn Origin is the connection that made the change
-     */
-    const awarenessChangeHandler = ({ added, updated, removed }, conn) => {
-      const changedClients = added.concat(updated, removed)
-      if (conn !== null) {
-        const connControlledIDs = /** @type {Set<number>} */ (this.conns.get(conn))
-        if (connControlledIDs !== undefined) {
-          added.forEach(clientID => { connControlledIDs.add(clientID) })
-          removed.forEach(clientID => { connControlledIDs.delete(clientID) })
-        }
-      }
-      // broadcast awareness update
-      const encoder = encoding.createEncoder()
-      encoding.writeVarUint(encoder, messageAwareness)
-      encoding.writeVarUint8Array(encoder, awarenessProtocol.encodeAwarenessUpdate(this.awareness, changedClients))
-      const buff = encoding.toUint8Array(encoder)
-      this.conns.forEach((_, c) => {
-        send(this, c, buff)
-      })
-    }
-    this.awareness.on('update', awarenessChangeHandler)
-    this.on('update', /** @type {any} */ (updateHandler))
-    //if (isCallbackSet) {
-    //  this.on('update', (_update, _origin, doc) => {
-    //    debouncer(() => callbackHandler(/** @type {WSSharedDoc} */ (doc)))
-    //  })
-    //}
-    this.whenInitialized = contentInitializor(this)
-  }
-}
-
-/**
- * Gets a Y.Doc by name, whether in memory or on disk
- *
- * @param {string} docname - the name of the Y.Doc to find or create
- * @param {boolean} gc - whether to allow gc on the doc (applies only when created)
- * @return {WSSharedDoc}
- */
-export const getYDoc = (docname, gc = true) => map.setIfUndefined(docs, docname, () => {
-  const doc = new WSSharedDoc(docname)
-  doc.gc = gc
-  if (persistence !== null) {
-    persistence.bindState(docname, doc)
-  }
-  docs.set(docname, doc)
-  return doc
-})
-
-/**
- * @param {any} conn
- * @param {WSSharedDoc} doc
- * @param {Uint8Array} message
- */
-const messageListener = (conn, doc, message) => {
-  try {
-    const encoder = encoding.createEncoder()
-    const decoder = decoding.createDecoder(new Uint8Array(message))
-    const messageType = decoding.readVarUint(decoder)
-    switch (messageType) {
-      case messageSync:
-        encoding.writeVarUint(encoder, messageSync)
-        syncProtocol.readSyncMessage(decoder, encoder, doc, conn)
-
-        // If the `encoder` only contains the type of reply message and no
-        // message, there is no need to send the message. When `encoder` only
-        // contains the type of reply, its length is 1.
-        if (encoding.length(encoder) > 1) {
-          send(doc, conn, encoding.toUint8Array(encoder))
-        }
-        break
-      case messageAwareness: {
-        awarenessProtocol.applyAwarenessUpdate(doc.awareness, decoding.readVarUint8Array(decoder), conn)
-        break
-      }
-      // If this is a text or a message (no Yjs logic) - echo the message back to the client
-      default: {
-        conn.send(String(message))
-        console.log(String(message))
-        break
-      }
-    }
-  } catch (err) {
-    console.error(err)
-    // @ts-ignore
-    doc.emit('error', [err])
-  }
-}
-
-/**
- * @param {WSSharedDoc} doc
- * @param {any} conn
- */
-const closeConn = (doc, conn) => {
-  if (doc.conns.has(conn)) {
-    /**
-     * @type {Set<number>}
-     */
-    // @ts-ignore
-    const controlledIds = doc.conns.get(conn)
-    doc.conns.delete(conn)
-    awarenessProtocol.removeAwarenessStates(doc.awareness, Array.from(controlledIds), null)
-    if (doc.conns.size === 0 && persistence !== null) {
-      // if persisted, we store state and destroy ydocument
-      persistence.writeState(doc.name, doc).then(() => {
-        doc.destroy()
-      })
-      docs.delete(doc.name)
-    }
-  }
-  conn.close()
-}
-
-/**
- * @param {WSSharedDoc} doc
- * @param {import('ws').WebSocket} conn
- * @param {Uint8Array} m
- */
-const send = (doc, conn, m) => {
-  if (conn.readyState !== wsReadyStateConnecting && conn.readyState !== wsReadyStateOpen) {
-    closeConn(doc, conn)
-  }
-  try {
-    conn.send(m, {}, err => { err != null && closeConn(doc, conn) })
-  } catch (e) {
-    closeConn(doc, conn)
-  }
-}
-
-const pingTimeout = 30000
-
-/**
- * @param {import('ws').WebSocket} conn
- * @param {import('http').IncomingMessage} req
- * @param {any} opts
- */
-export const setupWSConnection = (conn, req, { docName = (req.url || '').slice(1).split('?')[0], gc = true } = {}) => {
-  conn.binaryType = 'arraybuffer'
-  // get doc, initialize if it does not exist yet
-  const doc = getYDoc(docName, gc)
-  doc.conns.set(conn, new Set())
-  // listen and reply to events
-  conn.on('message', /** @param {ArrayBuffer} message */ message => messageListener(conn, doc, message))
-
-  // Check if connection is still alive
-  let pongReceived = true
-  const pingInterval = setInterval(() => {
-    if (!pongReceived) {
-      if (doc.conns.has(conn)) {
-        closeConn(doc, conn)
-      }
-      clearInterval(pingInterval)
-    } else if (doc.conns.has(conn)) {
-      pongReceived = false
-      try {
-        conn.ping()
-      } catch (e) {
-        closeConn(doc, conn)
-        clearInterval(pingInterval)
-      }
-    }
-  }, pingTimeout)
-  conn.on('close', () => {
-    closeConn(doc, conn)
-    clearInterval(pingInterval)
-  })
-  conn.on('pong', () => {
-    pongReceived = true
-  })
-  // put the following in a variables in a block so the interval handlers don't keep in in
-  // scope
-  {
-    // send sync step 1
-    const encoder = encoding.createEncoder()
-    encoding.writeVarUint(encoder, messageSync)
-    syncProtocol.writeSyncStep1(encoder, doc)
-    send(doc, conn, encoding.toUint8Array(encoder))
-    const awarenessStates = doc.awareness.getStates()
-    if (awarenessStates.size > 0) {
-      const encoder = encoding.createEncoder()
-      encoding.writeVarUint(encoder, messageAwareness)
-      encoding.writeVarUint8Array(encoder, awarenessProtocol.encodeAwarenessUpdate(doc.awareness, Array.from(awarenessStates.keys())))
-      send(doc, conn, encoding.toUint8Array(encoder))
-    }
-  }
-}