@dotrino/lobby 0.3.0 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/lobby",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Lobby + matchmaking reciclable para juegos del ecosistema Dotrino: salas, asientos, espectadores, motor de turnos autoritativo, reputación y contactos sobre el proxy/identity/reputation compartidos",
   "type": "module",
   "main": "src/index.js",
@@ -31,8 +31,8 @@
     "web-of-trust"
   ],
   "peerDependencies": {
-    "@dotrino/proxy-client": ">=0.1.0",
     "@dotrino/identity": ">=0.5.0",
+    "@dotrino/proxy-client": "^0.10.0",
     "@dotrino/reputation": ">=0.3.0"
   },
   "peerDependenciesMeta": {

package/src/index.js

@@ -11,5 +11,5 @@ export {
   createRepGate, rankRooms, ratePlayer,
   receiptPayload, signReceiptHalf
 } from './reputation.js'
-export { K, discoveryChannel, roomChannel, setLobbyHomeNode, envelope, parseEnvelope } from './protocol.js'
+export { K, discoveryChannel, discoveryChannels, roomChannel, envelope, parseEnvelope } from './protocol.js'
 export { Emitter, mulberry32, hashSeed, shuffle, normalizeSeats, samePubkey } from './util.js'

package/src/lobby.js

@@ -3,7 +3,7 @@
 // por reputación, e invita contactos por pubkey (cola offline).
 
 import { Emitter, normalizeSeats } from './util.js'
-import { K, envelope, discoveryChannel } from './protocol.js'
+import { K, envelope, discoveryChannel, discoveryChannels } from './protocol.js'
 import { Transport } from './transport.js'
 import { Room, STATUS } from './room.js'
 import { createRepGate, rankRooms } from './reputation.js'
@@ -28,21 +28,44 @@ export class Lobby extends Emitter {
       if (env.k === K.INFO) { if (this._infoCollector) this._infoCollector(from, env.d && env.d.summary) }
       else if (env.k === K.INVITE) this.emit('invite', { from, ...(env.d || {}) })
     })
-    const dc = discoveryChannel(this.gameId)
+    // Hay un canal de descubrimiento POR NODO (ver protocol.js): el
+    // descubrimiento no tiene dueño natural, así que en vez de designar un nodo
+    // árbitro se publica en el propio y se lee de todos.
+    const esDescubrimiento = (channel) => this._discoveryChannels().includes(channel)
     // Descubrimiento en vivo: requiere observar el canal (watch) para recibir
     // estos eventos sin publicarnos como sala. Si el proxy no soporta watch,
     // _watchDiscovery degrada a no-op y la app sigue con su polling de respaldo.
-    this.transport.on('channel_joined', (channel, token) => { if (channel === dc && token !== this.transport.token) this.emit('rooms-changed', { type: 'joined', token }) })
-    this.transport.on('channel_left', (channel, token) => { if (channel === dc) this.emit('rooms-changed', { type: 'left', token }) })
-    this.transport.on('peer_disconnected', (token, channel) => { if (!channel || channel === dc) this.emit('rooms-changed', { type: 'left', token }) })
+    this.transport.on('channel_joined', (channel, token) => { if (esDescubrimiento(channel) && token !== this.transport.token) this.emit('rooms-changed', { type: 'joined', token }) })
+    this.transport.on('channel_left', (channel, token) => { if (esDescubrimiento(channel)) this.emit('rooms-changed', { type: 'left', token }) })
+    this.transport.on('peer_disconnected', (token, channel) => { if (!channel || esDescubrimiento(channel)) this.emit('rooms-changed', { type: 'left', token }) })
     this.transport.on('reconnect', () => this._watchDiscovery())
     this._watchDiscovery()
   }
 
-  // Observar el canal de descubrimiento para recibir altas/bajas de salas en vivo
-  // (proxy ≥ 0.6.2). Fire-and-forget: no bloquea ni rompe si no está soportado.
+  /** Los nodos que conoce el proxio al que estamos conectados (él incluido). */
+  _knownNodes () {
+    const t = this.transport
+    return (t && (t.knownNodes || (t.client && t.client.knownNodes))) || []
+  }
+
+  /** Un canal de descubrimiento por nodo conocido. */
+  _discoveryChannels () {
+    return discoveryChannels(this.gameId, this._knownNodes())
+  }
+
+  /** El canal donde ANUNCIAMOS: el del proxio al que estamos conectados. */
+  _myDiscoveryChannel () {
+    const t = this.transport
+    return discoveryChannel(this.gameId, (t && (t.node || (t.client && t.client.node))) || null)
+  }
+
+  // Observar los canales de descubrimiento para recibir altas/bajas de salas en
+  // vivo (proxy ≥ 0.6.2). Fire-and-forget: no bloquea ni rompe si no está
+  // soportado. Son N canales, uno por nodo conocido — hoy dos.
   _watchDiscovery () {
-    try { this.transport.watch(discoveryChannel(this.gameId)) } catch (_) {}
+    for (const ch of this._discoveryChannels()) {
+      try { this.transport.watch(ch) } catch (_) {}
+    }
   }
 
   // ── Crear / unir ────────────────────────────────────────────────
@@ -77,8 +100,13 @@ export class Lobby extends Emitter {
   async listRooms (opts = {}) {
     await this.transport.connect()
     const timeout = opts.timeout || 1500
-    let tokens = []
-    try { tokens = await this.transport.list(discoveryChannel(this.gameId)) } catch (_) {}
+    // Se pregunta en CADA nodo y se mezcla. Un nodo que no conteste no rompe la
+    // lista: se ven las salas de los demás, que es justo lo que se gana al no
+    // tener un nodo árbitro.
+    const listas = await Promise.all(this._discoveryChannels().map(
+      (ch) => this.transport.list(ch).catch(() => [])
+    ))
+    const tokens = [...new Set(listas.flat())]
     const others = tokens.filter(t => t && t !== this.transport.token)
     const summaries = await this._gatherInfo(others, timeout)
     if (opts.enrich === false) return summaries

package/src/protocol.js

@@ -49,35 +49,56 @@ export const K = {
 /**
  * NODO DUEÑO DE LOS CANALES.
  *
- * Un canal del proxio puede llevar delante el prefijo del nodo que lo hospeda
+ * Un canal del proxio lleva delante el id del nodo que lo hospeda
  * (`<id de 12>/loquesea`). Ese nodo guarda la membresía y los demás le pasan las
- * operaciones. Sin prefijo, cada proxio tiene su propia copia del canal — que es
- * lo que hacía que dos personas en proxios distintos NO se vieran en la misma
- * lista de salas, aunque los mensajes entre ellas sí cruzaran.
+ * operaciones. Sin ese prefijo, cada proxio tiene su propia copia del canal.
  *
- * El **canal de descubrimiento** es uno solo para todo el ecosistema, así que
- * tiene que vivir en un nodo fijo: si cada quien lo publicara en el suyo,
- * habría tantas listas de salas como proxios. Se fija con `setLobbyHomeNode()`
- * pasándole el id del proxio elegido (se lee de `client.node`). Mientras no se
- * fije, el descubrimiento es local a cada proxio.
+ * Los dos canales del lobby resuelven su dueño de forma distinta, y la razón es
+ * que uno tiene dueño natural y el otro no:
+ *
+ *   · LA SALA lo tiene: vive en el proxio de quien la abrió, y eso se LEE del
+ *     propio `roomId` (que es la instancia del host y lleva su id delante). Nadie
+ *     lo declara ni lo acuerda.
+ *
+ *   · EL DESCUBRIMIENTO no: es un nombre global del ecosistema y no lo crea
+ *     nadie en particular. Poner el id del primero que llegue no sirve — el
+ *     segundo host, en otro proxio, crearía otro canal y volverían a ser dos
+ *     listas.
+ *
+ * Para el descubrimiento se eligió NO designar un árbitro: **cada proxio tiene su
+ * lista y quien busca pregunta en todos**. Se publica en uno, se lee de varios.
+ * Así no hay punto único de fallo (si un nodo no contesta, se ven las salas de
+ * los demás) ni nadie que decida dónde vive la lista del ecosistema. El costo es
+ * una consulta por nodo, y lo paga el CLIENTE —no el servidor— así que no
+ * reaparece el fan-out en el proxio, que ya habíamos descartado.
  */
 const NODE_ID_LEN = 12
+// Comprueba la FORMA, no el alfabeto exacto, y es a propósito: el alfabeto lo
+// decide el proxio (que excluye los caracteres confundibles) y esta librería no
+// tiene por qué llevar una copia que se desincronice. Un id con un símbolo que
+// el proxio no emite simplemente no va a coincidir con ningún nodo.
 const isNodeId = (s) => new RegExp(`^[1-9A-Z]{${NODE_ID_LEN}}$`).test(String(s || ''))
 
-// Sin valor por defecto: el id de un proxio se DERIVA de su llave, así que no
-// hay ninguno que se pueda escribir aquí de antemano. Mientras no se fije, el
-// canal de descubrimiento es local a cada proxio (comportamiento de siempre).
-let LOBBY_HOME_NODE = null
-
-/** Fija en qué proxio vive el canal de descubrimiento de salas. */
-export function setLobbyHomeNode (nodeId) {
-  LOBBY_HOME_NODE = isNodeId(nodeId) ? nodeId : null
-}
-
 const withNode = (prefix, name) => (prefix ? `${prefix}/${name}` : name)
 
-/** Canal de descubrimiento de salas de un juego (lista instancias de hosts). */
-export const discoveryChannel = (gameId) => withNode(LOBBY_HOME_NODE, `cclobby/${gameId}`)
+/**
+ * Canal de descubrimiento de un juego EN UN NODO concreto.
+ * Sin `nodeId` (proxio sin identidad, o dev) devuelve el nombre pelado, que el
+ * servidor trata como canal local — el comportamiento de siempre.
+ */
+export const discoveryChannel = (gameId, nodeId) =>
+  withNode(isNodeId(nodeId) ? nodeId : null, `cclobby/${gameId}`)
+
+/**
+ * Todos los canales de descubrimiento a consultar: el del propio proxio y el de
+ * cada nodo que conozca. Se deduplica y se deja el propio PRIMERO, porque es el
+ * que va a contestar más rápido y el que se usa para publicar.
+ */
+export function discoveryChannels (gameId, nodeIds = []) {
+  const ids = nodeIds.filter((n, i, a) => isNodeId(n) && a.indexOf(n) === i)
+  if (!ids.length) return [`cclobby/${gameId}`]
+  return ids.map((id) => discoveryChannel(gameId, id))
+}
 
 /**
  * Canal de presencia de una sala concreta (host + guests publican aquí).

package/src/room.js

@@ -114,20 +114,30 @@ export class Room extends Emitter {
     this._members.set(this.transport.token, { pubkey: this.myPubkey, name: this.myName, verified: true, lastSeen: clock.now() })
     this._wire()
     // Anunciarse: canal de descubrimiento + canal de presencia de la sala.
-    try { await this.transport.publish(discoveryChannel(this.gameId), { roomName: this.name, gameType: this.gameId }) } catch (_) {}
+    try { await this.transport.publish(this._myDiscoveryChannel(), { roomName: this.name, gameType: this.gameId }) } catch (_) {}
     try { await this.transport.publish(roomChannel(this.gameId, this.roomId)) } catch (_) {}
     this._startHeartbeat()
     this._afterStateChange()
     return this
   }
 
+  /**
+   * El canal de descubrimiento donde ANUNCIAMOS esta sala: el del proxio al que
+   * estamos conectados. Se publica en uno solo (el propio) y quien busca lee de
+   * todos — así el descubrimiento no necesita un nodo árbitro. Ver protocol.js.
+   */
+  _myDiscoveryChannel () {
+    const t = this.transport
+    return discoveryChannel(this.gameId, (t && (t.node || (t.client && t.client.node))) || null)
+  }
+
   // Re-publica la sala periódicamente: las entradas de canal del proxy expiran
   // (~20 min), así que sin esto una sala desaparecería del descubrimiento en
   // partidas largas. Reemplaza el _republish casero que hacían los bots.
   _startHeartbeat () {
     if (this._heartbeat) clearInterval(this._heartbeat)
     this._heartbeat = setInterval(() => {
-      this.transport.publish(discoveryChannel(this.gameId), { roomName: this.name, gameType: this.gameId }).catch(() => {})
+      this.transport.publish(this._myDiscoveryChannel(), { roomName: this.name, gameType: this.gameId }).catch(() => {})
       this.transport.publish(roomChannel(this.gameId, this.roomId)).catch(() => {})
     }, 10 * 60 * 1000)
     if (this._heartbeat.unref) this._heartbeat.unref()
@@ -792,7 +802,7 @@ export class Room extends Emitter {
         }, 20000)
         if (this._rekeyTimer.unref) this._rekeyTimer.unref()
       }
-      this.transport.publish(discoveryChannel(this.gameId), { roomName: this.name, gameType: this.gameId }).catch(() => {})
+      this.transport.publish(this._myDiscoveryChannel(), { roomName: this.name, gameType: this.gameId }).catch(() => {})
       this.transport.publish(roomChannel(this.gameId, this.roomId)).catch(() => {})
       this._afterStateChange() // re-difundir estado a los miembros vivos
     } else {

package/src/transport.js

@@ -46,6 +46,10 @@ export class Transport extends Emitter {
   }
 
   get token () { return this.proxy ? this.proxy.token : null }
+  /** Id del proxio al que estamos conectados (12 chars, derivado de su llave). */
+  get node () { return this.proxy ? (this.proxy.node || null) : null }
+  /** Ese proxio + los que conoce. Es a quiénes se les pregunta por salas. */
+  get knownNodes () { return (this.proxy && this.proxy.knownNodes) || [] }
   get isReady () { return this._ready && !!this.token }
 
   /** Conecta (si hace falta) e identifica con el vault. Idempotente. */