@vanzxysenpai/baileys 0.0.0-stage → 0.0.2

package/lib/Utils/username.js

@@ -0,0 +1,59 @@
+// Vanz@Port (2.0.3) --- from rexxhayanasi/elaina-baileys 1.3.10 (username.js). Creator credits untouched. See NOTICE.md.
+export const USERNAME_MIN_LENGTH = 3;
+export const USERNAME_MAX_LENGTH = 35;
+export const USERNAME_PIN_LENGTH = 4;
+const LETTERS = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
+const DIGITS = '0123456789';
+const LETTER_SET = new Set(LETTERS.split(''));
+const ALLOWED_SET = new Set([...LETTERS.split(''), ...DIGITS.split(''), '_', '.']);
+const RESERVED_SUFFIXES = ['.com', '.org', '.net', '.int', '.edu', '.gov', '.mil', '.arpa', '.html', '.htm', '.txt', '.xml'];
+const RESERVED_WORDS = ['whatsapp', 'instagram', 'facebook', 'oculus'];
+const PIN_PATTERN = /^[0-9]{4}$/;
+export const UsernameValidationError = {
+    INVALID_CHARACTER: 'INVALID_CHARACTER',
+    INVALID_LENGTH: 'INVALID_LENGTH',
+    INVALID_NO_LETTERS: 'INVALID_NO_LETTERS',
+    INVALID_PERIODS: 'INVALID_PERIODS',
+    INVALID_DOMAIN_SUFFIX: 'INVALID_DOMAIN_SUFFIX',
+    INVALID_WWW_PREFIX: 'INVALID_WWW_PREFIX',
+    INVALID_WORD: 'INVALID_WORD'
+};
+export const stripUsernamePrefix = (username) => {
+    return typeof username === 'string' && username.startsWith('@') ? username.slice(1) : username;
+};
+export const displayUsername = (username) => {
+    return '@' + stripUsernamePrefix(username);
+};
+export const validateUsername = (username) => {
+    const value = stripUsernamePrefix(username);
+    if (typeof value !== 'string') {
+        return { isValid: false, errorType: UsernameValidationError.INVALID_CHARACTER };
+    }
+    const characters = Array.from(value);
+    if (!characters.every(character => ALLOWED_SET.has(character))) {
+        return { isValid: false, errorType: UsernameValidationError.INVALID_CHARACTER };
+    }
+    if (value.length < USERNAME_MIN_LENGTH || value.length > USERNAME_MAX_LENGTH) {
+        return { isValid: false, errorType: UsernameValidationError.INVALID_LENGTH };
+    }
+    if (!characters.some(character => LETTER_SET.has(character))) {
+        return { isValid: false, errorType: UsernameValidationError.INVALID_NO_LETTERS };
+    }
+    if (value.startsWith('.') || value.endsWith('.') || value.includes('..')) {
+        return { isValid: false, errorType: UsernameValidationError.INVALID_PERIODS };
+    }
+    const lowered = value.toLowerCase();
+    if (lowered.startsWith('www.')) {
+        return { isValid: false, errorType: UsernameValidationError.INVALID_WWW_PREFIX };
+    }
+    if (RESERVED_SUFFIXES.some(suffix => lowered.endsWith(suffix))) {
+        return { isValid: false, errorType: UsernameValidationError.INVALID_DOMAIN_SUFFIX };
+    }
+    if (RESERVED_WORDS.some(word => lowered.includes(word))) {
+        return { isValid: false, errorType: UsernameValidationError.INVALID_WORD };
+    }
+    return { isValid: true };
+};
+export const isUsernamePin = (pin) => {
+    return typeof pin === 'string' && PIN_PATTERN.test(pin);
+};

package/lib/Utils/validate-connection.d.ts

@@ -0,0 +1,43 @@
+export function generateLoginNode(userJid: any, config: any): proto.ClientPayload;
+export function generateRegistrationNode(opts2: { [key: string]: any; 
+    registrationId: any;
+    signedPreKey: any;
+    signedIdentityKey: any;
+}, config: any): proto.ClientPayload;
+export function configureSuccessfulPairing(stanza: any, opts1: { [key: string]: any; 
+    advSecretKey: any;
+    signedIdentityKey: any;
+    signalIdentities: any;
+}): {
+    creds: {
+        account: proto.ADVSignedDeviceIdentity;
+        me: {
+            id: any;
+            name: any;
+            lid: any;
+        };
+        signalIdentities: any[];
+        platform: any;
+    };
+    reply: {
+        tag: string;
+        attrs: {
+            to: "@s.whatsapp.net";
+            type: string;
+            id: any;
+        };
+        content: {
+            tag: string;
+            attrs: {};
+            content: {
+                tag: string;
+                attrs: {
+                    'key-index': any;
+                };
+                content: any;
+            }[];
+        }[];
+    };
+};
+export function encodeSignedDeviceIdentity(account: any, includeSignatureKey: any): any;
+import { proto } from '../../WAProto/index.js';

package/lib/Utils/validate-connection.js

@@ -0,0 +1,197 @@
+import { Boom } from '@hapi/boom';
+import { createHash } from 'crypto';
+import { proto } from '../../WAProto/index.js';
+import { KEY_BUNDLE_TYPE, WA_ADV_ACCOUNT_SIG_PREFIX, WA_ADV_DEVICE_SIG_PREFIX, WA_ADV_HOSTED_ACCOUNT_SIG_PREFIX, COMPANION_DEVICE_VERSION } from '../Defaults/index.js';
+import { getBinaryNodeChild, jidDecode, S_WHATSAPP_NET } from '../WABinary/index.js';
+import { Curve, hmacSign } from './crypto.js';
+import { encodeBigEndian } from './generics.js';
+import { createSignalIdentity } from './signal.js';
+const getUserAgent = (config) => {
+    return {
+        appVersion: {
+            primary: config.version[0],
+            secondary: config.version[1],
+            tertiary: config.version[2]
+        },
+        platform: proto.ClientPayload.UserAgent.Platform.WEB,
+        releaseChannel: proto.ClientPayload.UserAgent.ReleaseChannel.RELEASE,
+        osVersion: '0.1',
+        device: 'Desktop',
+        osBuildNumber: '0.1',
+        localeLanguageIso6391: 'en',
+        mnc: '000',
+        mcc: '000',
+        localeCountryIso31661Alpha2: config.countryCode
+    };
+};
+const PLATFORM_MAP = {
+    'Mac OS': proto.ClientPayload.WebInfo.WebSubPlatform.DARWIN,
+    Windows: proto.ClientPayload.WebInfo.WebSubPlatform.WIN32
+};
+const getWebInfo = (config) => {
+    let webSubPlatform = proto.ClientPayload.WebInfo.WebSubPlatform.WEB_BROWSER;
+    if (config.syncFullHistory &&
+        PLATFORM_MAP[config.browser[0]] &&
+        config.browser[1] === 'Desktop') {
+        webSubPlatform = PLATFORM_MAP[config.browser[0]];
+    }
+    return { webSubPlatform };
+};
+const getClientPayload = (config) => {
+    const payload = {
+        connectType: proto.ClientPayload.ConnectType.WIFI_UNKNOWN,
+        connectReason: proto.ClientPayload.ConnectReason.USER_ACTIVATED,
+        userAgent: getUserAgent(config)
+    };
+    payload.webInfo = getWebInfo(config);
+    if (config.pushName) {
+        payload.pushName = config.pushName;
+    }
+    return payload;
+};
+export const generateLoginNode = (userJid, config) => {
+    const { user, device } = jidDecode(userJid);
+    const payload = {
+        ...getClientPayload(config),
+        passive: true,
+        pull: true,
+        username: +user,
+        device: device,
+        lidDbMigrated: config.lidDbMigrated ?? false
+    };
+    return proto.ClientPayload.fromObject(payload);
+};
+const getPlatformType = (platform) => {
+    const platformType = platform.toUpperCase();
+    return (proto.DeviceProps.PlatformType[platformType] ||
+        proto.DeviceProps.PlatformType.CHROME);
+};
+export const generateRegistrationNode = ({ registrationId, signedPreKey, signedIdentityKey }, config) => {
+    // the app version needs to be md5 hashed
+    // and passed in
+    const appVersionBuf = createHash('md5')
+        .update(config.version.join('.')) // join as string
+        .digest();
+    const companion = {
+        os: config.browser[0],
+        platformType: getPlatformType(config.browser[1]),
+        requireFullSync: config.syncFullHistory,
+        historySyncConfig: {
+            storageQuotaMb: 10240,
+            inlineInitialPayloadInE2EeMsg: true,
+            recentSyncDaysLimit: undefined,
+            supportCallLogHistory: false,
+            supportBotUserAgentChatHistory: true,
+            supportCagReactionsAndPolls: true,
+            supportBizHostedMsg: true,
+            supportRecentSyncChunkMessageCountTuning: true,
+            supportHostedGroupMsg: true,
+            supportFbidBotChatHistory: true,
+            supportAddOnHistorySyncMigration: undefined,
+            supportMessageAssociation: true,
+            supportGroupHistory: false,
+            onDemandReady: undefined,
+            supportGuestChat: undefined
+        },
+        version: COMPANION_DEVICE_VERSION
+    };
+    const companionProto = proto.DeviceProps.encode(companion).finish();
+    const registerPayload = {
+        ...getClientPayload(config),
+        passive: false,
+        pull: false,
+        devicePairingData: {
+            buildHash: appVersionBuf,
+            deviceProps: companionProto,
+            eRegid: encodeBigEndian(registrationId),
+            eKeytype: KEY_BUNDLE_TYPE,
+            eIdent: signedIdentityKey.public,
+            eSkeyId: encodeBigEndian(signedPreKey.keyId, 3),
+            eSkeyVal: signedPreKey.keyPair.public,
+            eSkeySig: signedPreKey.signature
+        }
+    };
+    return proto.ClientPayload.fromObject(registerPayload);
+};
+export const configureSuccessfulPairing = (stanza, { advSecretKey, signedIdentityKey, signalIdentities }) => {
+    const msgId = stanza.attrs.id;
+    const pairSuccessNode = getBinaryNodeChild(stanza, 'pair-success');
+    const deviceIdentityNode = getBinaryNodeChild(pairSuccessNode, 'device-identity');
+    const platformNode = getBinaryNodeChild(pairSuccessNode, 'platform');
+    const deviceNode = getBinaryNodeChild(pairSuccessNode, 'device');
+    const businessNode = getBinaryNodeChild(pairSuccessNode, 'biz');
+    if (!deviceIdentityNode || !deviceNode) {
+        throw new Boom('Missing device-identity or device in pair success node', { data: stanza });
+    }
+    const bizName = businessNode?.attrs.name;
+    const jid = deviceNode.attrs.jid;
+    const lid = deviceNode.attrs.lid;
+    const { details, hmac, accountType } = proto.ADVSignedDeviceIdentityHMAC.decode(deviceIdentityNode.content);
+    let hmacPrefix = Buffer.from([]);
+    if (accountType !== undefined && accountType === proto.ADVEncryptionType.HOSTED) {
+        hmacPrefix = WA_ADV_HOSTED_ACCOUNT_SIG_PREFIX;
+    }
+    const advSign = hmacSign(Buffer.concat([hmacPrefix, details]), Buffer.from(advSecretKey, 'base64'));
+    if (Buffer.compare(hmac, advSign) !== 0) {
+        throw new Boom('Invalid account signature');
+    }
+    const account = proto.ADVSignedDeviceIdentity.decode(details);
+    const { accountSignatureKey, accountSignature, details: deviceDetails } = account;
+    const deviceIdentity = proto.ADVDeviceIdentity.decode(deviceDetails);
+    const accountSignaturePrefix = deviceIdentity.deviceType === proto.ADVEncryptionType.HOSTED
+        ? WA_ADV_HOSTED_ACCOUNT_SIG_PREFIX
+        : WA_ADV_ACCOUNT_SIG_PREFIX;
+    const accountMsg = Buffer.concat([accountSignaturePrefix, deviceDetails, signedIdentityKey.public]);
+    if (!Curve.verify(accountSignatureKey, accountMsg, accountSignature)) {
+        throw new Boom('Failed to verify account signature');
+    }
+    const deviceMsg = Buffer.concat([
+        WA_ADV_DEVICE_SIG_PREFIX,
+        deviceDetails,
+        signedIdentityKey.public,
+        accountSignatureKey
+    ]);
+    account.deviceSignature = Curve.sign(signedIdentityKey.private, deviceMsg);
+    const identity = createSignalIdentity(lid, accountSignatureKey);
+    const accountEnc = encodeSignedDeviceIdentity(account, false);
+    const reply = {
+        tag: 'iq',
+        attrs: {
+            to: S_WHATSAPP_NET,
+            type: 'result',
+            id: msgId
+        },
+        content: [
+            {
+                tag: 'pair-device-sign',
+                attrs: {},
+                content: [
+                    {
+                        tag: 'device-identity',
+                        attrs: { 'key-index': deviceIdentity.keyIndex.toString() },
+                        content: accountEnc
+                    }
+                ]
+            }
+        ]
+    };
+    const authUpdate = {
+        account,
+        me: { id: jid, name: bizName, lid },
+        signalIdentities: [...(signalIdentities || []), identity],
+        platform: platformNode?.attrs.name
+    };
+    return {
+        creds: authUpdate,
+        reply
+    };
+};
+export const encodeSignedDeviceIdentity = (account, includeSignatureKey) => {
+    account = { ...account };
+    // set to null if we are not to include the signature key
+    // or if we are including the signature key but it is empty
+    if (!includeSignatureKey || !account.accountSignatureKey?.length) {
+        account.accountSignatureKey = null;
+    }
+    return proto.ADVSignedDeviceIdentity.encode(account).finish();
+};

package/lib/Utils/vcard.d.ts

@@ -0,0 +1,40 @@
+export function escapeVCard(s: any): any;
+export function unescapeVCard(s: any): any;
+export function formatPhone(p: any): any;
+export function generateVCard(c: any): string;
+export function generateVCards(contacts: any): any;
+export function parseVCard(vcard: any): {
+    fullName: any;
+    organization: any;
+    title: any;
+    phones: any;
+    emails: any;
+    birthday: any;
+    note: any;
+};
+export function createContactCard(contact: any): {
+    contacts: {
+        displayName: any;
+        contacts: {
+            vcard: string;
+        }[];
+    };
+};
+export function createContactCards(contacts: any): {
+    contacts: {
+        displayName: any;
+        contacts: any;
+    };
+};
+export function quickContact(name: any, phone: any, options: any): {
+    fullName: any;
+    phones: {
+        number: any;
+        type: string;
+    }[];
+    organization: any;
+    emails: {
+        email: any;
+        type: string;
+    }[];
+};

package/lib/Utils/vcard.js

@@ -0,0 +1,92 @@
+export const escapeVCard = (s) => s.replace(/\\/g, '\\\\').replace(/;/g, '\\;').replace(/,/g, '\\,').replace(/\n/g, '\\n');
+export const unescapeVCard = (s) => s.replace(/\\(.)/g, (_, ch) => (ch === 'n' ? '\n' : ch));
+export const formatPhone = (p) => p.replace(/[^\d+]/g, '');
+/** Build a VCARD 3.0 string from structured contact data. */
+export const generateVCard = (c) => {
+    const lines = ['BEGIN:VCARD', 'VERSION:3.0', `FN:${escapeVCard(c.fullName)}`];
+    const parts = c.fullName.split(' ');
+    if (parts.length >= 2) {
+        const last = parts[parts.length - 1] || '';
+        const first = parts.slice(0, -1).join(' ');
+        lines.push(`N:${escapeVCard(last)};${escapeVCard(first)};;;`);
+    }
+    else {
+        lines.push(`N:${escapeVCard(c.fullName)};;;;`);
+    }
+    if (c.organization)
+        lines.push(`ORG:${escapeVCard(c.organization)}`);
+    if (c.title)
+        lines.push(`TITLE:${escapeVCard(c.title)}`);
+    for (const p of c.phones ?? []) {
+        const t = p.type || 'CELL';
+        const n = formatPhone(p.number);
+        lines.push(p.label ? `TEL;type=${t};type=VOICE;X-ABLabel=${escapeVCard(p.label)}:${n}` : `TEL;type=${t};type=VOICE:${n}`);
+    }
+    for (const e of c.emails ?? [])
+        lines.push(`EMAIL;type=${e.type || 'OTHER'}:${e.email}`);
+    for (const u of c.urls ?? [])
+        lines.push(`URL;type=${u.type || 'OTHER'}:${u.url}`);
+    for (const a of c.addresses ?? []) {
+        const t = a.type || 'OTHER';
+        const parts = ['', '', a.street || '', a.city || '', a.state || '', a.postalCode || '', a.country || ''].map((v) => escapeVCard(v));
+        lines.push(`ADR;type=${t}:${parts.join(';')}`);
+    }
+    if (c.birthday)
+        lines.push(`BDAY:${c.birthday}`);
+    if (c.note)
+        lines.push(`NOTE:${escapeVCard(c.note)}`);
+    lines.push('END:VCARD');
+    return lines.join('\r\n');
+};
+export const generateVCards = (contacts) => contacts.map(generateVCard).join('\r\n');
+/** Parse a subset of VCARD fields back into structured data. */
+export const parseVCard = (vcard) => {
+    const contact = {};
+    for (const line of vcard.split(/\r?\n/)) {
+        const [key, ...vp] = line.split(':');
+        if (!key)
+            continue;
+        const value = vp.join(':');
+        if (key.startsWith('FN'))
+            contact.fullName = unescapeVCard(value);
+        else if (key.startsWith('ORG'))
+            contact.organization = unescapeVCard(value);
+        else if (key.startsWith('TITLE'))
+            contact.title = unescapeVCard(value);
+        else if (key.startsWith('TEL')) {
+            contact.phones = contact.phones || [];
+            const tm = key.match(/type=(\w+)/i);
+            contact.phones.push({ number: value, type: tm?.[1]?.toUpperCase() || 'CELL' });
+        }
+        else if (key.startsWith('EMAIL')) {
+            contact.emails = contact.emails || [];
+            const tm = key.match(/type=(\w+)/i);
+            contact.emails.push({ email: value, type: tm?.[1]?.toUpperCase() || 'OTHER' });
+        }
+        else if (key.startsWith('BDAY'))
+            contact.birthday = value;
+        else if (key.startsWith('NOTE'))
+            contact.note = unescapeVCard(value);
+    }
+    return contact;
+};
+/** Ready-to-send `contacts` message content for a single contact. */
+export const createContactCard = (contact) => ({
+    contacts: {
+        displayName: contact.displayName || contact.fullName,
+        contacts: [{ vcard: generateVCard(contact) }]
+    }
+});
+/** Ready-to-send `contacts` message content for multiple contacts. */
+export const createContactCards = (contacts) => ({
+    contacts: {
+        displayName: contacts.length === 1 ? contacts[0]?.displayName || contacts[0]?.fullName || '' : `${contacts.length} Contacts`,
+        contacts: contacts.map((c) => ({ vcard: generateVCard(c) }))
+    }
+});
+export const quickContact = (name, phone, options) => ({
+    fullName: name,
+    phones: [{ number: phone, type: 'CELL' }],
+    organization: options?.organization,
+    emails: options?.email ? [{ email: options.email, type: 'WORK' }] : undefined
+});

package/lib/Utils/voice-note.d.ts

@@ -0,0 +1,13 @@
+/** Upper bound for a buffered voice note before conversion (WhatsApp voice notes are short; this only stops runaway inputs). */
+export const MAX_VOICE_NOTE_BYTES: number;
+export function isOggBuffer(buf: any): boolean;
+export function buildVoiceNoteContent(audio: any, opts1?: { [key: string]: any; 
+    convert?: boolean;
+}): Promise<{
+    audio: any;
+    ptt: boolean;
+    mimetype: string;
+    waveform: any;
+    seconds: any;
+}>;
+export function sendVoiceNote(sock: any, jid: any, audio: any, opts2?: { [key: string]: any; }): Promise<any>;

package/lib/Utils/voice-note.js

@@ -0,0 +1,47 @@
+// Vanz@Port (2.0.3) --- from @japofc/baileys 2.4.1 (MIT, author JAPofc / J.AP), lib/Utils/voice-note.js. See NOTICE.md.
+// Changed vs donor: URL/file/stream inputs go through this fork's getStream() (same fetch path as every other media input) instead of
+// a bare fetch() with no timeout or size limit, and the buffered audio is capped (MAX_VOICE_NOTE_BYTES).
+import { Boom } from '@hapi/boom';
+import { getStream, toBuffer } from './messages-media.js';
+/** Upper bound for a buffered voice note before conversion (WhatsApp voice notes are short; this only stops runaway inputs). */
+export const MAX_VOICE_NOTE_BYTES = 64 * 1024 * 1024;
+/** True when the buffer starts with the OGG container magic ('OggS'). */
+export const isOggBuffer = (buf) => Buffer.isBuffer(buf) && buf.length > 4 && buf.subarray(0, 4).toString('latin1') === 'OggS';
+const resolveAudioBuffer = async (audio) => {
+    if (Buffer.isBuffer(audio)) {
+        return audio;
+    }
+    if (audio == null || (typeof audio !== 'string' && typeof audio !== 'object')) {
+        throw new Boom('voice note audio must be a Buffer, a file path, a URL, { url } or a stream', { statusCode: 400 });
+    }
+    const input = typeof audio === 'string' ? { url: audio } : audio;
+    let buf;
+    try {
+        const { stream } = await getStream(input, { maxContentLength: MAX_VOICE_NOTE_BYTES });
+        buf = await toBuffer(stream);
+    }
+    catch (err) {
+        throw new Boom(`voice note: cannot read audio (${err?.message || err})`, { statusCode: 400 });
+    }
+    if (buf.length > MAX_VOICE_NOTE_BYTES) {
+        throw new Boom(`voice note: audio exceeds ${MAX_VOICE_NOTE_BYTES} bytes`, { statusCode: 413 });
+    }
+    return buf;
+};
+/** Build `sendMessage`-ready voice-note content (converts to mono 16 kHz Opus/OGG unless already OGG or `convert: false`). */
+export const buildVoiceNoteContent = async (audio, { convert = true, waveform, seconds, ...passthrough } = {}) => {
+    let buf = await resolveAudioBuffer(audio);
+    if (convert && !isOggBuffer(buf)) {
+        // Dynamic import: Framework is not imported by Socket/Utils statically (cycle-safe).
+        const { MediaManager } = await import('../Framework/MediaManager.js');
+        buf = await MediaManager.convertToVoiceNote(buf);
+    }
+    return { audio: buf, ptt: true, mimetype: 'audio/ogg; codecs=opus', waveform, seconds, ...passthrough };
+};
+/** Standalone sender: `sendVoiceNote(sock, jid, audio, opts?)`. */
+export const sendVoiceNote = async (sock, jid, audio, { convert, waveform, seconds, ...sendOptions } = {}) => {
+    if (!sock || typeof sock.sendMessage !== 'function') {
+        throw new Boom('sendVoiceNote(sock, ...) requires an active Baileys socket', { statusCode: 400 });
+    }
+    return sock.sendMessage(jid, await buildVoiceNoteContent(audio, { convert, waveform, seconds }), sendOptions);
+};

package/lib/VoIP/audio-feeder.d.ts

@@ -0,0 +1,15 @@
+export class AudioFeeder {
+    constructor(sampleRate: any, channels: any, framesPerChunk: any, onChunk: any, source?: string);
+    sampleRate: any;
+    channels: any;
+    framesPerChunk: any;
+    onChunk: any;
+    source: string;
+    droppedChunks: number;
+    underflowChunks: number;
+    bytesProduced: number;
+    chunksEmitted: number;
+    start: () => void;
+    stop: () => void;
+    #private;
+}

package/lib/VoIP/audio-feeder.js

@@ -0,0 +1,132 @@
+/**
+ * Audio feeder.
+ *
+ * Spawns ffmpeg to decode `source` into f32le PCM at the requested rate, then
+ * meters frames out at chunk-cadence to the WASM uplink.
+ *
+ * @author ShellTear
+ */
+import { spawn } from "node:child_process";
+const LOW_WATERMARK_CHUNKS = 16;
+const MAX_QUEUED_CHUNKS = 1024;
+const DEFAULT_WARMUP_MS = 500;
+export class AudioFeeder {
+    sampleRate;
+    channels;
+    framesPerChunk;
+    onChunk;
+    source;
+    #proc = null;
+    #pending = Buffer.alloc(0);
+    #queue = [];
+    #emitTimer = null;
+    #nextEmitAtMs = 0;
+    #warmupUntilMs = 0;
+    droppedChunks = 0;
+    underflowChunks = 0;
+    bytesProduced = 0;
+    chunksEmitted = 0;
+    constructor(sampleRate, channels, framesPerChunk, onChunk, source = "silence") {
+        this.sampleRate = sampleRate;
+        this.channels = channels;
+        this.framesPerChunk = framesPerChunk;
+        this.onChunk = onChunk;
+        this.source = source;
+    }
+    start = () => {
+        if (this.#proc)
+            return;
+        const chunkSamples = this.framesPerChunk * this.channels;
+        const chunkBytes = chunkSamples * Float32Array.BYTES_PER_ELEMENT;
+        const chunkIntervalMs = (this.framesPerChunk / this.sampleRate) * 1000;
+        const inputArgs = this.#resolveInputArgs();
+        this.#proc = spawn("ffmpeg", [
+            "-hide_banner",
+            "-loglevel", "error",
+            "-thread_queue_size", "512",
+            ...inputArgs,
+            "-f", "f32le",
+            "-ac", String(this.channels),
+            "-ar", String(this.sampleRate),
+            "pipe:1",
+        ]);
+        this.#proc.stdout.on("data", (chunk) => {
+            this.#pending = Buffer.concat([this.#pending, chunk]);
+            while (this.#pending.length >= chunkBytes) {
+                if (this.#queue.length >= MAX_QUEUED_CHUNKS) {
+                    this.#proc?.stdout.pause();
+                    break;
+                }
+                const frame = this.#pending.subarray(0, chunkBytes);
+                this.#pending = this.#pending.subarray(chunkBytes);
+                const out = new Float32Array(chunkSamples);
+                out.set(new Float32Array(frame.buffer, frame.byteOffset, chunkSamples));
+                this.bytesProduced += chunkBytes;
+                this.#queue.push(out);
+            }
+        });
+        this.#proc.stderr.on("data", (chunk) => {
+            process.stderr.write(`[AudioFeeder] ${chunk.toString().trim()}\n`);
+        });
+        this.#proc.on("exit", (code) => {
+            if (code !== 0 && code !== null) {
+                process.stderr.write(`[AudioFeeder] ffmpeg exited with code=${code}\n`);
+            }
+            this.#proc = null;
+        });
+        this.#nextEmitAtMs = 0;
+        this.#warmupUntilMs = Date.now() + DEFAULT_WARMUP_MS;
+        this.#scheduleNext(chunkSamples, chunkIntervalMs);
+    };
+    stop = () => {
+        if (this.#emitTimer) {
+            clearTimeout(this.#emitTimer);
+            this.#emitTimer = null;
+        }
+        this.#proc?.kill("SIGTERM");
+        this.#proc = null;
+        this.#pending = Buffer.alloc(0);
+        this.#queue = [];
+        this.#warmupUntilMs = 0;
+    };
+    #resolveInputArgs = () => {
+        if (!this.source || this.source === "silence") {
+            return ["-f", "lavfi", "-i", `aevalsrc=0:d=3600:s=${this.sampleRate}`];
+        }
+        if (this.source.startsWith("lavfi:")) {
+            return ["-f", "lavfi", "-i", this.source.slice("lavfi:".length)];
+        }
+        return ["-i", this.source];
+    };
+    #scheduleNext = (chunkSamples, chunkIntervalMs) => {
+        if (!this.#proc)
+            return;
+        const now = Date.now();
+        if (this.#nextEmitAtMs === 0)
+            this.#nextEmitAtMs = now;
+        const delayMs = Math.max(0, this.#nextEmitAtMs - now);
+        this.#emitTimer = setTimeout(() => {
+            this.#emitTimer = null;
+            if (this.#queue.length < LOW_WATERMARK_CHUNKS && Date.now() < this.#warmupUntilMs) {
+                this.#nextEmitAtMs = Date.now() + 10;
+                this.#scheduleNext(chunkSamples, chunkIntervalMs);
+                return;
+            }
+            this.#flushOne(chunkSamples);
+            this.#nextEmitAtMs += chunkIntervalMs;
+            this.#scheduleNext(chunkSamples, chunkIntervalMs);
+        }, delayMs);
+    };
+    #flushOne = (chunkSamples) => {
+        let nextChunk = this.#queue.shift();
+        if (!nextChunk) {
+            nextChunk = new Float32Array(chunkSamples);
+            this.underflowChunks += 1;
+        }
+        this.chunksEmitted += 1;
+        this.onChunk(nextChunk);
+        if (this.#proc?.stdout.isPaused() && this.#queue.length <= MAX_QUEUED_CHUNKS / 4) {
+            this.#proc.stdout.resume();
+        }
+    };
+}

package/lib/VoIP/index.d.ts

@@ -0,0 +1,22 @@
+export { CallState } from "./types.js";
+export class ActiveCall {
+    constructor(callId: any, engine: any, durationMs: any);
+    _audioSource: string;
+    callId: any;
+    engine: any;
+    get state(): number;
+    end: () => void;
+    mute: (muted: any) => void;
+    waitForEnd: () => Promise<any>;
+    _updateState: (state: any) => void;
+    _emitAudio: (pcm: any) => void;
+    _forceEnd: (reason: any) => void;
+    #private;
+}
+export class VoipClient {
+    constructor(config?: {});
+    connectWithSocket: (existingSock: any) => Promise<void>;
+    call: (phoneNumber: any, opts?: {}) => Promise<ActiveCall>;
+    disconnect: () => void;
+    #private;
+}