@sloev/trystero-corvax 0.0.0-stage → 0.1.17

package/README.md

@@ -1,3 +1,27 @@
-# Temporary Holding Version
+# @sloev/trystero-corvax
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[Trystero](https://github.com/dmotz/trystero) signalling over [CORVAX](https://github.com/sloev/CORVAX): no relay server, nothing to configure.
+
+```sh
+npm i @trystero-p2p/core @sloev/trystero-corvax
+```
+
+```js
+import { joinRoom } from '@sloev/trystero-corvax'
+
+const room = joinRoom({ appId: 'my-app' }, 'lobby')
+room.onPeerJoin(({ peerId }) => console.log('joined', peerId))
+```
+
+Browsers without a bundler: `import { joinRoom } from 'https://cdn.jsdelivr.net/npm/@sloev/trystero-corvax/+esm'`.
+
+**How it signals** (peer to peer):
+
+- **Members:** CORVAX topic presence on the room's topic: signed leases kept by many storage peers, not one server.
+- **Announce:** flooded over the room's CORVAX mesh, and sealed straight to each member through that member's own inbox anchors.
+- **Offers, answers, candidates:** over a CORVAX mesh link to that peer when there is one (no anchor at all), otherwise to its inboxes. Senders are verified by signature.
+- **Once a room's mesh exists, it no longer needs any anchor:** reconnects re-signal over the mesh.
+
+Trystero encrypts its signals with the room key, and CORVAX seals them again for the one recipient. Joining took 0.3 s between two Chromium tabs in our tests.
+
+Options: `joinRoom({ appId, corvax: { peer, ...Peer.create options } }, roomId)`. Pass `corvax.peer` to share an existing CORVAX peer.

package/index.js

@@ -0,0 +1,96 @@
+// @sloev/trystero-corvax: a Trystero signalling transport on CORVAX, peer to peer (SPEC §10).
+//   room members  → CORVAX topic presence on the room's root topic (signed leases on storage peers, any peer)
+//   announce      → a topic broadcast over the room's CORVAX mesh, and a sealed message to each member's inboxes
+//   signal        → over a CORVAX mesh link to that peer when there is one (no anchor), else to its inboxes
+// Trystero encrypts its signals with the room key; CORVAX seals them again for the one recipient.
+import { createTopicStrategy } from '@trystero-p2p/core'
+import { Peer } from '@sloev/corvax'
+
+export { clearUserIdentity, createUserIdentity, exportUserIdentity, importUserIdentity, roles, scale } from '@trystero-p2p/core'
+
+const peers = new Map()                         // options key → Promise<Peer>: one CORVAX peer per tab or process
+const TAG = 'tr1'
+
+// The CORVAX peer behind this transport: one per tab (sessionStorage seed), or pass your own as corvax.peer.
+export function corvaxPeer ({ peer, ...options } = {}) {
+  if (peer) return Promise.resolve(peer)
+  const key = JSON.stringify(options)
+  if (!peers.has(key)) peers.set(key, (async () => {
+    let seed = null
+    try { seed = sessionStorage.getItem('corvax.trystero') } catch {}
+    const p = await Peer.create({ seed, ...options })
+    try { sessionStorage.setItem('corvax.trystero', p.seed) } catch {}
+    wire(p)
+    return p
+  })())
+  return peers.get(key)
+}
+
+// Per CORVAX peer: Trystero topic → handlers; peer topic → CORVAX address (learned from signed messages).
+function wire (p) {
+  if (p.trystero) return p.trystero
+  const s = p.trystero = { handlers: new Map(), routes: new Map(), rooms: new Map(), early: [] }
+  const deliver = (from, body) => {
+    if (body?.[TAG] !== 1 || typeof body.t !== 'string' || typeof body.st !== 'string') return
+    s.routes.set(body.st, from)                                  // reply path: their topic → their verified address
+    const fns = s.handlers.get(body.t)
+    if (fns?.size) for (const fn of fns) fn(body.t, body.m)
+    else s.early = [...s.early.filter(e => Date.now() - e.at < 10e3), { at: Date.now(), body }].slice(-64)   // before we subscribed
+  }
+  p.on(({ from, body }) => deliver(from, body))
+  s.deliver = deliver
+  return s
+}
+
+// A CORVAX topic per Trystero root topic: members (presence), a mesh (links), and the last announce to repeat.
+async function room (p, s, root) {
+  if (s.rooms.has(root)) return s.rooms.get(root)
+  const r = { members: new Set(), announce: null, topic: await p.topic('trystero:' + root) }
+  s.rooms.set(root, r)
+  r.off = r.topic.subscribe({
+    presence: e => {
+      if (e.presence !== 'recent') return r.members.delete(e.address)
+      if (r.members.has(e.address)) return
+      r.members.add(e.address)
+      if (r.announce) send(p, e.address, r.announce)             // a newcomer hears from us at once, not in 60 s
+    },
+    message: m => s.deliver(m.from, m.body)                      // announces flooded over the room's mesh
+  })
+  await r.topic.publish()
+  return r
+}
+
+const send = (p, address, body) => p.topics.sendVia(address, body) || p.send(address, body).catch(() => {})
+
+export const joinRoom = createTopicStrategy({
+  init: config => corvaxPeer(config.corvax),
+
+  subscribeTopic: async (p, topic, onMessage, { kind, rootTopic }) => {
+    const s = wire(p)
+    if (!s.handlers.has(topic)) s.handlers.set(topic, new Set())
+    s.handlers.get(topic).add(onMessage)
+    for (const e of s.early.filter(e => e.body.t === topic && Date.now() - e.at < 10e3)) onMessage(topic, e.body.m)
+    s.early = s.early.filter(e => e.body.t !== topic)
+    if (kind === 'root') await room(p, s, rootTopic)
+    return () => {
+      s.handlers.get(topic)?.delete(onMessage)
+      if (kind !== 'root' || s.handlers.get(topic)?.size) return
+      const r = s.rooms.get(rootTopic)
+      s.rooms.delete(rootTopic)
+      r?.off(); r?.topic.close().catch(() => {})
+    }
+  },
+
+  publishTopic: async (p, topic, msg, { kind, rootTopic, selfTopic }) => {
+    const s = wire(p), body = { [TAG]: 1, t: topic, st: selfTopic, m: msg }
+    if (kind === 'announce') {
+      const r = await room(p, s, rootTopic)
+      r.announce = body
+      r.topic.broadcast(body).catch(() => {})                   // over the mesh, if we have links
+      for (const address of r.members) send(p, address, body)    // and straight to each member
+      return
+    }
+    const address = s.routes.get(topic)                          // signals answer someone we heard from
+    if (address) send(p, address, body)
+  }
+})

package/package.json

@@ -1,6 +1,34 @@
 {
   "name": "@sloev/trystero-corvax",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.17",
+  "description": "Trystero signalling over CORVAX: peer to peer, no relay server; rooms keep re-signalling over their own mesh.",
+  "type": "module",
+  "exports": "./index.js",
+  "files": [
+    "index.js",
+    "README.md"
+  ],
+  "dependencies": {
+    "@sloev/corvax": "^0.1.17"
+  },
+  "peerDependencies": {
+    "@trystero-p2p/core": ">=0.27.0 <0.28.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sloev/CORVAX.git",
+    "directory": "trystero"
+  },
+  "homepage": "https://corvax.sloev.workers.dev/",
+  "keywords": [
+    "trystero",
+    "webrtc",
+    "p2p",
+    "signalling",
+    "corvax"
+  ],
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  }
+}