ishumdz-bail 1.0.4 → 1.0.6

package/lib/Caller/audio-feeder.d.mts

@@ -0,0 +1,24 @@
+export declare class AudioFeeder {
+    #private;
+    private readonly sampleRate;
+    private readonly channels;
+    private readonly framesPerChunk;
+    private readonly onChunk;
+    private readonly source;
+    private readonly onFinished?;
+    private readonly loop;
+    private readonly warmupSilenceMs;
+    private readonly trailingSilenceMs;
+    droppedChunks: number;
+    underflowChunks: number;
+    bytesProduced: number;
+    constructor(sampleRate: number, channels: number, framesPerChunk: number, onChunk: (chunk: Float32Array) => void, source?: string, onFinished?: (() => void) | undefined, loop?: boolean, warmupSilenceMs?: number, // 500ms warm-up for WebRTC/RTP stabilization
+    trailingSilenceMs?: number);
+    get chunksEmitted(): number;
+    /**
+     * Pre-decode an audio file into memory ahead of time so playback can start with 0ms latency.
+     */
+    static preload: (source: string, sampleRate?: number, channels?: number) => Promise<Float32Array | null>;
+    start: () => void;
+    stop: () => void;
+}

package/lib/Caller/audio-feeder.mjs

@@ -0,0 +1,255 @@
+/**
+ * Audio feeder.
+ *
+ * Decodes `source` into an in-memory Float32Array PCM buffer at the requested rate,
+ * then meters frames out with microsecond-accurate cadence to the WASM VoIP uplink.
+ * Uses an elastic accumulator loop with a 60ms cushion matching PJMEDIA's 60ms encoder
+ * frame length, eliminating Windows timer jitter and buffer underruns.
+ *
+ * @author ShellTear & Chama
+ */
+import { spawn } from "node:child_process";
+// Cache decoded audio buffers in memory across calls for instant 0ms startup
+const audioBufferCache = new Map();
+export class AudioFeeder {
+    sampleRate;
+    channels;
+    framesPerChunk;
+    onChunk;
+    source;
+    onFinished;
+    loop;
+    warmupSilenceMs;
+    trailingSilenceMs;
+    loopGapMs;
+    #proc = null;
+    #timer = null;
+    #active = false;
+    #samples = null;
+    #playhead = 0;
+    #startTime = 0;
+    #chunksEmitted = 0;
+    #finishedEmitted = false;
+    #warmupRemaining = 0;
+    #trailingRemaining = 0;
+    #loopGapRemaining = 0;
+    #cushionChunks = 3; // 60ms cushion (3 * 20ms) matching PJMEDIA's 60ms encoder cycle
+    #chunkSamples = 0;
+    #chunkIntervalMs = 0;
+    droppedChunks = 0;
+    underflowChunks = 0;
+    bytesProduced = 0;
+    constructor(sampleRate, channels, framesPerChunk, onChunk, source = "silence", onFinished, loop = true, warmupSilenceMs = 1500, // 1500ms warm-up for WebRTC/RTP stabilization
+    trailingSilenceMs = 2000, loopGapMs = 1500) {
+        this.sampleRate = sampleRate;
+        this.channels = channels;
+        this.framesPerChunk = framesPerChunk;
+        this.onChunk = onChunk;
+        this.source = source;
+        this.onFinished = onFinished;
+        this.loop = loop;
+        this.warmupSilenceMs = warmupSilenceMs;
+        this.trailingSilenceMs = trailingSilenceMs;
+        this.loopGapMs = loopGapMs;
+        this.#chunkSamples = this.framesPerChunk * this.channels;
+        this.#chunkIntervalMs = (this.framesPerChunk / this.sampleRate) * 1000;
+        this.#warmupRemaining = Math.max(0, Math.round(this.warmupSilenceMs / this.#chunkIntervalMs));
+        this.#trailingRemaining = Math.max(0, Math.round(this.trailingSilenceMs / this.#chunkIntervalMs));
+        this.#loopGapRemaining = Math.max(0, Math.round(this.loopGapMs / this.#chunkIntervalMs));
+    }
+    get chunksEmitted() {
+        return this.#chunksEmitted;
+    }
+    /**
+     * Clear cached in-memory decoded audio buffers.
+     */
+    static clearCache = () => {
+        audioBufferCache.clear();
+    };
+    /**
+     * Pre-decode an audio file into memory ahead of time so playback can start with 0ms latency.
+     */
+    static preload = async (source, sampleRate = 16000, channels = 1) => {
+        if (!source || source === "silence")
+            return null;
+        const cacheKey = `${source}:${sampleRate}:${channels}`;
+        if (audioBufferCache.has(cacheKey)) {
+            return audioBufferCache.get(cacheKey);
+        }
+        return AudioFeeder.#decodeSource(source, sampleRate, channels);
+    };
+    static #decodeSource = (source, sampleRate, channels) => {
+        const cacheKey = `${source}:${sampleRate}:${channels}`;
+        return new Promise((resolve) => {
+            console.log(`[AudioFeeder] Decoding audio source to PCM: ${source}`);
+            const inputArgs = source.startsWith("lavfi:")
+                ? ["-f", "lavfi", "-i", source.slice("lavfi:".length)]
+                : ["-i", source];
+            const proc = spawn("ffmpeg", [
+                "-hide_banner",
+                "-loglevel", "error",
+                ...inputArgs,
+                "-af", "volume=2.2",
+                "-f", "f32le",
+                "-ac", String(channels),
+                "-ar", String(sampleRate),
+                "pipe:1",
+            ]);
+            const chunks = [];
+            proc.stdout.on("data", (chunk) => {
+                chunks.push(chunk);
+            });
+            proc.stderr.on("data", (chunk) => {
+                process.stderr.write(`[AudioFeeder] ${chunk.toString().trim()}\n`);
+            });
+            proc.on("close", () => {
+                const fullBuf = Buffer.concat(chunks);
+                if (fullBuf.length >= 4) {
+                    const numFloats = Math.floor(fullBuf.length / 4);
+                    const fullFloats = new Float32Array(numFloats);
+                    const srcView = new Uint8Array(fullBuf.buffer, fullBuf.byteOffset, numFloats * 4);
+                    const dstView = new Uint8Array(fullFloats.buffer, fullFloats.byteOffset, numFloats * 4);
+                    dstView.set(srcView);
+                    audioBufferCache.set(cacheKey, fullFloats);
+                    console.log(`✅ [AudioFeeder] Decoded and cached audio (${numFloats} samples, ${(numFloats / sampleRate).toFixed(1)}s) from ${source}`);
+                    resolve(fullFloats);
+                }
+                else {
+                    console.warn(`[AudioFeeder] Decode produced no audio bytes for ${source}`);
+                    resolve(null);
+                }
+            });
+            proc.on("error", (err) => {
+                console.error(`[AudioFeeder] ffmpeg spawn error decoding ${source}:`, err);
+                resolve(null);
+            });
+        });
+    };
+    start = () => {
+        if (this.#active)
+            return;
+        this.#active = true;
+        this.#startTime = performance.now();
+        this.#chunksEmitted = 0;
+        this.#finishedEmitted = false;
+        this.#playhead = 0;
+        const cacheKey = `${this.source}:${this.sampleRate}:${this.channels}`;
+        if (!this.source || this.source === "silence") {
+            this.#samples = new Float32Array(this.#chunkSamples);
+            this.#startPacer();
+            return;
+        }
+        const cached = audioBufferCache.get(cacheKey);
+        if (cached && cached.length > 0) {
+            console.log(`[AudioFeeder] Using cached PCM buffer (${cached.length} samples, ${(cached.length / this.sampleRate).toFixed(1)}s) for ${this.source}`);
+            this.#samples = cached;
+            this.#startPacer();
+            return;
+        }
+        // If not cached, start pacer immediately with silence while decoding in background
+        console.log(`[AudioFeeder] Audio buffer not cached yet; starting pacer with silence while decoding ${this.source}...`);
+        this.#startPacer();
+        AudioFeeder.#decodeSource(this.source, this.sampleRate, this.channels).then((samples) => {
+            if (this.#active && samples) {
+                this.#samples = samples;
+                console.log(`[AudioFeeder] Background decode completed (${samples.length} samples); voice streaming active!`);
+            }
+        });
+    };
+    #startPacer = () => {
+        if (this.#timer || !this.#active)
+            return;
+        // Immediately flush initial cushion frames so PJMEDIA's sound port buffer is never empty
+        this.#tick();
+        // High-resolution polling every 5ms to keep jitter buffer perfectly filled
+        this.#timer = setInterval(this.#tick, 5);
+    };
+    #tick = () => {
+        if (!this.#active)
+            return;
+        const elapsedMs = performance.now() - this.#startTime;
+        // Calculate total frames that should have been emitted by now + cushion
+        const targetChunks = Math.floor(elapsedMs / this.#chunkIntervalMs) + this.#cushionChunks;
+        // Flush all pending chunks up to target in this tick
+        while (this.#chunksEmitted < targetChunks && this.#active && !this.#finishedEmitted) {
+            this.#flushOne();
+        }
+    };
+    #flushOne = () => {
+        if (!this.#active)
+            return;
+        const frame = new Float32Array(this.#chunkSamples);
+        // 1. Warm-up silence phase (allows WebRTC/RTP connection to fully establish)
+        if (this.#warmupRemaining > 0) {
+            this.#warmupRemaining--;
+            // frame remains all 0.0f
+        }
+        // 2. Speech PCM samples phase
+        else if (this.#samples && this.#playhead < this.#samples.length) {
+            const audio = this.#samples;
+            for (let i = 0; i < this.#chunkSamples; i++) {
+                if (this.#playhead < audio.length) {
+                    frame[i] = audio[this.#playhead++];
+                }
+                else {
+                    frame[i] = 0;
+                }
+            }
+            // If audio finished playing and loop is enabled, prime the loop gap pause
+            if (this.#playhead >= audio.length && this.loop) {
+                this.#loopGapRemaining = Math.max(0, Math.round(this.loopGapMs / this.#chunkIntervalMs));
+            }
+        }
+        // 3. Loop gap silence phase (natural pause before repeating greeting)
+        else if (this.loop && this.#loopGapRemaining > 0) {
+            this.#loopGapRemaining--;
+            // frame remains all 0.0f
+            if (this.#loopGapRemaining <= 0) {
+                // Rewind playhead to replay greeting cleanly!
+                this.#playhead = 0;
+            }
+        }
+        // 4. Trailing silence padding phase (for non-looping audio)
+        else {
+            if (!this.loop) {
+                if (this.#trailingRemaining > 0) {
+                    this.#trailingRemaining--;
+                    // frame remains all 0.0f
+                }
+                else {
+                    if (!this.#finishedEmitted) {
+                        this.#finishedEmitted = true;
+                        this.#chunksEmitted++;
+                        this.bytesProduced += frame.byteLength;
+                        this.onChunk(frame);
+                        console.log(`[AudioFeeder] Audio playback completed (${this.#chunksEmitted} chunks emitted). Triggering onFinished to cut call...`);
+                        this.stop();
+                        this.onFinished?.();
+                        return;
+                    }
+                }
+            }
+        }
+        this.#chunksEmitted++;
+        this.bytesProduced += frame.byteLength;
+        this.onChunk(frame);
+    };
+    stop = () => {
+        if (!this.#active)
+            return;
+        this.#active = false;
+        console.log(`[AudioFeeder] Stopped. Total emitted chunks: ${this.#chunksEmitted}, bytes: ${this.bytesProduced}`);
+        if (this.#timer) {
+            clearInterval(this.#timer);
+            this.#timer = null;
+        }
+        if (this.#proc) {
+            try {
+                this.#proc.kill("SIGTERM");
+            }
+            catch { }
+            this.#proc = null;
+        }
+        this.#playhead = 0;
+    };
+}

package/lib/Caller/audio-utils.js

@@ -0,0 +1,73 @@
+/**
+ * Audio Utilities for Chama Baileys VoIP Calling
+ * 
+ * Provides PCM Float32 conversion to valid RIFF WAV buffers and helpers.
+ * 
+ * @author Chama (@chamanemax02) & ShellTear
+ */
+import fs from "node:fs";
+import path from "node:path";
+
+/**
+ * Convert Float32Array audio chunks into a valid RIFF WAV buffer (16-bit PCM).
+ * 
+ * @param {Float32Array[]} chunks Array of Float32Array PCM chunks
+ * @param {number} [sampleRate=16000] Sample rate in Hz
+ * @param {number} [numChannels=1] Number of channels
+ * @returns {Buffer} Valid WAV audio Buffer
+ */
+export function float32ToWav(chunks, sampleRate = 16000, numChannels = 1) {
+    let totalSamples = 0;
+    for (const chunk of chunks) {
+        if (chunk && chunk.length) totalSamples += chunk.length;
+    }
+    const buffer = Buffer.alloc(44 + totalSamples * 2);
+
+    // RIFF chunk descriptor
+    buffer.write("RIFF", 0);
+    buffer.writeUInt32LE(36 + totalSamples * 2, 4);
+    buffer.write("WAVE", 8);
+
+    // "fmt " sub-chunk
+    buffer.write("fmt ", 12);
+    buffer.writeUInt32LE(16, 16);                               // Subchunk1Size (16 for PCM)
+    buffer.writeUInt16LE(1, 20);                                // AudioFormat (1 for PCM)
+    buffer.writeUInt16LE(numChannels, 22);                      // NumChannels
+    buffer.writeUInt32LE(sampleRate, 24);                       // SampleRate
+    buffer.writeUInt32LE(sampleRate * numChannels * 2, 28);     // ByteRate
+    buffer.writeUInt16LE(numChannels * 2, 32);                  // BlockAlign
+    buffer.writeUInt16LE(16, 34);                               // BitsPerSample (16-bit)
+
+    // "data" sub-chunk
+    buffer.write("data", 36);
+    buffer.writeUInt32LE(totalSamples * 2, 40);
+
+    let offset = 44;
+    for (const chunk of chunks) {
+        if (!chunk) continue;
+        for (let i = 0; i < chunk.length; i++) {
+            const s = Math.max(-1, Math.min(1, chunk[i]));
+            buffer.writeInt16LE(s < 0 ? Math.floor(s * 0x8000) : Math.floor(s * 0x7FFF), offset);
+            offset += 2;
+        }
+    }
+    return buffer;
+}
+
+/**
+ * Save Float32 PCM chunks to a WAV file on disk.
+ * 
+ * @param {Float32Array[]} chunks 
+ * @param {string} filePath 
+ * @param {number} [sampleRate=16000] 
+ * @returns {Buffer}
+ */
+export function saveFloat32ToWavFile(chunks, filePath, sampleRate = 16000) {
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    const wavBuffer = float32ToWav(chunks, sampleRate, 1);
+    fs.writeFileSync(filePath, wavBuffer);
+    return wavBuffer;
+}

package/lib/Caller/auto-answer.js

@@ -0,0 +1,115 @@
+/**
+ * Chama Baileys Caller — Voice Call Auto-Answer Plugin
+ * 
+ * Gives ANY Baileys bot instant WhatsApp VoIP voice call answering & audio playback!
+ * 
+ * @author Chama (@chamanemax02)
+ */
+
+import path from "node:path";
+import { printChamaBanner } from "./banner.js";
+import { VoipClient, CallState } from "./index.mjs";
+
+let _activeVoipClient = null;
+
+/**
+ * Enable WhatsApp Voice Call Auto-Answer with audio playback on any Baileys socket.
+ * 
+ * @param {any} sock The Baileys socket created by makeWASocket()
+ * @param {object} options Call configuration options
+ * @param {string} [options.audio="welcome.wav"] Path to MP3 / WAV audio to play
+ * @param {boolean} [options.autoAnswer=true] Automatically answer incoming calls
+ * @param {number} [options.answerDelayMs=200] Delay before answering in milliseconds
+ * @param {number} [options.durationMs=60000] Maximum call duration in milliseconds
+ * @param {function} [options.onCall] Callback when an incoming call arrives
+ * @param {function} [options.onAnswer] Callback when call is answered
+ * @param {function} [options.onEnd] Callback when call ends
+ * @returns {Promise<VoipClient>}
+ */
+export async function enableCallAutoAnswer(sock, options = {}) {
+  printChamaBanner();
+
+  if (_activeVoipClient) {
+    try {
+      _activeVoipClient.destroy?.();
+    } catch {}
+    _activeVoipClient = null;
+  }
+
+  const autoAnswer = options.autoAnswer !== false;
+  const audioSource = options.audio || options.audioSource || options.audioFile || "welcome.wav";
+  const videoSource = options.video || options.videoSource || options.videoFile || "sample.mp4";
+  const durationMs = options.durationMs || 60000;
+  const answerDelay = options.answerDelayMs || 200;
+  const loop = options.loop !== false;
+  const warmupSilenceMs = options.warmupSilenceMs || 1500;
+  const loopGapMs = options.loopGapMs || 1500;
+
+  console.log(`\x1b[38;5;82m📞 [Chama Caller] Voice/Video Engine Active — Auto-Answer: ${autoAnswer ? "ON" : "OFF"} | Audio: ${audioSource} | Video: ${videoSource} | Loop: ${loop ? "YES" : "NO"}\x1b[0m`);
+
+  const client = new VoipClient({
+    autoAnswer: false,
+    defaultAudioSource: audioSource,
+    defaultVideoSource: videoSource,
+    defaultDurationMs: durationMs,
+    loop,
+    warmupSilenceMs,
+    loopGapMs,
+  });
+
+  await client.attach(sock);
+  _activeVoipClient = client;
+
+  client.on("call", (call) => {
+    const callerNumber = call.peerJid ? call.peerJid.split("@")[0].split(":")[0] : "Unknown";
+    console.log(`\n\x1b[38;5;51m┌─────────────────────────────────────────────────────────────┐\x1b[0m`);
+    console.log(`\x1b[38;5;51m│\x1b[0m  \x1b[1;37m📲 [CHAMA CALL]\x1b[0m \x1b[38;5;213mIncoming WhatsApp ${call.isVideo ? "VIDEO" : "VOICE"} Call\x1b[0m`);
+    console.log(`\x1b[38;5;51m│\x1b[0m  👤 \x1b[38;5;222mCaller :\x1b[0m +${callerNumber}`);
+    console.log(`\x1b[38;5;51m│\x1b[0m  🆔 \x1b[38;5;222mCall ID:\x1b[0m ${call.callId}`);
+    console.log(`\x1b[38;5;51m└─────────────────────────────────────────────────────────────┘\x1b[0m`);
+
+    call.recordAudio = options.recordCallerAudio !== false;
+    const recordingsDir = options.recordingsDir || "./recordings";
+    call.saveRecordingPath = path.resolve(recordingsDir, `incoming_${call.isVideo ? "video" : "voice"}_${callerNumber}_${Date.now()}.wav`);
+
+    if (options.onCall) {
+      try { options.onCall(call); } catch {}
+    }
+
+    if (autoAnswer) {
+      setTimeout(() => {
+        try {
+          if (call.isVideo) {
+            call.accept(audioSource, videoSource, true);
+          } else {
+            call.accept(audioSource);
+          }
+          if (options.onAnswer) {
+            try { options.onAnswer(call); } catch {}
+          }
+        } catch (err) {
+          console.error("❌ [Chama Caller] Error answering call:", err.message);
+        }
+      }, answerDelay);
+    }
+
+    call.on("connected", () => {
+      console.log(`\x1b[38;5;46m✨ [CHAMA CALL] Connected to +${callerNumber}! Streaming ${call.isVideo ? "720p Video & Audio" : "Audio"}...\x1b[0m`);
+    });
+
+    call.on("ended", (reason) => {
+      console.log(`\x1b[38;5;208m📴 [CHAMA CALL] Call Ended with +${callerNumber} (${reason})\x1b[0m\n`);
+      if (options.onEnd) {
+        try { options.onEnd(call, reason); } catch {}
+      }
+    });
+  });
+
+  return client;
+}
+
+export function getActiveVoipClient() {
+  return _activeVoipClient;
+}
+
+export { CallState };

package/lib/Caller/banner.js

@@ -0,0 +1,41 @@
+/**
+ * Chama Baileys Caller — Custom Colored Welcome Banner
+ * @author Chama (@chamanemax02)
+ */
+
+export function printChamaBanner(botInfo = {}) {
+  const c = {
+    cyan: "\x1b[1;38;5;51m",
+    sky: "\x1b[38;5;45m",
+    blue: "\x1b[38;5;39m",
+    gold: "\x1b[1;38;5;220m",
+    pink: "\x1b[1;38;5;213m",
+    magenta: "\x1b[1;38;5;198m",
+    green: "\x1b[1;38;5;82m",
+    purple: "\x1b[38;5;141m",
+    white: "\x1b[1;37m",
+    dim: "\x1b[2m",
+    reset: "\x1b[0m",
+  };
+
+  const rawInfo = typeof botInfo === "string" ? botInfo : (botInfo?.id || botInfo?.name || "");
+  const cleanNumber = rawInfo ? rawInfo.split("@")[0].split(":")[0] : "Ready";
+
+  console.log(`
+${c.cyan}  ██████╗██╗  ██╗ █████╗ ███╗   ███╗ █████╗ 
+${c.sky} ██╔════╝██║  ██║██╔══██╗████╗ ████║██╔══██╗
+${c.blue} ██║     ███████║███████║██╔████╔██║███████║
+${c.purple} ██║     ██╔══██║██╔══██║██║╚██╔╝██║██╔══██║
+${c.magenta} ╚██████╗██║  ██║██║  ██║██║ ╚═╝ ██║██║  ██║
+${c.pink}  ╚═════╝╚═╝  ╚═╝╚═╝  ╚═╝╚═╝     ╚═╝╚═╝  ╚═╝${c.reset}
+
+${c.cyan}╔══════════════════════════════════════════════════════════════════════════╗
+║${c.gold}               ⚡ CHAMA BAILEYS CALL ENGINE v2.0 ⚡                       ${c.cyan}║
+║${c.dim}   ────────────────────────────────────────────────────────────────────   ${c.cyan}║
+║   ${c.pink}👑 Author    : ${c.white}CHAMA (@chamanemax02)                                  ${c.cyan}║
+║   ${c.purple}🚀 Engine    : ${c.white}WhatsApp VoIP Native WebRTC Audio Engine                ${c.cyan}║
+║   ${c.green}🟢 Connected : ${c.white}+${cleanNumber.padEnd(54)} ${c.cyan}║
+║   ${c.gold}📞 Auto-Call : ${c.white}READY — Listening for incoming WhatsApp voice calls!   ${c.cyan}║
+╚══════════════════════════════════════════════════════════════════════════╝${c.reset}
+`);
+}

package/lib/Caller/index.d.mts

@@ -0,0 +1,69 @@
+/**
+ * baileys-caller — WhatsApp voice calling for Node.js.
+ *
+ * Wraps WhatsApp Web's official VoIP WASM stack and routes signaling through
+ * Baileys. Public surface:
+ *
+ *   const client = new VoipClient({ authDir })
+ *   await client.connect()
+ *   const call = await client.call("12345678901", { audioSource: "./hi.mp3" })
+ *
+ * @author ShellTear
+ */
+import { EventEmitter } from "node:events";
+import { WasmEngine } from "./wasm-engine.mjs";
+import { CallState, type VoipSdkConfig } from "./types.mjs";
+export type { VoipSdkConfig, CallOptions, CallEvents, AudioConfig } from "./types.mjs";
+export { CallState } from "./types.mjs";
+export { AudioFeeder } from "./audio-feeder.mjs";
+/** A live or recently-ended call. */
+export declare class ActiveCall extends EventEmitter {
+    #private;
+    readonly callId: string;
+    private readonly engine;
+    readonly durationMs: number;
+    /** @internal mirrors the source path for the audio feeder */
+    _audioSource: string;
+    peerJid: string;
+    isIncoming: boolean;
+    /** @internal */
+    _shouldAutoAccept: boolean;
+    constructor(callId: string, engine: WasmEngine, durationMs: number);
+    get state(): CallState;
+    accept: (audioSource?: string) => void;
+    reject: () => void;
+    end: () => void;
+    mute: (muted: boolean) => void;
+    waitForEnd: () => Promise<string>;
+    /** @internal — called by VoipClient on WASM call-state change */
+    _updateState: (state: number) => void;
+    /** @internal */
+    _emitAudio: (pcm: Float32Array) => void;
+    /** @internal */
+    _forceEnd: (reason: string) => void;
+}
+/** Top-level client. Connects to WhatsApp and lets you place or answer calls. */
+export declare class VoipClient extends EventEmitter {
+    #private;
+    static preloadAudio: (source: string, sampleRate?: number, channels?: number) => Promise<Float32Array | null>;
+    constructor(config?: VoipSdkConfig);
+    get sock(): any;
+    get activeCall(): ActiveCall | null;
+    get engine(): WasmEngine | null;
+    /** Connect to WhatsApp and bring up the WASM VoIP stack. */
+    connect: () => Promise<void>;
+    /** Attach to an existing Baileys socket instead of creating a new one. */
+    attach: (sock: any) => Promise<void>;
+    /** Place an outbound voice call. */
+    call: (phoneNumber: string, opts?: {
+        audioSource?: string;
+        durationMs?: number;
+    }) => Promise<ActiveCall>;
+    /** Accept an incoming call */
+    acceptCall: (audioSource?: string) => void;
+    /** Reject an incoming call */
+    rejectCall: () => void;
+    /** Tear down the WhatsApp socket and release resources. */
+    disconnect: () => void;
+    destroy: () => void;
+}