soblendwa-client 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Soblend Development Studio
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,98 @@
-# Temporary Holding Version
+# soblendwa-client
 
-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.
+Cliente de JavaScript y TypeScript para el servidor de
+[SoblendWA](https://github.com/Soblend-Development-Studio/SoblendWA). Hecho por **Soblend Development Studio**.
+
+El motor (Rust) corre en `soblendwa-server`; tu bot solo habla con él por WebSocket. No compila nada nativo, no tiene
+dependencias y funciona en Node 18+, Bun, Deno y el navegador. En Node 22+, Bun y Deno usa el WebSocket incluido; en
+Node 18–21 instala `ws`.
+
+```bash
+npm install soblendwa-client
+```
+
+## 1. Arranca el servidor
+
+Descarga el binario de tu plataforma en
+[Releases](https://github.com/Soblend-Development-Studio/SoblendWA/releases) y córrelo:
+
+```text
+./soblendwa-server --token mi-clave
+```
+
+O, si tienes Rust y el repositorio: `cargo run --release -p soblendwa-server -- --token mi-clave`.
+
+La primera vez muestra un QR en la terminal: escanéalo en **WhatsApp > Dispositivos vinculados**.
+
+Para probar sin ninguna cuenta: `./soblendwa-server --fake --session bot --session ana` usa un WhatsApp falso con el
+protocolo real, y nada sale de tu máquina.
+
+## 2. Escribe tu bot
+
+```js
+import { connect } from 'soblendwa-client'
+
+const bot = await connect('ws://127.0.0.1:8787', { token: 'mi-clave' })
+
+bot.on('message', async (message) => {
+  if (message.info.fromMe) return
+  if (message.text === '!ping') {
+    const ms = await bot.elapsed(message)
+    await bot.reply(message, `Pong\n${ms.toFixed(2)} ms`)
+  }
+  if (message.text === '!menu') {
+    await bot.sendInteractive(message.info.chat, {
+      body: '¿Qué quieres hacer?',
+      buttons: [
+        { type: 'reply', id: 'ping', text: 'Medir latencia' },
+        { type: 'url', text: 'Rust', url: 'https://www.rust-lang.org' },
+      ],
+    })
+  }
+  if (message.reply?.id === 'ping') await bot.reply(message, 'Pong')
+})
+```
+
+Con TypeScript es igual: los tipos vienen incluidos.
+
+Si te desconectas del servidor, el cliente se reconecta solo. WhatsApp sigue conectado en el servidor mientras tanto,
+así que no se pierde la sesión.
+
+## Varias cuentas
+
+Cada sesión es una cuenta de WhatsApp distinta y el servidor las maneja todas a la vez:
+
+```js
+const ventas = await connect(url, { session: 'ventas', token })
+const soporte = await connect(url, { session: 'soporte', token })
+```
+
+## Vista previa de enlaces
+
+Los enlaces de un texto llevan vista previa sola. Para quitarla o escribirla a mano:
+
+```js
+await bot.sendText(chat, texto, { preview: false })
+await bot.sendText(chat, texto, { preview: { title: 'Mi título', description: 'Escrito a mano' } })
+```
+
+## Métodos
+
+Los mismos que el módulo nativo `soblendwa`: `sendText`, `reply`, `react`, `read`, `sendImage`, `sendVideo`,
+`sendAudio`, `sendDocument`, `sendSticker`, `sendFile`, `download`, `downloadToFile`, `sendPoll`, `votePoll`, `edit`,
+`revoke`, `typing`, `setOnline`, `sendInteractive`, `sendButtons`, `sendList`, `sendContacts`, `sendMentionAll`,
+`sendGroupInvite`, `setMemberLabel`, `sendProto`, `groupInfo`, `joinedGroups`, `onWhatsApp`, `profilePicture`, `block`,
+`unblock`, `modifyChat`, `labelChat`, `labelMessage`, `editLabel`, `deleteLabel`, `saveQuickReply`, `chats`, `contacts`,
+`messages`, `search`, `botList`, `reachoutTimelock`, `newChatMessageCap`, `disappearingModes`, `stats`, `pendingSends`,
+`ping`, `elapsed`, `requestPairCode` y `logout`. Para cualquier otro, `bot.call(método, parámetros)`.
+
+`sendMedia` y compañía mandan los bytes por el WebSocket. `sendFile` y `downloadToFile` usan rutas **del servidor** y
+son la opción para archivos grandes.
+
+## Aviso
+
+SoblendWA es independiente y no está afiliado a WhatsApp ni a Meta. Automatizar una cuenta puede ir contra sus Términos
+de Servicio y provocar un bloqueo. Lee
+[qué está probado](https://github.com/Soblend-Development-Studio/SoblendWA#estado).
+
+MIT © 2026 Soblend Development Studio

package/index.d.ts

@@ -0,0 +1,255 @@
+export interface ConnectOptions {
+  session?: string
+  token?: string
+  reconnect?: boolean
+  timeout?: number
+}
+
+export interface MessageInfo {
+  id: string
+  chat: string
+  sender: string
+  senderAlt: string | null
+  senderPhone: string | null
+  senderLid: string | null
+  fromMe: boolean
+  isGroup: boolean
+  pushName: string | null
+  timestamp: number
+  category: string | null
+  offline: boolean
+  edit: string | null
+  serverId: string | null
+  elapsedMicros: number
+}
+
+export interface MediaInfo {
+  type: 'image' | 'video' | 'gif' | 'ptv' | 'audio' | 'ptt' | 'document' | 'sticker'
+  mimetype: string | null
+  size: number | null
+  caption?: string | null
+  seconds?: number | null
+  width?: number | null
+  height?: number | null
+  fileName?: string | null
+  title?: string | null
+  pages?: number | null
+  animated?: boolean
+  viewOnce: boolean
+}
+
+export interface QuotedInfo {
+  id: string
+  sender: string | null
+  chat: string | null
+  text: string | null
+  mediaType: string | null
+  media: MediaInfo | null
+}
+
+export interface SendTimings {
+  queuedMicros: number
+  uploadMicros: number | null
+  prepareMicros: number
+  encryptMicros: number
+  serverMicros: number | null
+  totalMicros: number
+}
+
+export interface Stats {
+  connected: boolean
+  uptimeSecs: number
+  received: number
+  sent: number
+  undecryptable: number
+  recovered: number
+  duplicates: number
+  awaitingRecovery: number
+  reconnects: number
+  rateLimited: number
+  mediaUploaded: number
+  mediaReused: number
+  outboxResent: number
+  panics: number
+  cachedDevices: number
+  cachedGroups: number
+  pendingQueries: number
+  openLanes: number
+  latencyMicros: number | null
+}
+
+export interface LinkPreviewOverride {
+  url?: string
+  title?: string
+  description?: string
+  thumbnail?: string
+  image?: string
+  width?: number
+  height?: number
+  video?: boolean
+}
+
+export interface PendingSend {
+  id: string
+  chat: string
+  queuedAt: number
+  attempts: number
+}
+
+export interface MessageEvent {
+  type: 'message'
+  info: MessageInfo
+  kind: string
+  mediaType: string | null
+  text: string | null
+  media: MediaInfo | null
+  quoted: QuotedInfo | null
+  viewOnce: boolean
+  ageSecs: number
+  linkPreview: { url: string | null; title: string | null; description: string | null; video: boolean; hasThumbnail: boolean; hasHighQualityThumbnail: boolean; thumbnailWidth: number | null; thumbnailHeight: number | null } | null
+  quotedId: string | null
+  mentions: string[]
+  reaction: { targetId: string | null; emoji: string | null } | null
+  reply: { id: string; text: string | null; source: 'buttons' | 'list' | 'template' | 'nativeFlow'; flow: string | null; params: unknown } | null
+  proto: string
+}
+
+export type SoblendEvent =
+  | MessageEvent
+  | { type: 'qr'; code: string }
+  | { type: 'pairSuccess'; id: string; lid: string | null; platform: string | null; businessName: string | null }
+  | { type: 'connected' }
+  | { type: 'disconnected'; reason: { type: string; detail?: string }; reconnecting: boolean }
+  | { type: 'loggedOut'; reason: string }
+  | { type: 'messageRecovered'; id: string; chat: string; sender: string }
+  | { type: 'accountBlocked'; code: number; reason: string; expires: number | null }
+  | { type: 'receipt'; chat: string; sender: string; ids: string[]; receipt: string; timestamp: number; fromMe: boolean }
+  | { type: 'serverAck'; id: string; chat: string; error: number | null; latencyMicros: number | null; timings: SendTimings | null }
+  | { type: 'pollVote'; chat: string; pollId: string; voter: string; selected: string[]; timestamp: number }
+  | { type: 'eventResponse'; chat: string; eventId: string; responder: string; response: string; extraGuests: number; timestamp: number }
+  | { type: 'chatUpdate'; update: { type: string; [field: string]: unknown }; timestamp: number; initialSync: boolean }
+  | { type: string; [field: string]: unknown }
+
+export interface MediaOptions {
+  caption?: string
+  mimetype?: string
+  fileName?: string
+  voiceNote?: boolean
+  gif?: boolean
+  viewOnce?: boolean
+  seconds?: number
+  quoted?: MessageEvent | string
+}
+
+export interface ListSection {
+  title: string
+  rows: { id: string; title: string; description?: string }[]
+}
+
+export type InteractiveButton =
+  | { type: 'reply'; id: string; text: string }
+  | { type: 'url'; text: string; url: string }
+  | { type: 'copy'; text: string; code: string }
+  | { type: 'call'; text: string; phone: string }
+  | { type: 'select'; title: string; sections: ListSection[] }
+
+export interface StoredMessage {
+  id: string
+  chat: string
+  sender: string | null
+  fromMe: boolean
+  timestamp: number
+  pushName: string | null
+  text: string | null
+  kind: string
+  status: 'error' | 'pending' | 'sent' | 'delivered' | 'read' | 'played'
+  starred: boolean
+  edited: boolean
+  revoked: boolean
+  reactions: Record<string, string>
+  pollVotes: Record<string, string[]>
+}
+
+type MessageRef = MessageEvent | string
+type Bytes = Uint8Array | ArrayBuffer | string
+
+export declare class SoblendClient {
+  static connect(url?: string, options?: ConnectOptions): Promise<SoblendClient>
+  constructor(url?: string, options?: ConnectOptions)
+  readonly me: string | null
+  readonly connected: boolean
+  readonly qr: string | null
+  open(): Promise<this>
+  close(): void
+  call<T = unknown>(method: string, params?: Record<string, unknown>): Promise<T>
+  events(): AsyncGenerator<SoblendEvent>
+  on(event: 'message', listener: (event: MessageEvent) => unknown): this
+  on(event: 'open' | 'close' | 'lagged' | 'error', listener: (value: any) => unknown): this
+  on(event: string, listener: (event: SoblendEvent) => unknown): this
+  once(event: string, listener: (event: any) => unknown): this
+  off(event: string, listener: (event: any) => unknown): this
+
+  status(): Promise<{ me: string | null; connected: boolean }>
+  ping(): Promise<number>
+  stats(): Promise<Stats>
+  pendingSends(): Promise<PendingSend[]>
+  elapsed(message: MessageRef): Promise<number | null>
+  requestPairCode(phone: string | number): Promise<string>
+  logout(): Promise<void>
+
+  sendText(chat: string, text: string, options?: { quoted?: MessageRef; preview?: boolean | LinkPreviewOverride }): Promise<string>
+  reply(message: MessageRef, text: string): Promise<string>
+  react(message: MessageRef, emoji: string): Promise<string>
+  read(message: MessageRef): Promise<void>
+  markPlayed(message: MessageRef): Promise<void>
+  sendMedia(chat: string, kind: 'image' | 'video' | 'audio' | 'document' | 'sticker', data: Bytes, options?: MediaOptions): Promise<string>
+  sendImage(chat: string, data: Bytes, options?: MediaOptions): Promise<string>
+  sendVideo(chat: string, data: Bytes, options?: MediaOptions): Promise<string>
+  sendAudio(chat: string, data: Bytes, options?: MediaOptions): Promise<string>
+  sendDocument(chat: string, data: Bytes, options?: MediaOptions): Promise<string>
+  sendSticker(chat: string, data: Bytes, options?: MediaOptions): Promise<string>
+  sendFile(chat: string, kind: 'image' | 'video' | 'audio' | 'document' | 'sticker', path: string, options?: MediaOptions): Promise<string>
+  download(message: MessageRef): Promise<Uint8Array>
+  downloadToFile(message: MessageRef, path: string): Promise<number>
+  sendPoll(chat: string, name: string, options: string[], selectable?: number): Promise<string>
+  votePoll(chat: string, pollId: string, options: string[]): Promise<string>
+  edit(chat: string, messageId: string, text: string): Promise<string>
+  revoke(chat: string, messageId: string): Promise<string>
+  typing(chat: string, state?: 'composing' | 'recording' | 'paused'): Promise<void>
+  setOnline(available?: boolean): Promise<void>
+  sendInteractive(chat: string, spec: { body: string; buttons: InteractiveButton[]; title?: string; subtitle?: string; footer?: string; quoted?: MessageRef }): Promise<string>
+  sendButtons(chat: string, text: string, buttons: { id: string; text: string }[], footer?: string): Promise<string>
+  sendList(chat: string, list: { title: string; text: string; buttonText: string; sections: ListSection[]; footer?: string }): Promise<string>
+  sendContacts(chat: string, cards: { name: string; phone: string | number }[]): Promise<string>
+  sendMentionAll(chat: string, text: string): Promise<string>
+  sendGroupInvite(to: string, group: string, caption?: string): Promise<string>
+  setMemberLabel(group: string, label: string): Promise<string>
+  sendProto(chat: string, bytes: Bytes): Promise<string>
+
+  groupInfo(chat: string): Promise<Record<string, unknown>>
+  joinedGroups(): Promise<Record<string, unknown>[]>
+  onWhatsApp(...phones: (string | number | (string | number)[])[]): Promise<{ query: string; jid: string; exists: boolean; lid: string | null }[]>
+  profilePicture(jid: string, fullSize?: boolean): Promise<string | null>
+  block(jid: string): Promise<void>
+  unblock(jid: string): Promise<void>
+
+  modifyChat(chat: string, action: 'archive' | 'unarchive' | 'pin' | 'unpin' | 'mute' | 'unmute' | 'read' | 'unread' | 'delete' | 'clear', seconds?: number): Promise<void>
+  labelChat(chat: string, labelId: string | number, labeled?: boolean): Promise<void>
+  labelMessage(chat: string, message: MessageRef, labelId: string | number, labeled?: boolean): Promise<void>
+  editLabel(id: string | number, name: string, color?: number): Promise<void>
+  deleteLabel(id: string | number): Promise<void>
+  saveQuickReply(shortcut: string, text: string): Promise<string>
+
+  chats(): Promise<{ jid: string; name: string | null; unread: number; lastMessageAt: number; archived: boolean; pinned: boolean; mutedUntil: number | null; locked: boolean; labels: string[] }[]>
+  contacts(): Promise<{ jid: string; name: string | null; firstName: string | null; pushName: string | null; lid: string | null; phone: string | null }[]>
+  messages(chat: string, options?: { limit?: number; before?: number }): Promise<StoredMessage[]>
+  search(text: string, limit?: number): Promise<StoredMessage[]>
+
+  botList(): Promise<{ jid: string; personaId: string | null }[]>
+  reachoutTimelock(): Promise<{ active: boolean; endsAt: number | null; enforcement: string | null }>
+  newChatMessageCap(): Promise<unknown>
+  disappearingModes(...jids: (string | string[])[]): Promise<{ jid: string; seconds: number; setAt: number }[]>
+}
+
+export declare function connect(url?: string, options?: ConnectOptions): Promise<SoblendClient>
+export default SoblendClient

package/index.js

@@ -0,0 +1,444 @@
+const DEFAULT_URL = 'ws://127.0.0.1:8787'
+
+class Emitter {
+  constructor() {
+    this.listeners = new Map()
+  }
+
+  on(type, listener) {
+    if (!this.listeners.has(type)) this.listeners.set(type, new Set())
+    this.listeners.get(type).add(listener)
+    return this
+  }
+
+  off(type, listener) {
+    this.listeners.get(type)?.delete(listener)
+    return this
+  }
+
+  once(type, listener) {
+    const wrapped = (value) => {
+      this.off(type, wrapped)
+      listener(value)
+    }
+    return this.on(type, wrapped)
+  }
+
+  emit(type, value) {
+    for (const listener of [...(this.listeners.get(type) ?? [])]) {
+      try {
+        const outcome = listener(value)
+        if (outcome && typeof outcome.catch === 'function') outcome.catch((error) => this.emit('error', error))
+      } catch (error) {
+        if (type !== 'error') this.emit('error', error)
+      }
+    }
+  }
+}
+
+async function socketClass() {
+  if (typeof globalThis.WebSocket === 'function') return globalThis.WebSocket
+  try {
+    const { WebSocket } = await import('ws')
+    return WebSocket
+  } catch {
+    throw new Error('This runtime has no WebSocket: use Node 22+, Bun, Deno or a browser, or install the "ws" package')
+  }
+}
+
+function toBase64(data) {
+  if (typeof data === 'string') return data
+  const bytes = data instanceof Uint8Array ? data : new Uint8Array(data)
+  if (typeof Buffer !== 'undefined') return Buffer.from(bytes).toString('base64')
+  let binary = ''
+  for (let i = 0; i < bytes.length; i += 0x8000) binary += String.fromCharCode(...bytes.subarray(i, i + 0x8000))
+  return btoa(binary)
+}
+
+function fromBase64(text) {
+  if (typeof Buffer !== 'undefined') return Buffer.from(text, 'base64')
+  return Uint8Array.from(atob(text), (c) => c.charCodeAt(0))
+}
+
+function idOf(message) {
+  if (typeof message === 'string') return message
+  return message?.info?.id ?? message?.id
+}
+
+function media({ quoted, ...options } = {}) {
+  return { ...options, quotedId: quoted ? idOf(quoted) : undefined }
+}
+
+export class SoblendClient extends Emitter {
+  static async connect(url = DEFAULT_URL, options = {}) {
+    const client = new SoblendClient(url, options)
+    await client.open()
+    return client
+  }
+
+  constructor(url = DEFAULT_URL, { session = 'default', token, reconnect = true, timeout = 120000 } = {}) {
+    super()
+    this.base = String(url).replace(/^http/, 'ws').replace(/\/+$/, '')
+    this.session = session
+    this.token = token
+    this.reconnect = reconnect
+    this.timeout = timeout
+    this.pending = new Map()
+    this.counter = 0
+    this.state = { me: null, connected: false, qr: null, methods: [] }
+    this.closing = false
+    this.attempt = 0
+  }
+
+  get me() {
+    return this.state.me
+  }
+
+  get connected() {
+    return this.state.connected
+  }
+
+  get qr() {
+    return this.state.qr
+  }
+
+  async open() {
+    const Socket = await socketClass()
+    const query = this.token ? `?token=${encodeURIComponent(this.token)}` : ''
+    const socket = new Socket(`${this.base}/ws/${encodeURIComponent(this.session)}${query}`)
+    this.socket = socket
+    return new Promise((resolve, reject) => {
+      let greeted = false
+      socket.onmessage = (message) => {
+        const frame = JSON.parse(typeof message.data === 'string' ? message.data : String(message.data))
+        if (frame.type === 'hello') {
+          greeted = true
+          this.attempt = 0
+          Object.assign(this.state, { me: frame.me, connected: frame.connected, qr: frame.qr, methods: frame.methods })
+          this.emit('open', frame)
+          resolve(this)
+          return
+        }
+        this.handle(frame)
+      }
+      socket.onerror = (error) => {
+        if (!greeted) reject(new Error(`could not reach SoblendWA at ${this.base}: ${error?.message ?? 'connection failed'}`))
+      }
+      socket.onclose = (event) => {
+        this.failPending(new Error('the connection to the SoblendWA server closed'))
+        this.emit('close', { code: event?.code, reason: event?.reason })
+        if (!greeted) reject(new Error(`SoblendWA refused the connection (${event?.code ?? 'closed'}): check the url and token`))
+        if (greeted && this.reconnect && !this.closing) this.retry()
+      }
+    })
+  }
+
+  retry() {
+    const delay = Math.min(30000, 500 * 2 ** this.attempt++)
+    setTimeout(() => {
+      this.open().catch((error) => {
+        this.emit('error', error)
+        if (this.reconnect && !this.closing) this.retry()
+      })
+    }, delay)
+  }
+
+  handle(frame) {
+    if (frame.id !== undefined && frame.id !== null && this.pending.has(frame.id)) {
+      const { resolve, reject, timer } = this.pending.get(frame.id)
+      this.pending.delete(frame.id)
+      clearTimeout(timer)
+      if (frame.error) reject(new Error(frame.error.message))
+      else resolve(frame.result)
+      return
+    }
+    if (frame.type === 'lagged') {
+      this.emit('lagged', frame.missed)
+      return
+    }
+    const event = frame.event
+    if (!event) return
+    if (event.type === 'qr') this.state.qr = event.code
+    if (event.type === 'connected') Object.assign(this.state, { connected: true, qr: null })
+    if (event.type === 'disconnected') this.state.connected = false
+    if (event.type === 'pairSuccess') this.state.me = event.id
+    if (event.type === 'loggedOut') Object.assign(this.state, { connected: false, me: null })
+    this.emit(event.type, event)
+    this.emit('event', event)
+  }
+
+  failPending(error) {
+    for (const { reject, timer } of this.pending.values()) {
+      clearTimeout(timer)
+      reject(error)
+    }
+    this.pending.clear()
+  }
+
+  call(method, params = {}) {
+    if (!this.socket || this.socket.readyState !== 1) {
+      return Promise.reject(new Error('not connected to the SoblendWA server'))
+    }
+    const id = ++this.counter
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id)
+        reject(new Error(`${method} timed out`))
+      }, this.timeout)
+      this.pending.set(id, { resolve, reject, timer })
+      this.socket.send(JSON.stringify({ id, method, params }))
+    })
+  }
+
+  async *events() {
+    const queue = []
+    let wake = null
+    const push = (event) => {
+      queue.push(event)
+      wake?.()
+    }
+    this.on('event', push)
+    try {
+      for (;;) {
+        while (queue.length) yield queue.shift()
+        await new Promise((resolve) => (wake = resolve))
+        wake = null
+      }
+    } finally {
+      this.off('event', push)
+    }
+  }
+
+  close() {
+    this.closing = true
+    this.failPending(new Error('client closed'))
+    this.socket?.close()
+  }
+
+  status() {
+    return this.call('status')
+  }
+
+  ping() {
+    return this.call('ping')
+  }
+
+  stats() {
+    return this.call('stats')
+  }
+
+  pendingSends() {
+    return this.call('pendingSends')
+  }
+
+  elapsed(message) {
+    return this.call('elapsed', { messageId: idOf(message) })
+  }
+
+  requestPairCode(phone) {
+    return this.call('requestPairCode', { phone: String(phone) })
+  }
+
+  logout() {
+    return this.call('logout')
+  }
+
+  sendText(chat, text, { quoted, preview } = {}) {
+    return this.call('sendText', { chat, text, quotedId: quoted ? idOf(quoted) : undefined, preview })
+  }
+
+  reply(message, text) {
+    return this.call('reply', { messageId: idOf(message), text })
+  }
+
+  react(message, emoji) {
+    return this.call('react', { messageId: idOf(message), emoji })
+  }
+
+  read(message) {
+    return this.call('read', { messageId: idOf(message) })
+  }
+
+  markPlayed(message) {
+    return this.call('markPlayed', { messageId: idOf(message) })
+  }
+
+  sendMedia(chat, kind, data, options = {}) {
+    return this.call('sendMedia', { chat, kind, data: toBase64(data), ...media(options) })
+  }
+
+  sendImage(chat, data, options) {
+    return this.sendMedia(chat, 'image', data, options)
+  }
+
+  sendVideo(chat, data, options) {
+    return this.sendMedia(chat, 'video', data, options)
+  }
+
+  sendAudio(chat, data, options) {
+    return this.sendMedia(chat, 'audio', data, options)
+  }
+
+  sendDocument(chat, data, options) {
+    return this.sendMedia(chat, 'document', data, options)
+  }
+
+  sendSticker(chat, data, options) {
+    return this.sendMedia(chat, 'sticker', data, options)
+  }
+
+  sendFile(chat, kind, path, options = {}) {
+    return this.call('sendFile', { chat, kind, path: String(path), ...media(options) })
+  }
+
+  async download(message) {
+    const { base64 } = await this.call('download', { messageId: idOf(message) })
+    return fromBase64(base64)
+  }
+
+  downloadToFile(message, path) {
+    return this.call('downloadToFile', { messageId: idOf(message), path: String(path) })
+  }
+
+  sendPoll(chat, name, options, selectable = 1) {
+    return this.call('sendPoll', { chat, name, options, selectable })
+  }
+
+  votePoll(chat, pollId, options) {
+    return this.call('votePoll', { chat, pollId, options })
+  }
+
+  edit(chat, messageId, text) {
+    return this.call('edit', { chat, messageId, text })
+  }
+
+  revoke(chat, messageId) {
+    return this.call('revoke', { chat, messageId })
+  }
+
+  typing(chat, state = 'composing') {
+    return this.call('typing', { chat, state })
+  }
+
+  setOnline(available = true) {
+    return this.call('setOnline', { available })
+  }
+
+  sendInteractive(chat, { quoted, ...spec }) {
+    return this.call('sendInteractive', { chat, ...spec, quotedId: quoted ? idOf(quoted) : undefined })
+  }
+
+  sendButtons(chat, text, buttons, footer) {
+    return this.call('sendButtons', { chat, text, buttons, footer })
+  }
+
+  sendList(chat, { title, text, buttonText, sections, footer }) {
+    return this.call('sendList', { chat, title, text, buttonText, sections, footer })
+  }
+
+  sendContacts(chat, cards) {
+    return this.call('sendContacts', { chat, cards })
+  }
+
+  sendMentionAll(chat, text) {
+    return this.call('sendMentionAll', { chat, text })
+  }
+
+  sendGroupInvite(to, group, caption) {
+    return this.call('sendGroupInvite', { to, group, caption })
+  }
+
+  setMemberLabel(group, label) {
+    return this.call('setMemberLabel', { group, label })
+  }
+
+  sendProto(chat, bytes) {
+    return this.call('sendProto', { chat, proto: toBase64(bytes) })
+  }
+
+  groupInfo(chat) {
+    return this.call('groupInfo', { chat })
+  }
+
+  joinedGroups() {
+    return this.call('joinedGroups')
+  }
+
+  onWhatsApp(...phones) {
+    return this.call('onWhatsApp', { phones: phones.flat().map(String) })
+  }
+
+  profilePicture(jid, fullSize = false) {
+    return this.call('profilePicture', { jid, fullSize })
+  }
+
+  block(jid) {
+    return this.call('block', { jid })
+  }
+
+  unblock(jid) {
+    return this.call('unblock', { jid })
+  }
+
+  modifyChat(chat, action, seconds) {
+    return this.call('modifyChat', { chat, action, seconds })
+  }
+
+  labelChat(chat, labelId, labeled = true) {
+    return this.call('labelChat', { chat, labelId: String(labelId), labeled })
+  }
+
+  labelMessage(chat, message, labelId, labeled = true) {
+    return this.call('labelMessage', { chat, messageId: idOf(message), labelId: String(labelId), labeled })
+  }
+
+  editLabel(id, name, color = 0) {
+    return this.call('editLabel', { id: String(id), name, color })
+  }
+
+  deleteLabel(id) {
+    return this.call('deleteLabel', { id: String(id) })
+  }
+
+  saveQuickReply(shortcut, text) {
+    return this.call('saveQuickReply', { shortcut, text })
+  }
+
+  chats() {
+    return this.call('chats')
+  }
+
+  contacts() {
+    return this.call('contacts')
+  }
+
+  messages(chat, { limit = 50, before } = {}) {
+    return this.call('messages', { chat, limit, before })
+  }
+
+  search(text, limit = 50) {
+    return this.call('search', { text, limit })
+  }
+
+  botList() {
+    return this.call('botList')
+  }
+
+  reachoutTimelock() {
+    return this.call('reachoutTimelock')
+  }
+
+  newChatMessageCap() {
+    return this.call('newChatMessageCap')
+  }
+
+  disappearingModes(...jids) {
+    return this.call('disappearingModes', { jids: jids.flat().map(String) })
+  }
+}
+
+export function connect(url, options) {
+  return SoblendClient.connect(url, options)
+}
+
+export default SoblendClient

package/package.json

@@ -1,6 +1,35 @@
 {
   "name": "soblendwa-client",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "JavaScript and TypeScript client for the SoblendWA server: WhatsApp bots in any runtime, powered by Rust. By Soblend Development Studio.",
+  "author": "Soblend Development Studio",
+  "license": "MIT",
+  "homepage": "https://github.com/Soblend-Development-Studio/SoblendWA/tree/main/clients/js#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Soblend-Development-Studio/SoblendWA.git",
+    "directory": "clients/js"
+  },
+  "bugs": { "url": "https://github.com/Soblend-Development-Studio/SoblendWA/issues" },
+  "type": "module",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.js"
+    }
+  },
+  "files": ["index.js", "index.d.ts", "README.md"],
+  "engines": { "node": ">=18" },
+  "keywords": ["whatsapp", "baileys", "bot", "websocket", "typescript", "rust"],
+  "peerDependencies": {
+    "ws": ">=8"
+  },
+  "peerDependenciesMeta": {
+    "ws": { "optional": true }
+  },
+  "scripts": {
+    "test": "node test.mjs"
+  }
+}