@japofc/baileys 2.1.0

package/lib/Utils/validate-connection.js

@@ -0,0 +1,198 @@
+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,
+        // JAP@Fix (bug 49): was hardcoded false — now reads from config.lidDbMigrated (default false until investigated)
+        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,58 @@
+export interface ContactPhone {
+    number: string;
+    type?: string;
+    label?: string;
+}
+export interface ContactEmail {
+    email: string;
+    type?: string;
+}
+export interface ContactUrl {
+    url: string;
+    type?: string;
+}
+export interface ContactAddress {
+    street?: string;
+    city?: string;
+    state?: string;
+    postalCode?: string;
+    country?: string;
+    type?: string;
+}
+export interface ContactData {
+    fullName: string;
+    displayName?: string;
+    organization?: string;
+    title?: string;
+    phones?: ContactPhone[];
+    emails?: ContactEmail[];
+    urls?: ContactUrl[];
+    addresses?: ContactAddress[];
+    birthday?: string;
+    note?: string;
+}
+export declare const escapeVCard: (s: string) => string;
+export declare const formatPhone: (p: string) => string;
+export declare const generateVCard: (c: ContactData) => string;
+export declare const generateVCards: (contacts: ContactData[]) => string;
+export declare const parseVCard: (vcard: string) => Partial<ContactData>;
+export declare const createContactCard: (contact: ContactData) => {
+    contacts: {
+        displayName: string;
+        contacts: {
+            vcard: string;
+        }[];
+    };
+};
+export declare const createContactCards: (contacts: ContactData[]) => {
+    contacts: {
+        displayName: string;
+        contacts: {
+            vcard: string;
+        }[];
+    };
+};
+export declare const quickContact: (name: string, phone: string, options?: {
+    organization?: string;
+    email?: string;
+}) => ContactData;

package/lib/Utils/vcard.js

@@ -0,0 +1,104 @@
+// JAP@Add --- part of the @japofc/baileys utils (vcard.ts) (type-only
+// annotations dropped; behavior unchanged).
+export const escapeVCard = (s) => s.replace(/\\/g, '\\\\').replace(/;/g, '\\;').replace(/,/g, '\\,').replace(/\n/g, '\\n');
+// JAP@Fix 30-08-26 --- the old inline unescape used for FN/ORG/TITLE,
+// `value.replace(/\\([;,n\\])/g, '$1')`, mishandled the `\n` case: it matched
+// the backslash + literal "n" produced by escapeVCard's `\n` escape, then
+// substituted back just the captured "n" character instead of a real newline
+// (`$1` is literally the char "n", not the escape sequence). So a name/org/
+// title containing a real newline round-tripped as "n" inserted in place of
+// the line break instead of the original newline. NOTE already unescaped
+// `\n` correctly on its own, separately. This single helper now reverses
+// every escape escapeVCard() produces (backslash, semicolon, comma, newline)
+// the same correct way, and is reused for all four fields below.
+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,15 @@
+/**
+ * JAP@Add --- Type declarations for the voice-note sender.
+ */
+export interface VoiceNoteBuildOptions {
+    convert?: boolean;
+    waveform?: number[] | Buffer;
+    seconds?: number;
+    [key: string]: any;
+}
+export declare const buildVoiceNoteContent: (audio: Buffer | string | {
+    url: string;
+}, opts?: VoiceNoteBuildOptions) => Promise<any>;
+export declare const sendVoiceNote: (sock: any, jid: any, audio: Buffer | string | {
+    url: string;
+}, options?: any) => Promise<any>;

package/lib/Utils/voice-note.js

@@ -0,0 +1,63 @@
+/**
+ * JAP@Add --- Voice-note (PTT) sender.
+ *
+ * WhatsApp only plays voice notes encoded as mono 16kHz Opus in OGG. This
+ * helper converts anything (mp3/wav/m4a/...) via `MediaManager.convertToVoiceNote`
+ * unless the input already is OGG, then sends it with `ptt: true`.
+ * Duration + waveform are auto-computed by the media pipeline when the optional
+ * `audio-decode` / `music-metadata` packages are installed.
+ *
+ * ```js
+ * await sendVoiceNote(sock, jid, './hello.mp3') // path | Buffer | { url }
+ * // or: await sock.sendVoiceNote(jid, './hello.mp3')
+ * ```
+ */
+import { Boom } from '@hapi/boom';
+import { readFile } from 'node:fs/promises';
+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;
+    }
+    const source = typeof audio === 'string' ? audio : audio?.url;
+    if (!source || typeof source !== 'string') {
+        throw new Boom('sendVoiceNote audio must be a Buffer, a file path, a URL, or { url }', { statusCode: 400 });
+    }
+    if (/^https?:\/\//i.test(source)) {
+        const res = await fetch(source);
+        if (!res.ok) {
+            throw new Boom(`sendVoiceNote: fetch failed with HTTP ${res.status}`, { statusCode: 400 });
+        }
+        return Buffer.from(await res.arrayBuffer());
+    }
+    try {
+        return await readFile(source);
+    }
+    catch (err) {
+        throw new Boom(`sendVoiceNote: cannot read file ${source} (${err?.message || err})`, { statusCode: 400 });
+    }
+};
+/** Build `sendMessage`-ready voice-note content (converts to Opus OGG unless skipped). */
+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?)`. A `sock.sendVoiceNote` alias exists too. */
+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,18 @@
+export declare class AudioFeeder {
+    #private;
+    private readonly sampleRate;
+    private readonly channels;
+    private readonly framesPerChunk;
+    private readonly onChunk;
+    private readonly source;
+    droppedChunks: number;
+    underflowChunks: number;
+    bytesProduced: number;
+    chunksEmitted: number;
+    constructor(sampleRate: number, channels: number, framesPerChunk: number, onChunk: (chunk: Float32Array) => void, source?: string | {
+        data: Buffer;
+        ext?: string;
+    });
+    start: () => void;
+    stop: () => void;
+}

package/lib/VoIP/audio-feeder.js

@@ -0,0 +1,160 @@
+/**
+ * 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 J.AP
+ */
+import { spawn } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import { unlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+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);
+    #tempFile = null; // JAP@Add --- temp copy for { data: Buffer } sources
+    #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);
+            }
+        });
+        // JAP@Add --- clear error when ffmpeg is not installed
+        this.#proc.on("error", (err) => {
+            if (err?.code === "ENOENT") {
+                process.stderr.write('[AudioFeeder] ffmpeg binary not found — install ffmpeg to feed call audio (or use audioSource: "silence").\n');
+            }
+            this.#proc = null;
+        });
+        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;
+        // JAP@Add --- remove temp file created for Buffer sources
+        if (this.#tempFile) {
+            try {
+                unlinkSync(this.#tempFile);
+            }
+            catch { }
+            this.#tempFile = null;
+        }
+    };
+    #resolveInputArgs = () => {
+        if (!this.source || this.source === "silence") {
+            return ["-f", "lavfi", "-i", `aevalsrc=0:d=3600:s=${this.sampleRate}`];
+        }
+        // JAP@Add --- in-memory audio: { data: Buffer, ext: 'mp3' } via temp file
+        if (this.source && typeof this.source === "object" && Buffer.isBuffer(this.source.data)) {
+            const ext = String(this.source.ext || "ogg").replace(/[^a-z0-9]/gi, "") || "ogg";
+            const tmp = join(tmpdir(), `jap-voip-${Date.now()}-${randomBytes(4).toString("hex")}.${ext}`);
+            writeFileSync(tmp, this.source.data);
+            this.#tempFile = tmp;
+            return ["-i", tmp];
+        }
+        if (typeof this.source === "string" && 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/call-recorder.d.ts

@@ -0,0 +1,13 @@
+/**
+ * JAP@Add --- Type declarations for the VoIP WAV recorder.
+ */
+export interface WavRecorderOptions {
+    sampleRate?: number;
+    channels?: number;
+}
+export interface WavRecorder {
+    write(pcm: Float32Array): void;
+    close(): void;
+    readonly bytesWritten: number;
+}
+export declare const createWavRecorder: (filePath: string, opts?: WavRecorderOptions) => WavRecorder;