uniwrtc 1.1.0 → 1.3.0

package/CLOUDFLARE_DEPLOYMENT.md

@@ -1,126 +1,32 @@
 # UniWRTC Cloudflare Deployment Guide
 
-## Prerequisites
+## Deploy Without Durable Objects (Cloudflare Pages)
 
-1. **Cloudflare Account** - Free tier is sufficient
-2. **Wrangler CLI** - Install: `npm install -g wrangler`
-3. **Node.js** - v16 or higher
-4. **Your Domain** - Domain must be on Cloudflare (e.g., `peer.ooo`)
-
-## Setup Steps
-
-### 1. Install Wrangler
-
-```bash
-npm install -g wrangler
-```
-
-### 2. Authenticate with Cloudflare
-
-```bash
-wrangler login
-```
-
-This will open your browser to authorize the CLI.
-
-### 3. Update wrangler.toml
-
-Replace the zone configuration with your domain:
-
-```toml
-[env.production]
-routes = [
-  { pattern = "signal.peer.ooo/*", zone_name = "peer.ooo" }
-]
-```
-
-### 4. Deploy to Cloudflare
-
-```bash
-# Deploy to production
-wrangler publish --env production
-
-# Or deploy to staging first
-wrangler publish
-```
-
-### 5. Access Your Signaling Server
-
-Your server will be available at:
-- **Production**: `https://signal.peer.ooo/`
-- **Development**: `https://uniwrtc.<subdomain>.workers.dev/`
+If you only want to host the demo UI (static assets) and do NOT want Durable Objects, deploy the Vite build to Cloudflare Pages.
 
-## Using with UniWRTC Demo
+### Prerequisites
 
-Update the demo to use your Cloudflare endpoint:
-
-```javascript
-// In demo.html or client
-const serverUrl = 'https://signal.peer.ooo/';
-const roomId = 'my-room';
-
-const client = new UniWRTCClient(serverUrl, { 
-  roomId: roomId,
-  customPeerId: 'optional-id' 
-});
-
-await client.connect();
-```
-
-## How It Works
-
-1. **Durable Objects** - One per room, manages peer discovery
-2. **HTTP polling** - Browsers connect for signaling
-3. **Signaling Only** - Offers/answers/ICE via Worker
-4. **P2P Data** - WebRTC data channels bypass Cloudflare
-5. **Free Tier** - Plenty of capacity for small deployments
-
-## Cost
-
-- **Requests**: 100,000 free per day (signaling only)
-- **Compute**: Included in free tier
-- **Durable Objects**: ~$0.15/million operations (minimal for signaling)
-- **Total**: Free to very low cost
-
-## Monitoring
-
-Check deployment status:
-
-```bash
-wrangler tail --env production
-```
-
-View real-time logs from your Worker.
-
-## Local Development
+1. **Cloudflare Account** - Free tier is sufficient
+2. **Wrangler CLI** - Install: `npm install -g wrangler` (or use `npx`)
+3. **Node.js** - v16 or higher
 
-Test locally before deploying:
+### Deploy
 
 ```bash
-wrangler dev
+npm install
+npm run deploy:cf:no-do
 ```
 
-Your local server will run at `http://localhost:8787`
-
-Update demo to test:
-```javascript
-const serverUrl = 'http://localhost:8787/';
-```
-
-## Troubleshooting
-
-**Connection errors**: Ensure your domain is on Cloudflare with SSL enabled
-
-**Connection refused**: Check the Worker route pattern in `wrangler.toml`
+Notes:
+- This deploys the `dist/` folder (static hosting).
+- No server routes are deployed; Durable Objects are not used.
 
-**Durable Objects not found**: Run `wrangler publish` with migrations enabled
+## Custom Domain (signal.peer.ooo)
 
-## Next Steps
+To serve the Pages project at `https://signal.peer.ooo`:
 
-1. Deploy the Worker
-2. Update demo.html to use your Cloudflare endpoint
-3. Test with multiple browsers
-4. Scale up!
+1. Cloudflare Dashboard → Pages → your project → **Custom domains** → add `signal.peer.ooo`
+2. Cloudflare DNS → set `signal` as a CNAME to `<your-pages-project>.pages.dev`
 
 ---
 

package/QUICKSTART_CLOUDFLARE.md

@@ -1,8 +1,24 @@
-# Quick Start - Deploy to Cloudflare in 30 seconds
+# Quick Start - Deploy to Cloudflare
+
+## Option A (No Durable Objects): Cloudflare Pages (static)
+
+This repo’s current demo works client-side (Nostr), so you can deploy just the static site to Cloudflare Pages.
+
+### Prerequisites
+- Cloudflare account (free tier works)
+- Node.js installed
+- Wrangler CLI authenticated (`npx wrangler login`)
+
+### Deploy
+```bash
+npm install
+npm run deploy:cf:no-do
+```
+
+Wrangler will prompt you to pick/create a Pages project the first time.
 
 ## Prerequisites
 - Cloudflare account (free tier works)
-- Your domain on Cloudflare
 - Node.js installed
 
 ## Deploy
@@ -18,38 +34,12 @@ chmod +x deploy-cloudflare.sh
 deploy-cloudflare.bat
 ```
 
-## What the script does:
-1. ✅ Checks Node.js and installs Wrangler
-2. ✅ Authenticates with Cloudflare
-3. ✅ Asks for your domain (e.g., `signal.peer.ooo`)
-4. ✅ Updates `wrangler.toml`
-5. ✅ Deploys to Cloudflare Workers
-6. ✅ Gives you the live URL
+## What this does
+1. ✅ Builds the Vite site into `dist/`
+2. ✅ Deploys `dist/` to Cloudflare Pages
 
 ## After deployment:
 
-Update demo.html:
-```javascript
-const serverUrl = 'https://signal.peer.ooo/'; // Your domain
-```
-
-Then reload the demo and it will connect to your Cloudflare Workers signaling server! 🚀
-
-## Testing
-
-Test the server:
-```bash
-curl https://signal.peer.ooo/health
-```
-
-View logs:
-```bash
-wrangler tail --env production
-```
-
-Local development:
-```bash
-wrangler dev
-```
+Then set your custom domain in Cloudflare Pages (and point `signal` to `<project>.pages.dev`).
 
-That's it! Your WebRTC signaling is now on Cloudflare! 🎉
+That's it! Your demo is now on Cloudflare Pages (no Durable Objects).

package/deploy-cloudflare.bat

@@ -1,9 +1,10 @@
 @echo off
-REM UniWRTC Cloudflare Automated Setup Script (Windows)
+REM UniWRTC Cloudflare Automated Setup Script (Windows, NO Durable Objects)
+REM Deploys the static demo to Cloudflare Pages.
 
 setlocal enabledelayedexpansion
 
-echo 🚀 UniWRTC Cloudflare Setup
+echo 🚀 UniWRTC Cloudflare Setup (Pages / no Durable Objects)
 echo ============================
 echo.
 
@@ -40,74 +41,29 @@ if errorlevel 1 (
 echo ✅ Authenticated with Cloudflare
 echo.
 
-REM Ask for domain
-echo 🌐 Domain Configuration
-echo =====================
-set /p DOMAIN="Enter your Cloudflare domain (e.g., peer.ooo): "
-set /p SUBDOMAIN="Enter subdomain for signaling (e.g., signal): "
+REM Project name
+set PROJECT_NAME=signal-peer-ooo
+if not "%~1"=="" set PROJECT_NAME=%~1
 
-if "!DOMAIN!"=="" (
-  echo ❌ Domain required
-  exit /b 1
-)
-
-if "!SUBDOMAIN!"=="" (
-  echo ❌ Subdomain required
-  exit /b 1
-)
-
-set FULL_DOMAIN=!SUBDOMAIN!.!DOMAIN!
-
-REM Update wrangler.toml
-echo 📝 Updating wrangler.toml...
-(
-  echo name = "uniwrtc"
-  echo main = "src/index.js"
-  echo compatibility_date = "2024-12-20"
-  echo.
-  echo [env.production]
-  echo routes = [
-  echo   { pattern = "!FULL_DOMAIN!/*", zone_name = "!DOMAIN!" }
-  echo ]
-  echo.
-  echo [[durable_objects.bindings]]
-  echo name = "ROOMS"
-  echo class_name = "Room"
-  echo.
-  echo [durable_objects]
-  echo migrations = [
-  echo   { tag = "v1", new_classes = ["Room"] }
-  echo ]
-  echo.
-  echo [build]
-  echo command = "npm install"
-) > wrangler.toml
+echo 📦 Building static site...
+call npm run build
 
-echo ✅ wrangler.toml updated
+echo 🚀 Deploying to Cloudflare Pages project: %PROJECT_NAME%
 echo.
 
+REM Create project if needed (ignore errors)
+call npx wrangler pages project create %PROJECT_NAME% --production-branch main >nul 2>nul
+
 REM Deploy
-echo 🚀 Deploying to Cloudflare...
-echo.
-call wrangler deploy --env production
+call npx wrangler pages deploy dist --project-name %PROJECT_NAME%
 
 echo.
 echo ✅ Deployment Complete!
 echo.
-echo 🎉 Your UniWRTC signaling server is live at:
-echo    https://!FULL_DOMAIN!/
-echo.
-echo 📊 Test it:
-echo    curl https://!FULL_DOMAIN!/health
-echo.
-echo 🧪 Local testing:
-echo    wrangler dev
-echo.
-echo 📊 View logs:
-echo    wrangler tail --env production
-echo.
-echo 🛠️  Next: Update demo.html to use:
-echo    const serverUrl = 'https://!FULL_DOMAIN!/';
+echo 🎉 Your Pages site is deployed.
+echo Next step for custom domain (manual in Cloudflare UI):
+echo   - Pages ^> %PROJECT_NAME% ^> Custom domains ^> add signal.peer.ooo
+echo   - DNS: CNAME signal ^> %PROJECT_NAME%.pages.dev
 echo.
 
 endlocal

package/deploy-cloudflare.sh

@@ -1,11 +1,11 @@
 #!/bin/bash
 
-# UniWRTC Cloudflare Automated Setup Script
-# Run this to setup and deploy to Cloudflare
+# UniWRTC Cloudflare Automated Setup Script (NO Durable Objects)
+# Deploys the static demo to Cloudflare Pages.
 
 set -e
 
-echo "🚀 UniWRTC Cloudflare Setup"
+echo "🚀 UniWRTC Cloudflare Setup (Pages / no Durable Objects)"
 echo "============================"
 echo ""
 
@@ -41,67 +41,24 @@ fi
 echo "✅ Authenticated with Cloudflare"
 echo ""
 
-# Domain configuration
-DOMAIN="peer.ooo"
-SUBDOMAIN="signal"
+PROJECT_NAME=${1:-"signal-peer-ooo"}
 
-FULL_DOMAIN="${SUBDOMAIN}.${DOMAIN}"
+echo "📦 Building static site..."
+npm run build
 
-echo "📝 Updating wrangler.toml..."
-cat > wrangler.toml << EOF
-name = "uniwrtc"
-main = "src/index.js"
-compatibility_date = "2024-12-20"
+echo "🚀 Deploying to Cloudflare Pages project: ${PROJECT_NAME}"
 
-assets = { directory = "./dist", binding = "ASSETS" }
+# Create the project if it doesn't exist (ignore error if it already exists)
+npx wrangler pages project create "${PROJECT_NAME}" --production-branch main 2>/dev/null || true
 
-[[durable_objects.bindings]]
-name = "ROOMS"
-class_name = "Room"
-
-[[migrations]]
-tag = "v1"
-new_classes = ["Room"]
-
-[env.production]
-routes = [
-  { pattern = "${FULL_DOMAIN}/*", zone_name = "${DOMAIN}" }
-]
-
-assets = { directory = "./dist", binding = "ASSETS" }
-
-[[env.production.durable_objects.bindings]]
-name = "ROOMS"
-class_name = "Room"
-
-[build]
-command = "npm install"
-EOF
-
-echo "✅ wrangler.toml updated"
-echo ""
-
-# Deploy
-echo "🚀 Deploying to Cloudflare..."
-echo ""
-echo "Deploying to production..."
-wrangler deploy --env production
+# Deploy the built assets
+npx wrangler pages deploy dist --project-name "${PROJECT_NAME}"
 
 echo ""
 echo "✅ Deployment Complete!"
 echo ""
-echo "🎉 Your UniWRTC signaling server is live at:"
-echo "   https://${FULL_DOMAIN}/"
-echo ""
-echo "📊 Test it:"
-echo "   curl https://${FULL_DOMAIN}/health"
-echo ""
-echo "🧪 Local testing:"
-echo "   wrangler dev"
-echo ""
-echo "📊 View logs:"
-echo "   wrangler tail --env production"
-echo ""
-echo "🛠️  Next: Update demo.html to use:"
-echo "   const serverUrl = 'https://${FULL_DOMAIN}/';"
+echo "🎉 Your Pages site is deployed."
+echo "Next step for custom domain (manual in Cloudflare UI):"
+echo "  - Pages → ${PROJECT_NAME} → Custom domains → add signal.peer.ooo"
+echo "  - DNS: CNAME signal → ${PROJECT_NAME}.pages.dev"
 echo ""

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "uniwrtc",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "description": "A universal WebRTC signaling service",
   "main": "server.js",
   "type": "module",
@@ -9,6 +9,8 @@
     "dev": "vite",
     "build": "vite build",
     "preview": "vite preview",
+    "deploy:cf:pages": "npm run build && npx wrangler pages deploy dist",
+    "deploy:cf:no-do": "npm run deploy:cf:pages",
     "server": "node server.js",
     "test": "node test.js"
   },

package/src/main.js

@@ -7,10 +7,29 @@ window.UniWRTCClient = UniWRTCClient;
 
 // Nostr is the default transport (no toggle)
 let nostrClient = null;
+let myPeerId = null;
+let mySessionNonce = null;
+const peerSessions = new Map();
+const peerProbeState = new Map();
+const readyPeers = new Set();
+const deferredHelloPeers = new Set();
+
+// Curated public relays (best-effort). Users can override in the UI.
+const DEFAULT_RELAYS = [
+    'wss://relay.primal.net',
+    'wss://relay.nostr.band',
+    'wss://nos.lol',
+    'wss://relay.snort.social',
+    'wss://nostr.wine',
+    'wss://relay.damus.io',
+];
+
 
 let client = null;
 const peerConnections = new Map();
 const dataChannels = new Map();
+const pendingIce = new Map();
+const outboundIceBatches = new Map();
 
 // Initialize app
 document.getElementById('app').innerHTML = `
@@ -24,8 +43,8 @@ document.getElementById('app').innerHTML = `
             <h2>Connection</h2>
             <div class="connection-controls">
                 <div>
-                    <label style="display: block; margin-bottom: 5px; color: #64748b; font-size: 13px;">Relay URL</label>
-                    <input type="text" id="relayUrl" placeholder="wss://relay.damus.io" value="wss://relay.damus.io" style="width: 100%; padding: 8px; border: 1px solid #e2e8f0; border-radius: 4px; font-family: monospace; font-size: 12px;">
+                    <label style="display: block; margin-bottom: 5px; color: #64748b; font-size: 13px;">Relay URL(s)</label>
+                    <input type="text" id="relayUrl" placeholder="wss://relay.damus.io" value="${DEFAULT_RELAYS.join(', ')}" style="width: 100%; padding: 8px; border: 1px solid #e2e8f0; border-radius: 4px; font-family: monospace; font-size: 12px;">
                 </div>
                 <div>
                     <label style="display: block; margin-bottom: 5px; color: #64748b; font-size: 13px;">Room / Session ID</label>
@@ -93,6 +112,13 @@ if (urlRoom) {
     log(`Using default room ID: ${defaultRoom}`, 'info');
 }
 
+// STUN-only ICE servers (no TURN)
+const ICE_SERVERS = [
+    { urls: ['stun:stun.l.google.com:19302', 'stun:stun1.l.google.com:19302'] },
+    { urls: ['stun:stun2.l.google.com:19302', 'stun:stun3.l.google.com:19302'] },
+    { urls: ['stun:stun.cloudflare.com:3478'] },
+];
+
 function log(message, type = 'info') {
     const logContainer = document.getElementById('logContainer');
     const entry = document.createElement('div');
@@ -154,12 +180,164 @@ window.connect = async function() {
     await connectNostr();
 };
 
+function shouldInitiateWith(peerId) {
+    // Deterministic initiator to avoid offer glare
+    if (!myPeerId) return false;
+    return myPeerId.localeCompare(peerId) < 0;
+}
+
+function isPoliteFor(peerId) {
+    // In perfect negotiation, one side is "polite" (will accept/repair collisions)
+    return !shouldInitiateWith(peerId);
+}
+
+function sendSignal(to, payload) {
+    if (!nostrClient) throw new Error('Not connected to Nostr');
+
+    const toSession = peerSessions.get(to);
+    const type = payload?.type;
+    const needsToSession = type !== 'probe';
+
+    if (needsToSession && !toSession) throw new Error('No peer session yet');
+
+    return nostrClient.send({
+        ...payload,
+        to,
+        ...(needsToSession ? { toSession } : {}),
+        fromSession: mySessionNonce,
+    });
+}
+
+function sendSignalToSession(to, payload, toSession) {
+    if (!nostrClient) throw new Error('Not connected to Nostr');
+    if (!toSession) throw new Error('toSession is required');
+    return nostrClient.send({
+        ...payload,
+        to,
+        toSession,
+        fromSession: mySessionNonce,
+    });
+}
+
+async function maybeProbePeer(peerId) {
+    if (!nostrClient) return;
+    const session = peerSessions.get(peerId);
+    if (!session) return;
+    if (!shouldInitiateWith(peerId)) return;
+
+    const last = peerProbeState.get(peerId);
+    if (last && last.session === session) return;
+
+    const probeId = Math.random().toString(36).slice(2, 10) + Date.now().toString(36);
+    peerProbeState.set(peerId, { session, ts: Date.now(), probeId });
+    try {
+        await sendSignal(peerId, { type: 'probe', probeId });
+        log(`Probing peer ${peerId.substring(0, 6)}...`, 'info');
+    } catch (e) {
+        log(`Probe failed: ${e?.message || e}`, 'warning');
+    }
+}
+
+function logDrop(peerId, payload, reason) {
+    const t = payload?.type || 'unknown';
+    if (t !== 'signal-offer' && t !== 'signal-answer' && t !== 'signal-ice' && t !== 'signal-ice-batch' && t !== 'probe' && t !== 'probe-ack') return;
+    log(`Dropped ${t} from ${peerId.substring(0, 6)}... (${reason})`, 'warning');
+}
+
+async function resetPeerConnection(peerId) {
+    const existing = peerConnections.get(peerId);
+    if (existing instanceof RTCPeerConnection) {
+        try {
+            existing.close();
+        } catch {
+            // ignore
+        }
+    }
+    peerConnections.delete(peerId);
+    pendingIce.delete(peerId);
+
+    const dc = dataChannels.get(peerId);
+    if (dc) {
+        try {
+            dc.close();
+        } catch {
+            // ignore
+        }
+    }
+    dataChannels.delete(peerId);
+    updatePeerList();
+
+    return ensurePeerConnection(peerId);
+}
+
+async function ensurePeerConnection(peerId) {
+    if (!peerId || peerId === myPeerId) return null;
+    if (peerConnections.has(peerId) && peerConnections.get(peerId) instanceof RTCPeerConnection) {
+        return peerConnections.get(peerId);
+    }
+
+    const initiator = shouldInitiateWith(peerId);
+
+    // Initiator must wait until the peer proves it's live (probe-ack), otherwise we end up
+    // negotiating with stale peers from relay history.
+    if (initiator && !readyPeers.has(peerId)) {
+        return null;
+    }
+    const pc = await createPeerConnection(peerId, initiator);
+    return pc;
+}
+
+async function addIceCandidateSafely(peerId, candidate) {
+    const pc = peerConnections.get(peerId);
+    if (!(pc instanceof RTCPeerConnection)) return;
+
+    if (!pc.remoteDescription) {
+        const list = pendingIce.get(peerId) || [];
+        list.push(candidate);
+        pendingIce.set(peerId, list);
+        return;
+    }
+
+    await pc.addIceCandidate(new RTCIceCandidate(candidate));
+}
+
+async function flushPendingIce(peerId) {
+    const pc = peerConnections.get(peerId);
+    if (!(pc instanceof RTCPeerConnection)) return;
+    if (!pc.remoteDescription) return;
+
+    const list = pendingIce.get(peerId);
+    if (!list || list.length === 0) return;
+    pendingIce.delete(peerId);
+
+    for (const c of list) {
+        try {
+            await pc.addIceCandidate(new RTCIceCandidate(c));
+        } catch (e) {
+            log(`Failed to add queued ICE candidate: ${e?.message || e}`, 'warning');
+        }
+    }
+}
+
 async function connectNostr() {
-    const relayUrl = document.getElementById('relayUrl').value.trim();
+    const relayUrlRaw = document.getElementById('relayUrl').value.trim();
     const roomIdInput = document.getElementById('roomId');
     const roomId = roomIdInput.value.trim();
     
-    if (!relayUrl) {
+    const relayCandidatesRaw = relayUrlRaw.toLowerCase() === 'auto'
+        ? DEFAULT_RELAYS
+        : Array.from(
+            new Set(
+                relayUrlRaw
+                    .split(/[\s,]+/)
+                    .map((s) => s.trim())
+                    .filter(Boolean)
+            )
+        );
+
+    const relayCandidates = relayCandidatesRaw.length ? relayCandidatesRaw : DEFAULT_RELAYS;
+
+    if (relayCandidates.length === 0) {
         log('Please enter a relay URL', 'error');
         return;
     }
@@ -168,39 +346,318 @@ async function connectNostr() {
     if (!roomId) roomIdInput.value = effectiveRoom;
 
     try {
-        log(`Connecting to Nostr relay: ${relayUrl}...`, 'info');
+        log(`Connecting to Nostr relay...`, 'info');
 
         if (nostrClient) {
             await nostrClient.disconnect();
             nostrClient = null;
         }
 
-        nostrClient = createNostrClient({
+        // Reset local peer state to avoid stale sessions targeting the wrong browser tab.
+        myPeerId = null;
+        mySessionNonce = null;
+        peerSessions.clear();
+        peerProbeState.clear();
+        readyPeers.clear();
+        pendingIce.clear();
+        peerConnections.forEach((pc) => {
+            if (pc instanceof RTCPeerConnection) pc.close();
+        });
+        peerConnections.clear();
+        dataChannels.clear();
+        updatePeerList();
+
+        const wireHandlers = (client) => {
+            client.__handlers = {
+                onState: (state) => {
+                    if (state === 'connected') updateStatus(true);
+                    if (state === 'disconnected') updateStatus(false);
+                },
+                onNotice: (notice) => {
+                    log(`Relay NOTICE: ${String(notice)}`, 'warning');
+                },
+                onOk: ({ id, ok, message }) => {
+                    if (ok === false) log(`Relay rejected event ${String(id).slice(0, 8)}...: ${String(message)}`, 'error');
+                },
+            };
+        };
+
+        // Try relays async (in small parallel batches) and pick the first that accepts publishes.
+        const relayBatchSize = 3;
+        let lastError = null;
+        let selected = null;
+
+        // Identity must be ready before we connect/subscribe; inbound events can arrive immediately.
+        // Any client instance will derive the same per-tab keypair.
+        const identityClient = createNostrClient({ relayUrl: relayCandidates[0], room: effectiveRoom });
+        const myPubkey = identityClient.getPublicKey();
+        myPeerId = myPubkey;
+        mySessionNonce = Math.random().toString(36).slice(2) + Date.now().toString(36);
+        document.getElementById('clientId').textContent = myPubkey.substring(0, 16) + '...';
+        document.getElementById('sessionId').textContent = effectiveRoom;
+
+        const makeClient = (relayUrl) => createNostrClient({
             relayUrl,
             room: effectiveRoom,
             onState: (state) => {
                 if (state === 'connected') updateStatus(true);
                 if (state === 'disconnected') updateStatus(false);
             },
-            onMessage: ({ from, text }) => {
-                displayChatMessage(text, from, false);
+            onNotice: (notice) => {
+                log(`Relay NOTICE (${relayUrl}): ${String(notice)}`, 'warning');
             },
-            onPeer: ({ peerId }) => {
+            onOk: ({ id, ok, message }) => {
+                if (ok === false) log(`Relay rejected event ${String(id).slice(0, 8)}...: ${String(message)}`, 'error');
+            },
+            onPayload: async ({ from, payload }) => {
+                const peerId = from;
+                if (!peerId || peerId === myPeerId) return;
+
                 // Use the existing peer list UI as a simple "seen peers" list
                 if (!peerConnections.has(peerId)) {
                     peerConnections.set(peerId, null);
                     updatePeerList();
                     log(`Peer seen: ${peerId.substring(0, 6)}...`, 'success');
                 }
-            }
+
+                if (!payload || typeof payload !== 'object') return;
+
+                // NOTE: Do NOT learn/update peerSessions from arbitrary relay history.
+                // Only trust:
+                // - `hello` (broadcast presence)
+                // - messages targeted to this tab via `toSession === mySessionNonce`
+
+                // Presence
+                if (payload.type === 'hello') {
+                    if (!myPeerId || !mySessionNonce) return;
+                    if (typeof payload.session !== 'string' || payload.session.length < 6) return;
+                    const prev = peerSessions.get(peerId);
+                    peerSessions.set(peerId, payload.session);
+                    if (!prev || prev !== payload.session) {
+                        log(`Peer session updated: ${peerId.substring(0, 6)}...`, 'info');
+                    }
+
+                    if (prev && prev !== payload.session) {
+                        readyPeers.delete(peerId);
+                    }
+
+                    // We may receive peer presence while still selecting a relay.
+                    // Store and probe once we have a selected/connected `nostrClient`.
+                    deferredHelloPeers.add(peerId);
+                    await maybeProbePeer(peerId);
+                    return;
+                }
+
+                if (payload.type === 'probe') {
+                    // Learn the peer's session from a live message.
+                    if (typeof payload.fromSession === 'string' && payload.fromSession.length >= 6) {
+                        const prev = peerSessions.get(peerId);
+                        if (!prev || prev !== payload.fromSession) {
+                            peerSessions.set(peerId, payload.fromSession);
+                            log(`Peer session ${prev ? 'rotated' : 'learned'}: ${peerId.substring(0, 6)}...`, 'info');
+                            readyPeers.delete(peerId);
+                        }
+                    }
+
+                    // Reply directly to the sender's session (fromSession) so the initiator doesn't drop it.
+                    try {
+                        await sendSignalToSession(peerId, { type: 'probe-ack', probeId: payload.probeId }, payload.fromSession);
+                        log(`Probe ack -> ${peerId.substring(0, 6)}...`, 'info');
+                    } catch (e) {
+                        log(`Probe-ack failed: ${e?.message || e}`, 'warning');
+                    }
+                    return;
+                }
+
+                // Only accept signaling intended for THIS browser session
+                if (payload.toSession && payload.toSession !== mySessionNonce) {
+                    logDrop(peerId, payload, 'toSession mismatch');
+                    return;
+                }
+
+                // Signaling messages are always targeted
+                if (payload.to && payload.to !== myPeerId) {
+                    logDrop(peerId, payload, 'to mismatch');
+                    return;
+                }
+
+                // Now that we know it's targeted to this session, we can safely learn peer session.
+                if (typeof payload.fromSession === 'string' && payload.fromSession.length >= 6) {
+                    const prev = peerSessions.get(peerId);
+                    if (!prev || prev !== payload.fromSession) {
+                        peerSessions.set(peerId, payload.fromSession);
+                        log(`Peer session ${prev ? 'rotated' : 'learned'}: ${peerId.substring(0, 6)}...`, 'info');
+                        readyPeers.delete(peerId);
+                    }
+                }
+
+                if (payload.type === 'probe-ack') {
+                    const last = peerProbeState.get(peerId);
+                    if (!last || !last.probeId || !payload.probeId || payload.probeId !== last.probeId) {
+                        logDrop(peerId, payload, 'probeId mismatch');
+                        return;
+                    }
+                    // Peer session can legitimately rotate between hello/probe/ack (reloads, relay history).
+                    // Since this message is already targeted to our toSession, accept it and update our view.
+                    if (typeof payload.fromSession === 'string' && payload.fromSession.length >= 6) {
+                        if (peerSessions.get(peerId) !== payload.fromSession) {
+                            peerSessions.set(peerId, payload.fromSession);
+                        }
+                        if (last.session !== payload.fromSession) {
+                            last.session = payload.fromSession;
+                        }
+                    }
+                    if (Date.now() - last.ts > 30000) {
+                        logDrop(peerId, payload, 'stale probe-ack');
+                        return;
+                    }
+
+                    readyPeers.add(peerId);
+                    if (shouldInitiateWith(peerId)) {
+                        log(`Probe ack <- ${peerId.substring(0, 6)}...`, 'info');
+                        await ensurePeerConnection(peerId);
+                    }
+                    return;
+                }
+
+                if (payload.type === 'signal-offer' && payload.sdp) {
+                    log(`Received offer from ${peerId.substring(0, 6)}...`, 'info');
+                    let pc = await ensurePeerConnection(peerId);
+                    if (!pc) {
+                        // As the receiver we should always accept an offer even if probe logic didn't run.
+                        pc = await resetPeerConnection(peerId);
+                    }
+                    if (!(pc instanceof RTCPeerConnection)) return;
+
+                    // Offer collision handling: if we're not stable, decide whether to ignore or reset.
+                    const offerCollision = pc.signalingState !== 'stable';
+                    if (offerCollision && !isPoliteFor(peerId)) {
+                        log(`Ignoring offer collision from ${peerId.substring(0, 6)}...`, 'warning');
+                        return;
+                    }
+                    if (offerCollision && isPoliteFor(peerId)) {
+                        log(`Offer collision; resetting connection with ${peerId.substring(0, 6)}...`, 'warning');
+                        await resetPeerConnection(peerId);
+                        const next = peerConnections.get(peerId);
+                        if (!(next instanceof RTCPeerConnection)) return;
+                        pc = next;
+                    }
+
+                    const pc2 = peerConnections.get(peerId);
+                    if (!(pc2 instanceof RTCPeerConnection)) return;
+
+                    // Only accept offers here.
+                    if (payload.sdp?.type && payload.sdp.type !== 'offer') {
+                        log(`Ignoring non-offer in signal-offer from ${peerId.substring(0, 6)}...`, 'warning');
+                        return;
+                    }
+
+                    await pc2.setRemoteDescription(new RTCSessionDescription(payload.sdp));
+                    await flushPendingIce(peerId);
+                    if (pc2.signalingState !== 'have-remote-offer') {
+                        log(`Not answering; unexpected state: ${pc2.signalingState}`, 'warning');
+                        return;
+                    }
+                    const answer = await pc2.createAnswer();
+                    await pc2.setLocalDescription(answer);
+                    try {
+                        await sendSignal(peerId, { type: 'signal-answer', sdp: { type: pc2.localDescription.type, sdp: pc2.localDescription.sdp } });
+                        log(`Sent answer to ${peerId.substring(0, 6)}...`, 'success');
+                    } catch (e) {
+                        log(`Failed to send answer: ${e?.message || e}`, 'error');
+                    }
+                    return;
+                }
+
+                if (payload.type === 'signal-answer' && payload.sdp) {
+                    log(`Received answer from ${peerId.substring(0, 6)}...`, 'info');
+                    const pc = peerConnections.get(peerId);
+                    if (pc instanceof RTCPeerConnection) {
+                        if (payload.sdp?.type && payload.sdp.type !== 'answer') {
+                            log(`Ignoring non-answer in signal-answer from ${peerId.substring(0, 6)}...`, 'warning');
+                            return;
+                        }
+                        await pc.setRemoteDescription(new RTCSessionDescription(payload.sdp));
+                        await flushPendingIce(peerId);
+                    }
+                    return;
+                }
+
+                if (payload.type === 'signal-ice' && payload.candidate) {
+                    log(`Received ICE candidate from ${peerId.substring(0, 6)}...`, 'info');
+                    try {
+                        await addIceCandidateSafely(peerId, payload.candidate);
+                    } catch (e) {
+                        log(`Failed to add ICE candidate: ${e?.message || e}`, 'warning');
+                    }
+                    return;
+                }
+
+                if (payload.type === 'signal-ice-batch' && Array.isArray(payload.candidates)) {
+                    log(`Received ICE batch (${payload.candidates.length}) from ${peerId.substring(0, 6)}...`, 'info');
+                    for (const c of payload.candidates) {
+                        try {
+                            await addIceCandidateSafely(peerId, c);
+                        } catch (e) {
+                            log(`Failed to add ICE candidate: ${e?.message || e}`, 'warning');
+                        }
+                    }
+                }
+            },
         });
 
-        await nostrClient.connect();
+        const tryOneRelay = async (relayUrl) => {
+            const candidateClient = makeClient(relayUrl);
+            await candidateClient.connect();
+            const ok = await candidateClient.sendWithOk({ type: 'relay-check', session: mySessionNonce }, { timeoutMs: 3500 });
+            if (ok.ok !== true) throw new Error(ok.message || 'Relay rejected publish');
+            return { relayUrl, client: candidateClient };
+        };
+
+        for (let i = 0; i < relayCandidates.length && !selected; i += relayBatchSize) {
+            const batch = relayCandidates.slice(i, i + relayBatchSize);
+            batch.forEach((u) => log(`Trying relay: ${u}`, 'info'));
+
+            const clientsInBatch = new Map();
+            const attempts = batch.map((relayUrl) => (async () => {
+                const result = await tryOneRelay(relayUrl);
+                clientsInBatch.set(relayUrl, result.client);
+                return result;
+            })());
+
+            try {
+                selected = await Promise.any(attempts);
+            } catch (e) {
+                lastError = e;
+            } finally {
+                // Close any batch clients that were created but not selected.
+                for (const [url, c] of clientsInBatch.entries()) {
+                    if (selected && selected.relayUrl === url) continue;
+                    try {
+                        await c.disconnect();
+                    } catch {
+                        // ignore
+                    }
+                }
+            }
+        }
+
+        if (!selected) {
+            throw lastError || new Error('No relay candidates available');
+        }
+
+        nostrClient = selected.client;
+        document.getElementById('relayUrl').value = selected.relayUrl;
+        log(`Selected relay: ${selected.relayUrl}`, 'success');
 
-        const myPubkey = nostrClient.getPublicKey();
-        document.getElementById('clientId').textContent = myPubkey.substring(0, 16) + '...';
-        document.getElementById('sessionId').textContent = effectiveRoom;
         log(`Joined Nostr room: ${effectiveRoom}`, 'success');
+        await nostrClient.send({ type: 'hello', session: mySessionNonce });
+
+        // Kick any peers we saw while selecting relays.
+        for (const peerId of deferredHelloPeers) {
+            await maybeProbePeer(peerId);
+        }
+        deferredHelloPeers.clear();
         
         updateStatus(true);
 
@@ -336,6 +793,18 @@ window.disconnect = function() {
     if (nostrClient) {
         nostrClient.disconnect().catch(() => {});
         nostrClient = null;
+        myPeerId = null;
+        mySessionNonce = null;
+        peerSessions.clear();
+        peerProbeState.clear();
+        readyPeers.clear();
+        pendingIce.clear();
+        peerConnections.forEach((pc) => {
+            if (pc instanceof RTCPeerConnection) pc.close();
+        });
+        peerConnections.clear();
+        dataChannels.clear();
+        updatePeerList();
     }
     if (client) {
         client.disconnect();
@@ -351,25 +820,71 @@ window.disconnect = function() {
 
 async function createPeerConnection(peerId, shouldInitiate) {
     if (peerConnections.has(peerId)) {
+        const existing = peerConnections.get(peerId);
+        if (existing instanceof RTCPeerConnection) {
             log(`Peer connection already exists for ${peerId.substring(0, 6)}...`, 'warning');
-        return peerConnections.get(peerId);
+            return existing;
+        }
+
+        // Placeholder entry (e.g., peer "seen" list). Replace it with a real RTCPeerConnection.
+        peerConnections.delete(peerId);
     }
 
         log(`Creating peer connection with ${peerId.substring(0, 6)}... (shouldInitiate: ${shouldInitiate})`, 'info');
 
     const pc = new RTCPeerConnection({
-        iceServers: [
-            { urls: ['stun:stun.l.google.com:19302', 'stun:stun1.l.google.com:19302'] }
-        ]
+        iceServers: ICE_SERVERS,
     });
 
+    // Register early to avoid races where answer/ICE arrives before this function finishes.
+    peerConnections.set(peerId, pc);
+    pendingIce.delete(peerId);
+    updatePeerList();
+
     pc.onicecandidate = (event) => {
-        if (event.candidate) {
-                log(`Sending ICE candidate to ${peerId.substring(0, 6)}...`, 'info');
+        if (!nostrClient && client && event.candidate) {
             client.sendIceCandidate(event.candidate, peerId);
+            return;
+        }
+
+        if (!nostrClient) return;
+
+        const entry = outboundIceBatches.get(peerId) || { candidates: [], timer: null };
+        outboundIceBatches.set(peerId, entry);
+
+        if (event.candidate) {
+            entry.candidates.push(event.candidate.toJSON?.() || event.candidate);
+        }
+
+        const flush = () => {
+            entry.timer = null;
+            if (!entry.candidates.length) return;
+            const batch = entry.candidates.splice(0, entry.candidates.length);
+            log(`Sending ICE batch (${batch.length}) to ${peerId.substring(0, 6)}...`, 'info');
+            sendSignal(peerId, { type: 'signal-ice-batch', candidates: batch }).catch((e) => {
+                log(`Failed to send ICE batch: ${e?.message || e}`, 'warning');
+            });
+        };
+
+        // If end-of-candidates, flush immediately; otherwise debounce.
+        if (!event.candidate) {
+            flush();
+            return;
+        }
+
+        if (!entry.timer) {
+            entry.timer = setTimeout(flush, 250);
         }
     };
 
+    pc.oniceconnectionstatechange = () => {
+        log(`ICE state (${peerId.substring(0, 6)}...): ${pc.iceConnectionState}`, 'info');
+    };
+
+    pc.onconnectionstatechange = () => {
+        log(`Conn state (${peerId.substring(0, 6)}...): ${pc.connectionState}`, 'info');
+    };
+
     pc.ondatachannel = (event) => {
             log(`Received data channel from ${peerId.substring(0, 6)}`, 'info');
         setupDataChannel(peerId, event.channel);
@@ -381,14 +896,20 @@ async function createPeerConnection(peerId, shouldInitiate) {
         
         const offer = await pc.createOffer();
         await pc.setLocalDescription(offer);
-        client.sendOffer(offer, peerId);
+        if (nostrClient) {
+            try {
+                await sendSignal(peerId, { type: 'signal-offer', sdp: { type: pc.localDescription.type, sdp: pc.localDescription.sdp } });
+                log(`Sent offer to ${peerId.substring(0, 6)}...`, 'success');
+            } catch (e) {
+                log(`Failed to send offer: ${e?.message || e}`, 'warning');
+            }
+        } else if (client) {
+            client.sendOffer(offer, peerId);
             log(`Sent offer to ${peerId.substring(0, 6)}...`, 'success');
+        }
     } else {
             log(`Waiting for offer from ${peerId.substring(0, 6)}...`, 'info');
     }
-
-    peerConnections.set(peerId, pc);
-    updatePeerList();
     return pc;
 }
 
@@ -416,17 +937,8 @@ window.sendChatMessage = function() {
         return;
     }
 
-    if (nostrClient) {
-        nostrClient.sendMessage(message).catch((e) => {
-            log(`Failed to send via Nostr: ${e?.message || e}`, 'error');
-        });
-        displayChatMessage(message, 'You', true);
-        document.getElementById('chatMessage').value = '';
-        return;
-    }
-
     if (dataChannels.size === 0) {
-        log('No peer connections available. Wait for data channels to open.', 'error');
+        log('No data channels yet. Open this room in another tab/browser and wait for WebRTC to connect.', 'error');
         return;
     }
 

package/src/nostr/nostrClient.js

@@ -15,7 +15,7 @@ function isHex64(s) {
  * - Publishes kind:1 events tagged with ['t', room] and ['room', room]
  * - Subscribes to kind:1 events filtered by #t
  */
-export function createNostrClient({ relayUrl, room, onMessage, onPeer, onState } = {}) {
+export function createNostrClient({ relayUrl, room, onPayload, onState, onNotice, onOk } = {}) {
   if (!relayUrl) throw new Error('relayUrl is required');
   if (!room) throw new Error('room is required');
 
@@ -29,20 +29,27 @@ export function createNostrClient({ relayUrl, room, onMessage, onPeer, onState }
     seen: new Set(),
   };
 
+  // Track NIP-20 OK responses by event id
+  const okWaiters = new Map();
+
   function ensureKeys() {
     if (state.pubkey && state.secretKeyHex) return;
 
-    let stored = localStorage.getItem('nostr-secret-key');
+    // IMPORTANT: For this demo we want each browser tab to have a distinct peer ID.
+    // sessionStorage is per-tab, while localStorage is shared across tabs.
+    const storageKey = 'nostr-secret-key-tab';
+    let stored = sessionStorage.getItem(storageKey);
+
     // If stored value looks like an array string from prior buggy storage, clear it
     if (stored && stored.includes(',')) {
-      localStorage.removeItem('nostr-secret-key');
+      sessionStorage.removeItem(storageKey);
       stored = null;
     }
 
     if (!isHex64(stored)) {
       const secretBytes = generateSecretKey();
       state.secretKeyHex = bytesToHex(secretBytes);
-      localStorage.setItem('nostr-secret-key', state.secretKeyHex);
+      sessionStorage.setItem(storageKey, state.secretKeyHex);
     } else {
       state.secretKeyHex = stored;
     }
@@ -74,12 +81,44 @@ export function createNostrClient({ relayUrl, room, onMessage, onPeer, onState }
     if (!Array.isArray(msg) || msg.length < 2) return;
     const [type] = msg;
 
+    if (type === 'NOTICE') {
+      try {
+        onNotice?.(msg[1]);
+      } catch {
+        // ignore
+      }
+      return;
+    }
+
+    // NIP-20: ["OK", <event_id>, <true|false>, <message>]
+    if (type === 'OK') {
+      const id = msg[1];
+      const ok = msg[2];
+      const message = msg[3];
+
+      const waiter = okWaiters.get(id);
+      if (waiter) {
+        okWaiters.delete(id);
+        waiter.resolve({ id, ok, message });
+      }
+      try {
+        onOk?.({ id, ok, message });
+      } catch {
+        // ignore
+      }
+      return;
+    }
+
     if (type === 'EVENT') {
       const nostrEvent = msg[2];
       if (!nostrEvent || typeof nostrEvent !== 'object') return;
       if (nostrEvent.id && state.seen.has(nostrEvent.id)) return;
       if (nostrEvent.id) state.seen.add(nostrEvent.id);
 
+      // Ignore our own events
+      if (nostrEvent.pubkey && nostrEvent.pubkey === state.pubkey) return;
+
+
       // Ensure it's for our room
       const tags = Array.isArray(nostrEvent.tags) ? nostrEvent.tags : [];
       const roomTag = tags.find((t) => Array.isArray(t) && t[0] === 'room');
@@ -93,22 +132,15 @@ export function createNostrClient({ relayUrl, room, onMessage, onPeer, onState }
         return;
       }
 
-      if (payload?.type === 'peer-join' && payload.peerId) {
-        try {
-          onPeer?.({ peerId: payload.peerId });
-        } catch {
-          // ignore
-        }
-        return;
-      }
-
-      if (payload?.type === 'message' && typeof payload.message === 'string') {
-        const from = (payload.peerId || nostrEvent.pubkey || 'peer').substring(0, 8) + '...';
-        try {
-          onMessage?.({ from, text: payload.message });
-        } catch {
-          // ignore
-        }
+      try {
+        onPayload?.({
+          from: nostrEvent.pubkey,
+          payload,
+          eventId: nostrEvent.id,
+          createdAt: nostrEvent.created_at,
+        });
+      } catch {
+        // ignore
       }
     }
   }
@@ -153,44 +185,24 @@ export function createNostrClient({ relayUrl, room, onMessage, onPeer, onState }
     const filter = {
       kinds: [1],
       '#t': [state.room],
-      since: now - 3600,
+      // Use a wider window to tolerate clock skew; app layer filters stale via session nonces.
+      since: now - 600,
       limit: 200,
     };
 
     sendRaw(['REQ', state.subId, filter]);
 
-    // Announce presence
-    await sendJoin();
-
     setState('connected');
   }
 
-  async function sendJoin() {
+  async function send(payload) {
     ensureKeys();
-    const created_at = Math.floor(Date.now() / 1000);
-    const tags = [
-      ['room', state.room],
-      ['t', state.room],
-    ];
-
-    const eventTemplate = {
-      kind: 1,
-      created_at,
-      tags,
-      content: JSON.stringify({
-        type: 'peer-join',
-        peerId: state.pubkey,
-        room: state.room,
-        timestamp: Date.now(),
-      }),
-      pubkey: state.pubkey,
-    };
-
-    const signed = finalizeEvent(eventTemplate, state.secretKeyHex);
+    const signed = buildSignedEvent(payload);
     sendRaw(['EVENT', signed]);
+    return signed.id;
   }
 
-  async function sendMessage(text) {
+  function buildSignedEvent(payload) {
     ensureKeys();
     const created_at = Math.floor(Date.now() / 1000);
     const tags = [
@@ -203,17 +215,36 @@ export function createNostrClient({ relayUrl, room, onMessage, onPeer, onState }
       created_at,
       tags,
       content: JSON.stringify({
-        type: 'message',
-        message: text,
-        peerId: state.pubkey,
+        ...payload,
+        from: state.pubkey,
         room: state.room,
         timestamp: Date.now(),
       }),
       pubkey: state.pubkey,
     };
 
-    const signed = finalizeEvent(eventTemplate, state.secretKeyHex);
+    return finalizeEvent(eventTemplate, state.secretKeyHex);
+  }
+
+  async function sendWithOk(payload, { timeoutMs = 4000 } = {}) {
+    const signed = buildSignedEvent(payload);
+
+    const okPromise = new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        okWaiters.delete(signed.id);
+        reject(new Error('Timed out waiting for relay OK'));
+      }, timeoutMs);
+
+      okWaiters.set(signed.id, {
+        resolve: (v) => {
+          clearTimeout(timer);
+          resolve(v);
+        },
+      });
+    });
+
     sendRaw(['EVENT', signed]);
+    return await okPromise;
   }
 
   async function disconnect() {
@@ -237,7 +268,8 @@ export function createNostrClient({ relayUrl, room, onMessage, onPeer, onState }
   return {
     connect,
     disconnect,
-    sendMessage,
+    send,
+    sendWithOk,
     getPublicKey: getPublicKeyHex,
   };
 }

package/wrangler.toml

@@ -1,27 +1,2 @@
-name = "uniwrtc"
-main = "src/index.js"
-compatibility_date = "2024-12-20"
-
-assets = { directory = "./dist", binding = "ASSETS" }
-
-[[durable_objects.bindings]]
-name = "ROOMS"
-class_name = "Room"
-
-[[migrations]]
-tag = "v1"
-new_classes = ["Room"]
-
-[env.production]
-routes = [
-  { pattern = "signal.peer.ooo/*", zone_name = "peer.ooo" }
-]
-
-assets = { directory = "./dist", binding = "ASSETS" }
-
-[[env.production.durable_objects.bindings]]
-name = "ROOMS"
-class_name = "Room"
-
-[build]
-command = "npm install"
+name = "signal-peer-ooo"
+pages_build_output_dir = "dist"