@stone-wpp/ofc 1.0.6 → 1.0.7

package/lib/Socket/stone-voip-bridge.js

@@ -0,0 +1,263 @@
+import { EventEmitter } from 'node:events'
+import { createRequire } from 'node:module'
+import { spawnSync } from 'node:child_process'
+import { dirname, delimiter } from 'node:path'
+import pino from 'pino'
+import { loadStoneVoipCodec } from './stone-voip-codec.js'
+import { resolveStoneVoipTransport } from './stone-voip-transport.js'
+import { resolveStoneVoipSelfDeviceLid } from './stone-voip-identity.js'
+import { auditStoneGroupOffer } from './stone-voip-offer-audit.js'
+
+const require = createRequire(import.meta.url)
+
+function jidFromAddress(address) {
+  if (!address || typeof address.user !== 'string' || typeof address.server !== 'string') {
+    throw new TypeError('Endereço Signal de chamada inválido')
+  }
+  const device = Number(address.device || 0)
+  if (!Number.isSafeInteger(device) || device < 0) throw new TypeError('Dispositivo Signal inválido')
+  return address.user + (device ? ':' + device : '') + '@' + address.server
+}
+function addressFromJid(jid) {
+  if (typeof jid !== 'string') throw new TypeError('JID esperado')
+  const m = /^([^:@\s]+)(?::(\d+))?@([^@\s]+)$/.exec(jid)
+  if (!m) throw new TypeError('JID Signal inválido')
+  return { user: m[1], device: Number(m[2] || 0), server: m[3] }
+}
+function normalizeError(error, code) {
+  const next = new Error(error?.message || String(error))
+  next.code = code
+  next.cause = error
+  return next
+}
+
+/**
+ * Adaptador experimental do motor MIT de chamadas para o socket ORIGINAL
+ * Stone WPP. Não cria outro WaClient, socket WhatsApp ou sessão de login.
+ *
+ * É indispensável ter os componentes de codec/relay instalados no host.
+ * A ativação NÃO significa que uma chamada passou por testes ponta-a-ponta.
+ */
+export async function createStoneVoipBridge(socket, options = {}) {
+  if (!socket?.ws?.on || !socket?.sendNode || !socket?.signalRepository ||
+      !socket?.authState?.creds || !socket?.assertSessions ||
+      !socket?.getUSyncDevices) {
+    throw new TypeError('Socket Stone sem as primitivas necessárias para VoIP')
+  }
+
+  let voipPlugin
+  try {
+    ;({ voipPlugin } = await import('@zapo-js/voip'))
+  } catch (error) {
+    throw normalizeError(error, 'STONE_VOIP_RUNTIME_MISSING')
+  }
+  if (typeof voipPlugin !== 'function') {
+    throw new Error('Módulo VoIP instalado não exporta voipPlugin')
+  }
+  // libmlow-wasm-fork é ESM-only: require.resolve() NÃO resolve o export "import".
+  // Carregue a entrada pública via import() em vez de marcar o codec instalado
+  // como ausente (ERR_PACKAGE_PATH_NOT_EXPORTED).
+  await loadStoneVoipCodec()
+  const logger = options.logger || pino({ level: process.env.STONE_VOIP_LOG_LEVEL || 'warn' })
+  const transport = await resolveStoneVoipTransport(options)
+  if (transport.warning) {
+    logger.warn({ code: transport.warning.code }, transport.warning.message)
+  }
+  const signal = socket.signalRepository
+  const hostEvents = new EventEmitter()
+  const disposeHandlers = []
+  const creds = () => socket.authState.creds
+  // O roster atualizado pode confirmar o LID da própria conta quando o
+  // campo me.lid da autenticação está ausente/desatualizado.
+  let confirmedSelfLid = ''
+  const setSelfLid = value => {
+    if (/^\d+(?::\d+)?@lid$/.test(value)) confirmedSelfLid = value
+  }
+  const getCurrentCredentials = () => ({
+    meJid: creds().me?.id || '',
+    // A lista de participantes é por conta, mas a oferta do criador precisa
+    // indicar o dispositivo vinculado que está emitindo esta chamada.
+    meLid: resolveStoneVoipSelfDeviceLid(
+      creds().me?.id || '',
+      creds().me?.lid || '',
+      confirmedSelfLid
+    ),
+    signedIdentity: creds().account || null
+  })
+  const syncDeviceList = async (accounts) => Promise.all(accounts.map(async jid => {
+    const devices = await socket.getUSyncDevices([jid], true, false)
+    const deviceJids = [...new Set(devices.map(x => x.jid).filter(Boolean))]
+    return { jid, deviceJids }
+  }))
+
+  // Relaciona o ACK a uma oferta real sem expor o ID aleatório da stanza.
+  const recentOfferKinds = new Map()
+  const sendVoipNode = node => {
+    if (node?.tag === 'call' && typeof node.attrs?.id === 'string') {
+      const offer = Array.isArray(node.content)
+        ? node.content.find(child => child?.tag === 'offer')
+        : null
+      if (offer) {
+        const kind = offer.attrs?.['group-jid'] ? 'group' : 'individual'
+        if (kind === 'group') {
+          const credentials = getCurrentCredentials()
+          const ownJid = /:\d+@/.test(credentials.meJid) ? credentials.meJid :
+            (credentials.meLid || credentials.meJid)
+          const audit = auditStoneGroupOffer(node, ownJid)
+          socket.ev?.emit?.('stone.voip.group-offer-audit', audit)
+          if (!audit?.ok) {
+            // Never submit a locally invalid group offer. No identifiers in error.
+            const error = new Error('STONE_VOIP_GROUP_OFFER_INVALID: sinalização do grupo inconsistente')
+            error.code = 'STONE_VOIP_GROUP_OFFER_INVALID'
+            throw error
+          }
+        }
+        recentOfferKinds.set(node.attrs.id, kind)
+        if (recentOfferKinds.size > 32) recentOfferKinds.delete(recentOfferKinds.keys().next().value)
+      }
+    }
+    return socket.sendNode(node)
+  }
+
+  const deps = {
+    authClient: { getCurrentCredentials },
+    isMobilePrimary: () => false,
+    lowLevelCoordinator: {
+      sendNode: sendVoipNode,
+      query: (node, timeoutMs) => socket.query(node, timeoutMs)
+    },
+    signalDeviceSync: {
+      syncDeviceList,
+      queryLidsByPhoneJids: async jids => Promise.all(jids.map(async pnJid => {
+        const lidJid = await signal.lidMapping?.getLIDForPN?.(pnJid)
+        return { pnJid, lidJid: lidJid || null }
+      }))
+    },
+    sessionResolver: {
+      ensureSessionsBatch: async jids => {
+        await socket.assertSessions(jids)
+        return jids.map(jid => ({ address: addressFromJid(jid), session: null }))
+      }
+    },
+    signalProtocol: {
+      decryptMessage: async (address, { type, ciphertext }) =>
+        signal.decryptMessage({ jid: jidFromAddress(address), type, ciphertext }),
+      encryptMessagesBatch: async messages => {
+        const encrypted = []
+        for (const { address, plaintext } of messages) {
+          encrypted.push(await signal.encryptMessage({
+            jid: jidFromAddress(address),
+            data: Buffer.from(plaintext)
+          }))
+        }
+        return encrypted
+      }
+    },
+    messageDispatch: {
+      syncSignalSession: jid => socket.assertSessions([jid])
+    }
+  }
+  const stores = {
+    privacyToken: {
+      getByJid: async jid => {
+        const entry = (await socket.authState.keys.get('tctoken', [jid]))?.[jid]
+        return entry?.token ? { tcToken: entry.token } : null
+      }
+    }
+  }
+
+  const registerIncomingHandler = ({ tag, handler, prepend = false }) => {
+    const event = tag === 'call' ? 'CB:call' : tag === 'ack' ? 'CB:ack,class:call' :
+      tag === 'receipt' ? 'CB:receipt' : null
+    if (!event || typeof handler !== 'function') throw new TypeError('Handler de chamada inválido')
+    const receive = node => {
+      Promise.resolve().then(() => handler(node)).catch(error => {
+        hostEvents.emit('voip_call_error', error)
+        logger.warn({ err: error, tag }, 'falha no handler VoIP')
+      })
+    }
+    if (prepend && typeof socket.ws.prependListener === 'function') {
+      socket.ws.prependListener(event, receive)
+    } else socket.ws.on(event, receive)
+    const off = () => socket.ws.off(event, receive)
+    disposeHandlers.push(off)
+    return off
+  }
+
+  const context = {
+    client: hostEvents,
+    options: Object.freeze({}),
+    logger,
+    deps,
+    stores,
+    emit: hostEvents.emit.bind(hostEvents),
+    on: hostEvents.on.bind(hostEvents),
+    off: hostEvents.off.bind(hostEvents),
+    once: hostEvents.once.bind(hostEvents),
+    queryWithContext: (_context, node, timeoutMs) => socket.query(node, timeoutMs),
+    registerIncomingHandler,
+    registerIncomingStanzaFilter: () => () => {},
+    registerDispose: fn => disposeHandlers.push(fn)
+  }
+  let plugin, coordinator
+  try {
+    plugin = voipPlugin({
+      maxConcurrentCalls: options.maxConcurrentCalls || 1,
+      useRawUdpTransport: transport.kind === 'raw-udp',
+      logLevel: options.logLevel || 'warn'
+    })
+    coordinator = plugin.setup(context)
+    // Observa somente ACKs de ofertas recusadas. Não registra JID, IP,
+    // token do relay, texto do stanza nem qualquer material de sessão.
+    // setup_failed significa que o servidor rejeitou a oferta, não que o
+    // transporte WebRTC esteja necessariamente inoperante.
+    const onOfferAck = node => {
+      const attrs = node?.attrs || {}
+      if (attrs.type !== 'offer' || attrs.error == null) return
+      const code = String(attrs.error).trim()
+      if (!/^\d{3,4}$/.test(code)) return
+      const scope = recentOfferKinds.get(attrs.id) || 'unknown'
+      const correlated = scope !== 'unknown'
+      socket.ev?.emit?.('stone.voip.offer-rejected', { code, scope, correlated })
+      logger.warn({ code, scope, correlated }, 'ACK de oferta recusada pelo servidor')
+    }
+    socket.ws.on('CB:ack,class:call', onOfferAck)
+    disposeHandlers.push(() => socket.ws.off('CB:ack,class:call', onOfferAck))
+    socket.ws._stoneVoipActive = true
+  } catch (error) {
+    for (const off of disposeHandlers.splice(0)) {
+      try { off() } catch {}
+    }
+    throw normalizeError(error, 'STONE_VOIP_INITIALIZATION_FAILED')
+  }
+  let disposed = false
+  const dispose = async () => {
+    if (disposed) return
+    disposed = true
+    socket.ws._stoneVoipActive = false
+    for (const off of disposeHandlers.splice(0)) {
+      try { await off() } catch {}
+    }
+    try {
+      if (typeof plugin.dispose === 'function') await plugin.dispose(coordinator, context)
+      else coordinator?.dispose?.()
+    } finally {
+      hostEvents.removeAllListeners()
+    }
+  }
+
+  let audioFilesAvailable = false
+  for (const candidate of [options.ffmpegPath || process.env.FFMPEG_PATH || 'ffmpeg', (() => {
+    try { return require('ffmpeg-static') } catch { return null }
+  })()]) {
+    if (!candidate) continue
+    try {
+      if (spawnSync(candidate, ['-version'], { stdio: 'ignore', timeout: 4000 }).status === 0) {
+        audioFilesAvailable = true
+        if (candidate !== 'ffmpeg') process.env.PATH = dirname(candidate) + delimiter + process.env.PATH
+        break
+      }
+    } catch {}
+  }
+  return { coordinator, events: hostEvents, dispose, setSelfLid, audioFilesAvailable, transport: transport.kind, transportFallback: transport.fallback }
+}

package/lib/Socket/stone-voip-codec.js

@@ -0,0 +1,33 @@
+/**
+ * Verifica o motor MLow usando as condições ESM do pacote. Este codec é
+ * distribuído só como módulo ESM: require.resolve() produz
+ * ERR_PACKAGE_PATH_NOT_EXPORTED mesmo quando ele está instalado.
+ *
+ * A função de importação é injetável para o teste de regressão.
+ */
+export async function loadStoneVoipCodec(load = () => import('libmlow-wasm-fork')) {
+  let codec
+  try {
+    codec = await load()
+  } catch (error) {
+    const missing = error?.code === 'ERR_MODULE_NOT_FOUND'
+    const cause = error?.message || String(error)
+    const next = new Error(
+      missing
+        ? `Codec MLow não instalado: ${cause}`
+        : `Falha ao carregar o codec MLow via ESM: ${cause}`,
+      { cause: error }
+    )
+    next.code = missing ? 'STONE_VOIP_CODEC_MISSING' : 'STONE_VOIP_CODEC_LOAD_FAILED'
+    throw next
+  }
+  if (typeof codec?.createEncoder !== 'function' ||
+      typeof codec?.createDecoder !== 'function') {
+    const error = new Error(
+      'Codec MLow instalado, mas sem createEncoder/createDecoder; verifique a versão'
+    )
+    error.code = 'STONE_VOIP_CODEC_INVALID'
+    throw error
+  }
+  return codec
+}

package/lib/Socket/stone-voip-group.js

@@ -0,0 +1,112 @@
+/** Seleção de identidades para oferta de chamada em grupo (somente LID). */
+const account = (v) => String(v || '').trim().replace(/:\d+(?=@)/, '')
+const pn = (v) => { const s = account(v).replace(/@c\.us$/, '@s.whatsapp.net'); return /^\d+@s\.whatsapp\.net$/.test(s) ? s : '' }
+const lid = (v) => { const s = account(v); return /^\d+@lid$/.test(s) ? s : '' }
+const aliases = (m) => [...new Set([m?.jid, m?.id, m?.lid, m?.lidJid, m?.pnJid, m?.phoneJid, m?.phoneNumber].map(account).filter(Boolean))]
+const failed = (code, message) => Object.assign(new Error(message), { code })
+
+async function mappedLid(phone, socket) {
+  if (!phone) return ''
+  const mapping = socket?.signalRepository?.lidMapping
+  if (typeof mapping?.getLIDForPN !== 'function') return ''
+  let value = ''
+  try { value = lid(await mapping.getLIDForPN(phone)) } catch {}
+  if (!value && typeof socket?.getUSyncDevices === 'function') {
+    // Recarrega USync em vez de confiar em um cache desatualizado.
+    try { await socket.getUSyncDevices([phone], false, false) } catch {}
+    try { value = lid(await mapping.getLIDForPN(phone)) } catch {}
+  }
+  return value
+}
+async function memberLid(member, socket) {
+  for (const a of aliases(member)) { const value = lid(a); if (value) return value }
+  for (const a of aliases(member)) { const value = await mappedLid(pn(a), socket); if (value) return value }
+  return ''
+}
+async function rosterMember(members, requested, socket) {
+  const requestedAccount = account(requested)
+  const direct = members.find(m => aliases(m).includes(requestedAccount))
+  if (direct) return direct
+  if (lid(requestedAccount)) {
+    // Em grupos PN, o roster pode listar apenas telefones mesmo que a oferta
+    // já tenha LIDs válidos. Valida pelo mapa local, sem forçar USync para
+    // cada um dos membros do grupo.
+    const mapping = socket?.signalRepository?.lidMapping
+    let matchedPn = ''
+    try { matchedPn = pn(await mapping?.getPNForLID?.(requestedAccount)) } catch {}
+    if (matchedPn) {
+      const match = members.find(m => aliases(m).includes(matchedPn))
+      if (match) return match
+    }
+    for (const member of members) {
+      for (const value of aliases(member)) {
+        const phone = pn(value)
+        if (!phone) continue
+        let mapped = ''
+        try { mapped = lid(await mapping?.getLIDForPN?.(phone)) } catch {}
+        if (mapped === requestedAccount) return member
+      }
+    }
+    return null
+  }
+  const resolved = await mappedLid(pn(requestedAccount), socket)
+  return resolved ? members.find(m => aliases(m).includes(resolved)) || null : null
+}
+
+/** Prepara IDs de participantes e da própria conta ANTES de iniciar o motor. */
+export async function prepareStoneGroupOffer(socket, options) {
+  if (!/^\d+@g\.us$/.test(options?.groupJid || '')) {
+    throw failed('STONE_GROUP_INVALID_JID', 'Identificador do grupo inválido')
+  }
+  if (!Array.isArray(options.participants) || !options.participants.length || options.participants.length > 31) {
+    throw failed('STONE_GROUP_INVALID_PARTICIPANTS', 'Informe de 1 a 31 participantes')
+  }
+  if (typeof socket?.groupMetadata !== 'function') {
+    throw failed('STONE_GROUP_ROSTER_UNAVAILABLE', 'Consulta ao grupo indisponível no socket Stone')
+  }
+  let metadata
+  try { metadata = await socket.groupMetadata(options.groupJid) }
+  catch { throw failed('STONE_GROUP_ROSTER_UNAVAILABLE', 'Não foi possível atualizar os membros do grupo') }
+  const members = metadata?.participants
+  if (metadata?.id !== options.groupJid || !Array.isArray(members) || !members.length) {
+    throw failed('STONE_GROUP_ROSTER_INVALID', 'Lista de membros do grupo ausente ou divergente')
+  }
+
+  const own = socket?.authState?.creds?.me || {}
+  const ownPn = pn(own.id)
+  const ownCurrentLid = lid(own.lid)
+  const self = members.find(m => aliases(m).includes(ownPn) || (ownCurrentLid && aliases(m).includes(ownCurrentLid))) ||
+    (ownPn ? await rosterMember(members, ownPn, socket) : null)
+  if (!self) throw failed('STONE_GROUP_SELF_NOT_MEMBER', 'A conta do bot não foi encontrada na lista atual do grupo')
+  const selfLid = await memberLid(self, socket) || ownCurrentLid || await mappedLid(ownPn, socket)
+  if (!selfLid) {
+    throw failed('STONE_GROUP_SELF_LID_MISSING', 'O LID da conta do bot não está confirmado')
+  }
+
+  const seen = new Set(), participants = []
+  for (const participant of options.participants) {
+    const requested = account(participant?.jid)
+    if (!pn(requested) && !lid(requested)) {
+      throw failed('STONE_GROUP_INVALID_PARTICIPANT', 'ID inválido de participante')
+    }
+    const member = await rosterMember(members, requested, socket)
+    if (!member) {
+      throw failed('STONE_GROUP_MEMBER_MISMATCH', 'O convidado não consta mais na lista atual do grupo (ACK 412)')
+    }
+    const resolvedLid = await memberLid(member, socket)
+    if (!resolvedLid) {
+      throw failed('STONE_GROUP_MEMBER_LID_MISSING', 'Não foi possível confirmar o LID do convidado; não enviaremos um PN')
+    }
+    if (resolvedLid === selfLid) {
+      throw failed('STONE_GROUP_SELF_INVITE', 'Não é possível convidar a própria conta do bot')
+    }
+    if (seen.has(resolvedLid)) continue
+    seen.add(resolvedLid)
+    // Nunca reaproveita dispositivos PN antigos: o motor resolve a partir do LID.
+    participants.push({ jid: resolvedLid })
+  }
+  if (!participants.length) {
+    throw failed('STONE_GROUP_INVALID_PARTICIPANTS', 'Nenhum participante válido para chamar')
+  }
+  return { options: { ...options, participants }, selfLid }
+}

package/lib/Socket/stone-voip-identity.js

@@ -0,0 +1,26 @@
+/**
+ * Monta o LID do DISPOSITIVO que está autenticado no socket.
+ * O roster devolve identidades de conta sem sufixo :device.
+ * Em uma chamada de grupo o criador deve identificar o próprio aparelho
+ * vinculado, não anunciar incorretamente o dispositivo principal (:0).
+ */
+function parseAccount(jid) {
+  const match = /^(\d+)(?::(\d+))?@(lid|s\.whatsapp\.net)$/.exec(String(jid || ''))
+  if (!match) return null
+  const device = match[2] === undefined ? null : Number(match[2])
+  if (device !== null && (!Number.isSafeInteger(device) || device < 0)) return null
+  return { user: match[1], device, server: match[3] }
+}
+export function resolveStoneVoipSelfDeviceLid(meJid, meLid, confirmedSelfLid = '') {
+  const currentPn = parseAccount(meJid)
+  const currentLid = parseAccount(meLid)
+  const confirmed = parseAccount(confirmedSelfLid)
+  const lid = confirmed?.server === 'lid' ? confirmed :
+    (currentLid?.server === 'lid' ? currentLid : null)
+  if (!lid) return meLid || ''
+  // O JID PN autenticado traz o dispositivo da sessão; o LID confirmado
+  // pelo grupo pode vir sem o sufixo. Não confundir conta com dispositivo.
+  const device = currentPn?.device ?? currentLid?.device ?? confirmed?.device
+  if (device === null || device === 0) return lid.user + '@lid'
+  return lid.user + ':' + device + '@lid'
+}

package/lib/Socket/stone-voip-offer-audit.js

@@ -0,0 +1,49 @@
+// Validate the final group-call offer, not the command's input list.
+// Diagnostic output deliberately contains NO identifiers, raw nodes or secrets.
+const jid = value => {
+  const m = /^(\d+)(?::(\d+))?@(lid|s\.whatsapp\.net)$/.exec(String(value || ''))
+  return m ? { account: `${m[1]}@${m[3]}`, device: m[2] === undefined ? 0 : Number(m[2]), domain: m[3] } : null
+}
+export function auditStoneGroupOffer(node, ownJid = '') {
+  const offer = Array.isArray(node?.content) ? node.content.find(n => n?.tag === 'offer') : null
+  if (node?.tag !== 'call' || !offer?.attrs?.['group-jid']) return null
+  const creator = jid(offer.attrs['call-creator'])
+  const own = jid(ownJid)
+  const groupInfo = Array.isArray(offer.content) ? offer.content.filter(n => n?.tag === 'group_info') : []
+  const users = Array.isArray(groupInfo[0]?.content) ? groupInfo[0].content : []
+  const creatorRows = users.filter(u => jid(u?.attrs?.jid)?.account === creator?.account)
+  const creatorDevices = Array.isArray(creatorRows[0]?.content) ? creatorRows[0].content : []
+  const allDevices = users.flatMap(u => Array.isArray(u?.content) ? u.content : [])
+  const groupIdentityValid = /^\d+@g\.us$/.test(String(offer.attrs['group-jid'] || ''))
+  const toMatchesCall = /^[0-9A-Fa-f]{32}$/.test(String(offer.attrs['call-id'] || '')) &&
+    node.attrs?.to === `${offer.attrs['call-id']}@call`
+  const allLid = users.length > 0 && users.every(u => jid(u?.attrs?.jid)?.domain === 'lid') &&
+    allDevices.every(d => jid(d?.attrs?.jid)?.domain === 'lid')
+  const deviceOwnersMatch = users.every(u => {
+    const account = jid(u?.attrs?.jid)?.account
+    return Boolean(account) && Array.isArray(u.content) && u.content.length > 0 &&
+      u.content.every(d => d.tag === 'device' && jid(d?.attrs?.jid)?.account === account)
+  })
+  const creatorDeviceMatches = creatorRows.length === 1 &&
+    creatorDevices.some(d => {
+      const value = jid(d?.attrs?.jid)
+      return value?.account === creator?.account && value.device === creator.device
+    })
+  const creatorMatchesSocket = !own || !creator ? false :
+    (!/:\d+@/.test(String(ownJid)) || creator.device === own.device)
+  const distinctAccounts = new Set(users.map(u => jid(u?.attrs?.jid)?.account))
+  const memberCount = Math.max(0, users.length - 1)
+  const media = Array.isArray(offer.content) ? offer.content : []
+  const hasMedia = media.filter(n => n?.tag === 'audio').length >= 2 && media.some(n => n?.tag === 'net')
+  const ok = groupIdentityValid && toMatchesCall && groupInfo.length === 1 &&
+    Boolean(creator) && creator.domain === 'lid' && allLid && deviceOwnersMatch &&
+    creatorDeviceMatches && creatorMatchesSocket && users.length >= 2 &&
+    distinctAccounts.size === users.length && hasMedia
+  return {
+    ok, groupIdentityValid, toMatchesCall, creatorIsLid: creator?.domain === 'lid',
+    creatorDeviceMatches, creatorMatchesSocket, groupInfoUnique: groupInfo.length === 1,
+    allLid, deviceOwnersMatch, uniqueAccounts: distinctAccounts.size === users.length,
+    hasMedia, inviteeCount: Math.min(memberCount, 99),
+    deviceCount: Math.min(allDevices.length, 999)
+  }
+}

package/lib/Socket/stone-voip-transport.js

@@ -0,0 +1,44 @@
+/**
+ * Escolhe o transporte de mídia sem criar uma segunda sessão WhatsApp.
+ * WebRTC é a primeira opção. Hosts sem binário nativo podem tentar UDP
+ * direto; essa alternativa continua experimental e depende do relay.
+ */
+export async function resolveStoneVoipTransport(options = {}, loadWebRtc = () => import('@roamhq/wrtc')) {
+  if (options.useRawUdpTransport === true) {
+    return { kind: 'raw-udp', fallback: false, warning: null }
+  }
+
+  try {
+    const module = await loadWebRtc()
+    const connection = module?.RTCPeerConnection || module?.default?.RTCPeerConnection
+    if (typeof connection !== 'function') {
+      const invalid = new Error('Módulo WebRTC não exporta RTCPeerConnection')
+      invalid.code = 'STONE_VOIP_WEBRTC_INVALID'
+      throw invalid
+    }
+    return { kind: 'webrtc', fallback: false, warning: null }
+  } catch (error) {
+    const code = error?.code === 'ERR_MODULE_NOT_FOUND'
+      ? 'STONE_VOIP_WEBRTC_MISSING'
+      : 'STONE_VOIP_WEBRTC_LOAD_FAILED'
+
+    if (options.rawUdpFallback === false) {
+      const unavailable = new Error(
+        'WebRTC não está disponível neste host. Use um host compatível ou habilite o fallback UDP experimental.',
+        { cause: error }
+      )
+      unavailable.code = code
+      throw unavailable
+    }
+
+    return {
+      kind: 'raw-udp',
+      fallback: true,
+      warning: {
+        code,
+        message: 'WebRTC indisponível; usando transporte UDP experimental: ' +
+          (error?.message || String(error))
+      }
+    }
+  }
+}

package/lib/Utils/messages-media.js

@@ -421,8 +421,22 @@ export const downloadContentFromMessage = async ({ mediaKey, directPath, url },
     if (!downloadUrl) {
         throw new Boom('No valid media URL or directPath present in message', { statusCode: 400 });
     }
+    if (!mediaKey || (typeof mediaKey !== 'string' && mediaKey.length === 0)) {
+        throw new Boom('Media key is missing; the file cannot be decrypted', { statusCode: 400 });
+    }
     const keys = await getMediaKeys(mediaKey, type);
-    return downloadEncryptedContent(downloadUrl, keys, opts);
+    try {
+        return await downloadEncryptedContent(downloadUrl, keys, opts);
+    }
+    catch (error) {
+        // The directPath host can expire while the message still carries a valid signed URL.
+        // Only fall back on HTTP retrieval errors; never mask a key/decryption failure.
+        const status = error?.output?.statusCode;
+        if (!directPath || !url || url === downloadUrl || ![403, 404, 410].includes(status)) {
+            throw error;
+        }
+        return downloadEncryptedContent(url, keys, opts);
+    }
 };
 /**
  * Decrypts and downloads an AES256-CBC encrypted file given the keys.

package/lib/Utils/validate-connection.js

@@ -189,6 +189,8 @@ export const configureSuccessfulPairing = (stanza, { advSecretKey, signedIdentit
     };
     const authUpdate = {
         account,
+        registered: true,
+        pairingCode: undefined,
         me: { id: jid, name: bizName, lid },
         signalIdentities: [...(signalIdentities || []), identity],
         platform: platformNode?.attrs.name

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stone-wpp/ofc",
   "type": "module",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "description": "Stone WPP — biblioteca modular para WhatsApp em Node.js: conexão, mensagens, grupos, canais, armazenamento e extensões",
   "keywords": [
     "stone-wpp",
@@ -27,17 +27,22 @@
     "engine-requirements.js",
     "README.md",
     "LICENSE",
-    "docs/**/*"
+    "!lib/**/*.test.mjs",
+    "!lib/Socket/vox.mjs",
+    "!lib/**/*.bak"
   ],
   "scripts": {
     "preinstall": "node ./engine-requirements.js",
-    "test": "node --test test/*.test.mjs",
-    "prepublishOnly": "npm test"
+    "test": "node --test lib/Socket/stone-calls.test.mjs lib/Socket/group-protection.test.mjs lib/Signal/stability-1.0.7.test.mjs lib/Socket/stone-call-signaling.test.mjs lib/Socket/stone-call-keys.test.mjs lib/Socket/stone-call-audio.test.mjs lib/Socket/stone-pairing-state.test.mjs lib/Socket/stone-voip-bridge.test.mjs lib/Socket/stone-voip-codec.test.mjs lib/Socket/stone-voip-transport.test.mjs lib/Socket/vox.mjs lib/Socket/stone-voip-group.test.mjs lib/Socket/stone-voip-identity.test.mjs lib/Socket/stone-voip-offer-audit.test.mjs",
+    "prepublishOnly": "npm test",
+    "release:check": "npm test && npm pack --dry-run"
   },
   "dependencies": {
     "@cacheable/node-cache": "^1.4.0",
     "@hapi/boom": "^9.1.3",
+    "@zapo-js/voip": "^1.4.0",
     "async-mutex": "^0.5.0",
+    "libmlow-wasm-fork": "^0.2.0",
     "libsignal": "^6.0.0",
     "lru-cache": "^11.1.0",
     "music-metadata": "^11.12.3",
@@ -45,7 +50,8 @@
     "pino": "^9.6",
     "protobufjs": "^7.5.6",
     "whatsapp-rust-bridge": "0.5.4",
-    "ws": "^8.13.0"
+    "ws": "^8.13.0",
+    "zapo-js": "^1.0.0"
   },
   "peerDependencies": {
     "audio-decode": "^2.1.3",
@@ -107,5 +113,9 @@
   },
   "bugs": {
     "url": "https://github.com/dylan-Modz/stone-wpp-ofc/issues"
+  },
+  "optionalDependencies": {
+    "@roamhq/wrtc": "^0.10.0",
+    "ffmpeg-static": "^5.2.0"
   }
 }