@dotrino/lobby 0.1.5

package/src/transport.js

@@ -0,0 +1,156 @@
+// Transporte de lobby: una sola conexión al proxy Dotrino, reutilizable por
+// todas las salas/juegos de la app. Encapsula connect + identify (firmado por el
+// vault), canales, envío y el demux de mensajes namespaced por gameId.
+//
+// NO abre una conexión nueva si ya hay una: usa el singleton del proxy-client,
+// igual que el messenger. La identidad de red coincide con la de firma (identify
+// con sobre firmado por id.signData), lo que habilita la cola offline.
+
+import { Emitter, clock } from './util.js'
+import { parseEnvelope } from './protocol.js'
+
+let _defaultGetClient = null
+let _defaultIdentityConnect = null
+
+// Carga perezosa de los paquetes del ecosistema (peer deps). Permite testear con
+// transportes inyectados sin requerir los paquetes instalados.
+async function loadProxyFactory () {
+  if (_defaultGetClient) return _defaultGetClient
+  const mod = await import('@dotrino/proxy-client')
+  _defaultGetClient = mod.getWebSocketProxyClient
+  return _defaultGetClient
+}
+async function loadIdentity () {
+  if (_defaultIdentityConnect) return _defaultIdentityConnect
+  const mod = await import('@dotrino/identity')
+  _defaultIdentityConnect = mod.Identity.connect.bind(mod.Identity)
+  return _defaultIdentityConnect
+}
+
+export class Transport extends Emitter {
+  /**
+   * @param {object} opts
+   * @param {object} [opts.proxy]    cliente proxy ya creado (si no, se usa el singleton)
+   * @param {object} [opts.identity] instancia de Identity ya conectada (para identify/firmas)
+   * @param {string} [opts.url]      URL del proxy
+   */
+  constructor (opts = {}) {
+    super()
+    this.proxy = opts.proxy || null
+    this.identity = opts.identity || null
+    this.url = opts.url || null
+    this._ready = false
+    this._wired = false
+    this._connecting = null
+    this._subs = new Map() // gameId → Set<fn(from, env, meta)>
+  }
+
+  get token () { return this.proxy ? this.proxy.token : null }
+  get isReady () { return this._ready && !!this.token }
+
+  /** Conecta (si hace falta) e identifica con el vault. Idempotente. */
+  async connect () {
+    if (this.isReady) return this.token
+    if (this._connecting) return this._connecting
+    this._connecting = (async () => {
+      if (!this.proxy) {
+        const getClient = await loadProxyFactory()
+        this.proxy = getClient(this.url ? { url: this.url } : undefined)
+      }
+      if (this.url && this.proxy.updateConfig) this.proxy.updateConfig({ url: this.url })
+      if (!this.identity) {
+        try { const connect = await loadIdentity(); this.identity = await connect() } catch (_) { this.identity = null }
+      }
+      this._wire()
+      await this.proxy.connect()
+      await this._identify()
+      this._ready = true
+      this.emit('ready', this.token)
+      return this.token
+    })()
+    try { return await this._connecting } finally { this._connecting = null }
+  }
+
+  _wire () {
+    if (this._wired) return
+    this._wired = true
+
+    // Reconexión: el proxy reasigna token; reidentificamos y avisamos para que
+    // las salas vuelvan a anunciarse / re-saludar.
+    let firstToken = false
+    this.proxy.on('token', async () => {
+      if (!firstToken) { firstToken = true; return } // el primer token lo maneja connect()
+      try { await this._identify() } catch (e) { console.warn('[lobby] re-identify falló:', e) }
+      this.emit('reconnect', this.token)
+      this.emit('ready', this.token)
+    })
+
+    this.proxy.on('message', (from, payload, meta) => {
+      const env = parseEnvelope(payload)
+      if (!env) return
+      const subs = this._subs.get(env.g)
+      if (!subs || !subs.size) return
+      for (const fn of [...subs]) {
+        try { fn(from, env, meta) } catch (e) { console.error('[lobby] sub handler error:', e) }
+      }
+    })
+
+    // Eventos de presencia (no namespaced; las salas filtran por canal).
+    this.proxy.on('peer_disconnected', (token, channel) => this.emit('peer_disconnected', token, channel || null))
+    this.proxy.on('channel_joined', (channel, token) => this.emit('channel_joined', channel, token))
+    this.proxy.on('channel_left', (channel, token) => this.emit('channel_left', channel, token))
+    this.proxy.on('disconnect', (d) => this.emit('disconnect', d))
+  }
+
+  async _identify () {
+    if (!this.identity || !this.proxy || !this.proxy.token) return
+    const me = this.identity.me
+    const publickey = me && me.publickey
+    if (!publickey) return
+    const data = { op: 'identify', publickey, token: this.proxy.token, ts: clock.now() }
+    const signed = await this.identity.signData(data)
+    const signature = typeof signed === 'string' ? signed : signed.signature
+    await this.proxy.identify({ data, signature })
+  }
+
+  /** Demultiplexor: registra un handler para un gameId. Devuelve desuscriptor. */
+  subscribe (gameId, fn) {
+    let set = this._subs.get(gameId)
+    if (!set) { set = new Set(); this._subs.set(gameId, set) }
+    set.add(fn)
+    return () => { const s = this._subs.get(gameId); if (s) s.delete(fn) }
+  }
+
+  /** Envío directo por token (intenta WebRTC, cae a proxy). */
+  send (to, env) { this.proxy.send(to, env) }
+
+  /** Envío por pubkey estable (cola offline 24 h). Para invitaciones a contactos. */
+  sendByPubkey (pubkeys, env) { this.proxy.sendByPubkey(pubkeys, env) }
+
+  // ── Canales ────────────────────────────────────────────────────
+  publish (channel, extra) { return this.proxy.publish(channel, extra) }
+  unpublish (channel) { return this.proxy.unpublish(channel) }
+  list (channel) { return this.proxy.list(channel) }
+  listChannels (options) { return this.proxy.listChannels(options) }
+  channelCount (channel) { return this.proxy.channelCount(channel) }
+
+  // Observación read-only de un canal (proxy ≥ 0.6.2). Degrada elegante: si el
+  // cliente/proxy no lo soporta o no responde, resuelve sin colgar (la app cae a
+  // polling). Nunca bloquea ni rechaza hacia arriba.
+  watch (channel) {
+    if (!this.proxy || typeof this.proxy.watch !== 'function') return Promise.resolve(null)
+    return Promise.race([
+      this.proxy.watch(channel).catch(() => null),
+      new Promise(res => { const t = setTimeout(() => res(null), 4000); if (t.unref) t.unref() })
+    ])
+  }
+
+  unwatch (channel) {
+    if (!this.proxy || typeof this.proxy.unwatch !== 'function') return Promise.resolve(null)
+    return this.proxy.unwatch(channel).catch(() => null)
+  }
+
+  // ── WebRTC (opcional, para partidas de baja latencia) ─────────
+  connectWebRTC (token) { return this.proxy.connectWebRTC(token) }
+  isWebRTCOpen (token) { return this.proxy.isWebRTCOpen(token) }
+}

package/src/util.js

@@ -0,0 +1,127 @@
+// Utilidades internas de @dotrino/lobby.
+// Sin dependencias: EventEmitter mínimo, RNG determinista sembrado,
+// normalización de asientos y helpers varios.
+
+/**
+ * EventEmitter mínimo (navegador + node). on() devuelve un desuscriptor.
+ * Los errores en un handler no rompen al resto de handlers.
+ */
+export class Emitter {
+  constructor () { this._h = new Map() }
+
+  on (event, handler) {
+    if (typeof handler !== 'function') return () => {}
+    let set = this._h.get(event)
+    if (!set) { set = new Set(); this._h.set(event, set) }
+    set.add(handler)
+    return () => this.off(event, handler)
+  }
+
+  once (event, handler) {
+    const off = this.on(event, (...args) => { off(); handler(...args) })
+    return off
+  }
+
+  off (event, handler) {
+    const set = this._h.get(event)
+    if (set) set.delete(handler)
+  }
+
+  emit (event, ...args) {
+    const set = this._h.get(event)
+    if (!set) return
+    for (const h of [...set]) {
+      try { h(...args) } catch (e) { console.error(`[lobby] handler error on "${event}":`, e) }
+    }
+  }
+
+  removeAllListeners () { this._h.clear() }
+}
+
+/** Reloj inyectable (los tests pueden sustituirlo). */
+export const clock = { now: () => Date.now() }
+
+/**
+ * PRNG determinista (mulberry32). Devuelve floats en [0,1).
+ * Misma semilla ⇒ misma secuencia, en cualquier máquina. Esto permite que el
+ * host genere azar (barajar/dados) de forma reproducible y verificable.
+ * @param {number} seed entero de 32 bits
+ */
+export function mulberry32 (seed) {
+  let a = seed >>> 0
+  return function rng () {
+    a |= 0; a = (a + 0x6D2B79F5) | 0
+    let t = Math.imul(a ^ (a >>> 15), 1 | a)
+    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296
+  }
+}
+
+/** Hash de string → entero de 32 bits (FNV-1a). Para derivar semillas de seeds string. */
+export function hashSeed (str) {
+  let h = 0x811c9dc5
+  const s = String(str)
+  for (let i = 0; i < s.length; i++) {
+    h ^= s.charCodeAt(i)
+    h = Math.imul(h, 0x01000193)
+  }
+  return h >>> 0
+}
+
+/** Baraja Fisher–Yates in-place usando un rng() dado (no muta el original si se pasa copia). */
+export function shuffle (array, rng) {
+  for (let i = array.length - 1; i > 0; i--) {
+    const j = Math.floor(rng() * (i + 1))
+    const tmp = array[i]; array[i] = array[j]; array[j] = tmp
+  }
+  return array
+}
+
+/** Clon profundo (structuredClone si existe; si no, JSON). */
+export function clone (value) {
+  if (value == null) return value
+  try {
+    if (typeof structuredClone === 'function') return structuredClone(value)
+  } catch (_) { /* fall through */ }
+  return JSON.parse(JSON.stringify(value))
+}
+
+/**
+ * Normaliza la especificación de asientos a una forma canónica.
+ *  - Array de ids  → asientos nombrados (p.ej. ['white','black']).
+ *  - { min, max }  → genera ids 's1'..'sN'.
+ * @returns {{ ids: string[], min: number, max: number, named: boolean }}
+ */
+export function normalizeSeats (spec) {
+  if (Array.isArray(spec)) {
+    if (!spec.length) throw new Error('[lobby] seats: el array de asientos no puede estar vacío')
+    const ids = spec.map(String)
+    return { ids, min: ids.length, max: ids.length, named: true }
+  }
+  const max = Math.max(1, (spec && (spec.max ?? spec.min)) || 2)
+  const min = Math.max(1, Math.min(max, (spec && spec.min) || max))
+  const ids = Array.from({ length: max }, (_, i) => 's' + (i + 1))
+  return { ids, min, max, named: false }
+}
+
+/** Igualdad de pubkeys tolerante a diferencias de formato JWK (orden de claves). */
+export function samePubkey (a, b) {
+  if (!a || !b) return false
+  if (a === b) return true
+  try {
+    const pa = typeof a === 'string' ? JSON.parse(a) : a
+    const pb = typeof b === 'string' ? JSON.parse(b) : b
+    return pa && pb && pa.x === pb.x && pa.y === pb.y && pa.crv === pb.crv
+  } catch (_) { return false }
+}
+
+/** Promesa que resuelve tras `ms`. */
+export function delay (ms) { return new Promise(r => setTimeout(r, ms)) }
+
+/** Id corto aleatorio (no criptográfico) para correlación de mensajes. */
+export function shortId () {
+  try {
+    if (typeof crypto !== 'undefined' && crypto.randomUUID) return crypto.randomUUID().slice(0, 8)
+  } catch (_) {}
+  return Math.floor(Math.random() * 0xffffffff).toString(36)
+}