@vanzxy/baileys 1.6.4 → 1.6.6

package/lib/Utils/chat-control.js

@@ -0,0 +1,232 @@
+/**
+ * Chat Control Utilities
+ *
+ * Source: @innovatorssoft/baileys (chat-control.js)
+ * Rewritten as clean TypeScript with full types and JSDoc.
+ *
+ * Three components:
+ *  - TypingIndicator  — composing / recording presence helpers
+ *  - PinnedMessagesManager — client-side pin tracking
+ *  - ReadReceiptController — configurable automatic read receipts
+ */
+// ─── Constants ─────────────────────────────────────────────────────────────────
+/**
+ * Standard disappearing-message duration constants (in seconds).
+ * Pass to `sock.sendMessage(jid, { disappearingMessagesInChat: DISAPPEARING_DURATIONS.DAYS_7 })`.
+ */
+export const DISAPPEARING_DURATIONS = {
+    /** Disable disappearing messages */
+    OFF: 0,
+    /** 24 hours */
+    HOURS_24: 86400,
+    /** 7 days */
+    DAYS_7: 604800,
+    /** 90 days */
+    DAYS_90: 7776000
+};
+/**
+ * Manages composing ("typing...") and recording ("recording...") presence
+ * indicators with per-JID timer tracking.
+ *
+ * @example
+ * const typing = createTypingIndicator(
+ *     (jid, presence) => sock.sendPresenceUpdate(presence, jid)
+ * )
+ *
+ * // Simulate typing then send a message
+ * const result = await typing.simulateTyping(jid, 1500, () =>
+ *     sock.sendMessage(jid, { text: 'Hello!' })
+ * )
+ */
+export class TypingIndicator {
+    constructor(sendPresence) {
+        this.sendPresence = sendPresence;
+        this.timers = new Map();
+    }
+    /** Show the "typing..." (composing) indicator for a JID. */
+    async startTyping(jid, options = {}) {
+        this.clearTimer(jid);
+        await this.sendPresence(jid, 'composing');
+        if (options.autoPause !== false && options.duration) {
+            const t = setTimeout(() => void this.stopTyping(jid), options.duration);
+            this.timers.set(jid, t);
+        }
+    }
+    /** Show the "recording..." (audio/video) indicator for a JID. */
+    async startRecording(jid, options = {}) {
+        this.clearTimer(jid);
+        await this.sendPresence(jid, 'recording');
+        if (options.autoPause !== false && options.duration) {
+            const t = setTimeout(() => void this.stopTyping(jid), options.duration);
+            this.timers.set(jid, t);
+        }
+    }
+    /** Stop any active composing/recording indicator for a JID. */
+    async stopTyping(jid) {
+        this.clearTimer(jid);
+        try {
+            await this.sendPresence(jid, 'paused');
+        }
+        catch {
+            // Ignore errors when stopping presence (connection may be closed)
+        }
+    }
+    /** Stop all active indicators. */
+    async stopAll() {
+        const jids = Array.from(this.timers.keys());
+        await Promise.all(jids.map(jid => this.stopTyping(jid)));
+    }
+    /**
+     * Show typing for `durationMs`, run `callback`, then stop the indicator.
+     *
+     * @template T
+     * @returns The return value of `callback`
+     *
+     * @example
+     * await typing.simulateTyping(jid, 2000, async () => {
+     *     await sock.sendMessage(jid, { text: 'Here is your answer' })
+     * })
+     */
+    async simulateTyping(jid, durationMs, callback) {
+        await this.startTyping(jid);
+        await new Promise(resolve => setTimeout(resolve, durationMs));
+        await this.stopTyping(jid);
+        return callback();
+    }
+    clearTimer(jid) {
+        const existing = this.timers.get(jid);
+        if (existing) {
+            clearTimeout(existing);
+            this.timers.delete(jid);
+        }
+    }
+}
+/** Factory — create a TypingIndicator. */
+export const createTypingIndicator = (sendPresence) => new TypingIndicator(sendPresence);
+/**
+ * Client-side tracker for pinned messages.
+ * Listen to `messages.update` for `pinInChatMessage` protocol messages and call
+ * `manager.pin(jid, msgId, pinnedBy)` / `manager.unpin(jid, msgId)` accordingly.
+ */
+export class PinnedMessagesManager {
+    constructor() {
+        this.store = new Map();
+    }
+    /**
+     * Record a newly pinned message.
+     * @returns The created pin entry
+     */
+    pin(jid, messageId, pinnedBy, expiresAt) {
+        const entry = { messageId, jid, pinnedAt: new Date(), pinnedBy, expiresAt };
+        const existing = this.store.get(jid) ?? [];
+        // Remove any previous pin with the same message ID before re-adding
+        const filtered = existing.filter(p => p.messageId !== messageId);
+        filtered.push(entry);
+        this.store.set(jid, filtered);
+        return entry;
+    }
+    /**
+     * Remove a pinned message.
+     * @returns `true` if the pin was found and removed, `false` otherwise
+     */
+    unpin(jid, messageId) {
+        const existing = this.store.get(jid);
+        if (!existing)
+            return false;
+        const filtered = existing.filter(p => p.messageId !== messageId);
+        if (filtered.length === existing.length)
+            return false;
+        this.store.set(jid, filtered);
+        return true;
+    }
+    /** Get all pinned messages for a chat. */
+    getPinned(jid) {
+        return this.store.get(jid) ?? [];
+    }
+    /** Check if a message is pinned in a chat. */
+    isPinned(jid, messageId) {
+        return (this.store.get(jid) ?? []).some(p => p.messageId === messageId);
+    }
+    /** Remove all pins for a chat. */
+    clearPins(jid) {
+        this.store.delete(jid);
+    }
+    /**
+     * Evict pins whose `expiresAt` is in the past.
+     * @returns Number of expired pins removed
+     */
+    clearExpired() {
+        let cleared = 0;
+        const now = Date.now();
+        for (const [jid, pins] of this.store) {
+            const valid = pins.filter(p => !p.expiresAt || p.expiresAt.getTime() > now);
+            cleared += pins.length - valid.length;
+            this.store.set(jid, valid);
+        }
+        return cleared;
+    }
+    /** Total pin count across all chats. */
+    get totalPins() {
+        let total = 0;
+        for (const pins of this.store.values())
+            total += pins.length;
+        return total;
+    }
+}
+/** Factory — create a PinnedMessagesManager. */
+export const createPinnedMessagesManager = () => new PinnedMessagesManager();
+/**
+ * Create a read-receipt controller with optional auto-delay and per-JID exclusions.
+ *
+ * @example
+ * const readCtrl = createReadReceiptController(
+ *     (jid, participant, ids) => sock.readMessages(ids.map(id => ({ remoteJid: jid, id, participant }))),
+ *     { enabled: true, readDelay: 500, excludeJids: [spamJid] }
+ * )
+ *
+ * sock.ev.on('messages.upsert', ({ messages }) => {
+ *     for (const msg of messages) {
+ *         const { key } = msg
+ *         if (!key.fromMe)
+ *             readCtrl.markRead(key.remoteJid!, key.participant, [key.id!])
+ *     }
+ * })
+ */
+export const createReadReceiptController = (sendReadReceipt, config = {}) => {
+    let currentConfig = {
+        enabled: config.enabled ?? true,
+        excludeJids: config.excludeJids ?? [],
+        readDelay: config.readDelay ?? 0
+    };
+    return {
+        setConfig(newConfig) {
+            currentConfig = { ...currentConfig, ...newConfig };
+        },
+        getConfig() {
+            return { ...currentConfig };
+        },
+        enable() {
+            currentConfig.enabled = true;
+        },
+        disable() {
+            currentConfig.enabled = false;
+        },
+        isEnabled() {
+            return currentConfig.enabled;
+        },
+        async markRead(jid, participant, messageIds) {
+            if (!currentConfig.enabled)
+                return;
+            if (currentConfig.excludeJids.includes(jid))
+                return;
+            if (currentConfig.readDelay > 0) {
+                await new Promise(r => setTimeout(r, currentConfig.readDelay));
+            }
+            await sendReadReceipt(jid, participant, messageIds);
+        },
+        async forceMarkRead(jid, participant, messageIds) {
+            await sendReadReceipt(jid, participant, messageIds);
+        }
+    };
+};
+//# sourceMappingURL=chat-control.js.map

package/lib/Utils/generics.d.ts

@@ -49,6 +49,12 @@ export function fetchLatestWaWebVersion(options?: {}): Promise<{
     isLatest: boolean;
     error: unknown;
 }>;
+export function fetchBestWaVersion(options?: {}): Promise<{
+    version: number[];
+    isLatest: boolean;
+    source: 'wa-web' | 'baileys-fork' | 'hardcoded-fallback';
+    error?: unknown;
+}>;
 export function generateMdTagPrefix(): string;
 export function getStatusFromReceiptType(type: any): any;
 export function getErrorCodeFromStreamError(node: any): {

package/lib/Utils/generics.js

@@ -261,6 +261,30 @@ export const fetchLatestWaWebVersion = async (options = {}) => {
         };
     }
 };
+/**
+ * Vanz@Fix (bug 64): the comment on `version` in Defaults/index.js has long
+ * recommended calling `fetchLatestWaWebVersion()` first (parses WA's own
+ * sw.js — most accurate, and sidesteps the upstream `isLatest:true`-while-stale
+ * bug, WhiskeySockets#2679), falling back to `fetchLatestBaileysVersion()`,
+ * and only then the hardcoded constant — but nothing actually implemented
+ * that chain, so it was on every consumer to hand-roll it (or, more likely,
+ * skip it, which is how a bot ends up pinned to a stale `version` and starts
+ * getting rejected with 405 during pairing once WA bumps its minimum — see
+ * WhiskeySockets#2370 / #2485). This runs the documented chain for real.
+ * Never throws: worst case it resolves to the hardcoded fallback with
+ * isLatest:false, same as calling either function alone would.
+ */
+export const fetchBestWaVersion = async (options = {}) => {
+    const webResult = await fetchLatestWaWebVersion(options);
+    if (webResult.isLatest) {
+        return { ...webResult, source: 'wa-web' };
+    }
+    const baileysResult = await fetchLatestBaileysVersion(options);
+    if (baileysResult.isLatest) {
+        return { ...baileysResult, source: 'baileys-fork' };
+    }
+    return { ...baileysResult, source: 'hardcoded-fallback' };
+};
 /** unique message tag prefix for MD clients */
 export const generateMdTagPrefix = () => {
     const bytes = randomBytes(4);

package/lib/Utils/index.d.ts

@@ -33,3 +33,7 @@ export * from "./media-messages.js";
 export * from "./stickerpack.js";
 export * from "./media-set.js";
 export * from "./status.js";
+export * from "./use-cache-manager-auth-state.js";
+export * from "./baileys-event-stream.js";
+export * from "./past-participants.js";
+export * from "./chat-control.js";

package/lib/Utils/index.js

@@ -39,4 +39,8 @@ export * from './media-messages.js';
 export * from './stickerpack.js';
 export * from './media-set.js';
 export * from './status.js';
+export * from './use-cache-manager-auth-state.js';
+export * from './baileys-event-stream.js';
+export * from './past-participants.js';
+export * from './chat-control.js';
 //# sourceMappingURL=index.js.map

package/lib/Utils/media-set.js

@@ -12,7 +12,10 @@
  * buffer from `generatePP` (normalized preview). Both are kept.
  */
 import { randomBytes } from 'node:crypto';
-import { generateWAMessageContent, generateWAMessageFromContent, unixTimestampSeconds } from './messages.js';
+// Vanz@Fix: unixTimestampSeconds is not re-exported by messages.js (it only imports
+// it internally from generics.js for its own use) — pull it from generics.js directly.
+import { generateWAMessageContent, generateWAMessageFromContent } from './messages.js';
+import { unixTimestampSeconds } from './generics.js';
 import { S_WHATSAPP_NET } from '../WABinary/index.js';
 import { generatePP, generateProfilePictureFP } from './media-messages.js';
 /** Update the profile picture for yourself or a group — sends the main (scaled-to-fit) image. */

package/lib/Utils/message-search.js

@@ -1,7 +1,20 @@
 // Vanz@Add --- ported from Bail-master addons/message-search.ts (type-only
 // annotations dropped; behavior unchanged).
+// Vanz@Fix (bug 58): peel off ephemeral / view-once wrappers so search still
+// indexes text from disappearing-message chats instead of always seeing '{}'.
+const unwrapMessage = (content) => {
+    let c = content;
+    while (c && (c.ephemeralMessage || c.viewOnceMessage || c.viewOnceMessageV2 || c.viewOnceMessageV2Extension || c.documentWithCaptionMessage)) {
+        c = c.ephemeralMessage?.message ||
+            c.viewOnceMessage?.message ||
+            c.viewOnceMessageV2?.message ||
+            c.viewOnceMessageV2Extension?.message ||
+            c.documentWithCaptionMessage?.message;
+    }
+    return c;
+};
 export const extractMessageText = (message) => {
-    const c = message.message;
+    const c = unwrapMessage(message.message);
     if (!c)
         return '';
     if (c.conversation)
@@ -27,7 +40,7 @@ export const extractMessageText = (message) => {
     return '';
 };
 const getMessageType = (message) => {
-    const c = message.message;
+    const c = unwrapMessage(message.message);
     if (!c)
         return 'other';
     if (c.conversation || c.extendedTextMessage)
@@ -95,10 +108,12 @@ export const searchMessages = (messages, query, options = {}) => {
                 relevanceScore: calculateRelevance(query, text, pos)
             });
         }
-        if (options.limit && results.length >= options.limit)
-            break;
+        // Vanz@Fix (bug 59): limit used to break the scan loop *before* sorting,
+        // so it kept the first N matches in document order and could drop
+        // higher-relevance matches found later. Sort first, then slice.
     }
-    return results.sort((a, b) => b.relevanceScore - a.relevanceScore);
+    results.sort((a, b) => b.relevanceScore - a.relevanceScore);
+    return options.limit ? results.slice(0, options.limit) : results;
 };
 /** Regex-based search (e.g. for commands/patterns), unordered by relevance. */
 export const searchMessagesRegex = (messages, pattern, options = {}) => {

package/lib/Utils/messages.js

@@ -1815,10 +1815,14 @@ export const normalizeMessageContent = (content) => {
     }
     return content;
     // Lia@Changes 03-02-26 --- Add all futureProofMessage into getFutureProofMessage()
+    // Vanz@Fix 29-08-26 --- whitelist was missing 2 FutureProofMessage-typed fields added to
+    // WAProto this session: botPlatformRegistrationSuccessMessage (131) and
+    // newsletterScheduledMessage (132) — both would've silently failed to unwrap.
     function getFutureProofMessage(message) {
         return (message?.associatedChildMessage ||
             message?.botForwardedMessage ||
             message?.botInvokeMessage ||
+            message?.botPlatformRegistrationSuccessMessage ||
             message?.botTaskMessage ||
             message?.documentWithCaptionMessage ||
             message?.editedMessage ||
@@ -1833,6 +1837,7 @@ export const normalizeMessageContent = (content) => {
             message?.newsletterAdminProfileMessage ||
             message?.newsletterAdminProfileMessageV2 ||
             message?.newsletterAdminProfileStatusMessage ||
+            message?.newsletterScheduledMessage ||
             message?.pollCreationMessageV4 ||
             message?.pollCreationOptionImageMessage ||
             message?.questionMessage ||

package/lib/Utils/past-participants.d.ts

@@ -0,0 +1,14 @@
+import type { proto } from '../../WAProto/index.js';
+export interface ProcessedPastParticipant {
+    jid: string;
+    leaveTs?: number;
+    leaveReason?: 'left' | 'removed';
+}
+export interface ProcessedPastParticipants {
+    groupJid: string;
+    participants: ProcessedPastParticipant[];
+}
+/** Process proto.IPastParticipants[] from a history sync payload into a structured list per group. */
+export declare const processPastParticipants: (pastParticipantsList: proto.IPastParticipants[]) => ProcessedPastParticipants[];
+/** Check if a history sync event contains past participants data. */
+export declare const hasPastParticipants: (event: { pastParticipants?: unknown[] }) => boolean;

package/lib/Utils/past-participants.js

@@ -0,0 +1,40 @@
+// Ported from @queenanya/baileys `addons/past-participants.ts`.
+// No logic changes — @vanzxy/baileys's own WAProto already has the
+// `proto.PastParticipant.LeaveReason` enum and `HistorySync.pastParticipants`
+// field this depends on (confirmed present), so this ports as-is.
+//
+// This reads WhatsApp's own server-provided participant-leave history from
+// a history-sync payload (`proto.IPastParticipants[]`) — it's real protocol
+// data, not something reconstructed by listening to live events, so it
+// includes participants who left/were removed *before* this session ever
+// connected (which a live `group-participants.update` listener can never
+// see).
+import { proto } from '../../WAProto/index.js';
+
+/**
+ * Process proto.IPastParticipants[] from a history sync payload.
+ * Returns a structured list per group.
+ */
+export const processPastParticipants = (pastParticipantsList) => {
+    return pastParticipantsList.map((pp) => {
+        const groupJid = pp.groupJid ?? '';
+        const participants = (pp.pastParticipants ?? []).map((p) => ({
+            jid: p.userJid ?? '',
+            leaveTs: p.leaveTs ? Number(p.leaveTs) : undefined,
+            leaveReason: p.leaveReason === proto.PastParticipant.LeaveReason.LEFT
+                ? 'left'
+                : p.leaveReason === proto.PastParticipant.LeaveReason.REMOVED
+                    ? 'removed'
+                    : undefined
+        }));
+        return { groupJid, participants };
+    });
+};
+
+/**
+ * Check if a history sync event contains past participants data.
+ * (pastParticipants field replaces chunkOrder in this patch)
+ */
+export const hasPastParticipants = (event) => {
+    return Array.isArray(event.pastParticipants) && event.pastParticipants.length > 0;
+};

package/lib/Utils/process-message.js

@@ -21,8 +21,12 @@ const REAL_MSG_REQ_ME_STUB_TYPES = new Set([WAMessageStubType.GROUP_PARTICIPANT_
 // `LIDMigrationMappingSyncMessage { encodedMappingPayload: bytes }` is generated now.
 // Nothing suggests the *inner* wire layout actually changed (WA's extractor just stopped
 // walking this nested message), so we decode it by hand instead of guessing a new shape.
-// TODO: verify against live traffic on the next audit pass — if Meta did change the inner
-// layout this will start throwing and LID/PN pairs will silently stop syncing.
+// Vanz@Verify 29-08-26 --- cross-checked this hand decode against Baileys-5's WAProto.proto
+// (an independent, still-intact older schema dump that predates the removal) and it's an exact
+// field-for-field match: LIDMigrationMappingSyncPayload{ repeated pnToLidMappings=1,
+// optional chatDbMigrationTimestamp=2(uint64) }, LIDMigrationMapping{ pn=1, assignedLid=2,
+// latestLid=3, all uint64 }. Not literal live-traffic verification, but a real independent
+// source confirms the guess rather than just "seems plausible" — safe to leave as-is.
 function decodeLidMigrationMappingSyncPayload(buf) {
     const r = Reader.create(buf);
     const out = { pnToLidMappings: [], chatDbMigrationTimestamp: undefined };

package/lib/Utils/stickerpack.js

@@ -91,7 +91,9 @@ const ITSL_CONCURRENCY_LIMIT = 15;
  * cover→trayIcon-in-ZIP, and a separate 252×252 JPEG thumbnail upload.
  */
 export const prepareStickerPackMessageItsliaaa = async (message, options) => {
-    const { cover, stickers = [], name = '📦 Sticker Pack', publisher = 'GitHub: itsliaaa', description = '🏷️ itsliaaa/baileys' } = message;
+    // Vanz@Fix (bug 62): packId was never destructured here, so a caller-supplied
+    // pack ID was silently dropped and a fresh one always generated below.
+    const { cover, stickers = [], name = '📦 Sticker Pack', publisher = 'GitHub: itsliaaa', description = '🏷️ itsliaaa/baileys', packId } = message;
     if (stickers.length > 60) {
         throw new Boom('Sticker pack exceeds the maximum limit of 60 stickers', { statusCode: 400 });
     }
@@ -124,11 +126,10 @@ export const prepareStickerPackMessageItsliaaa = async (message, options) => {
     const lib = await getImageProcessingLibrary();
     const hasSharp = 'sharp' in lib && !!lib.sharp?.default;
     const hasImage = 'image' in lib && !!lib.image?.Transformer;
-    const hasJimp = 'jimp' in lib && !!lib.jimp?.Jimp;
     if (!hasSharp && !hasImage) {
         throw new Boom('No image processing library (sharp or @napi-rs/image) available for converting sticker to WebP.');
     }
-    const stickerPackIdValue = generateMessageIDV2();
+    const stickerPackIdValue = packId ?? generateMessageIDV2();
     const stickerData = {};
     const stickerMetadata = new Array(stickers.length);
     for (let i = 0; i < stickers.length; i += ITSL_CONCURRENCY_LIMIT) {
@@ -226,15 +227,13 @@ export const prepareStickerPackMessageItsliaaa = async (message, options) => {
         if (hasSharp) {
             thumbnailBuffer = await lib.sharp.default(coverBuffer).resize(252, 252).jpeg().toBuffer();
         }
-        else if (hasImage) {
-            thumbnailBuffer = await new lib.image.Transformer(coverBuffer).resize(252, 252).jpeg();
-        }
-        else if (hasJimp) {
-            const jimpImage = await lib.jimp.Jimp.read(coverBuffer);
-            thumbnailBuffer = await jimpImage.resize({ w: 252, h: 252 }).getBuffer('image/jpeg');
-        }
         else {
-            throw new Error('No image processing library available for thumbnail generation');
+            // hasImage is guaranteed here since hasSharp||hasImage is enforced above.
+            // Vanz@Fix (bug 63): removed a jimp fallback branch that could never be
+            // reached (the earlier guard already requires sharp or image), and which
+            // main sticker/cover conversion above doesn't support anyway — it was
+            // dead code presenting a false sense of a jimp-only code path.
+            thumbnailBuffer = await new lib.image.Transformer(coverBuffer).resize(252, 252).jpeg();
         }
         if (!thumbnailBuffer || thumbnailBuffer.length === 0) {
             throw new Error('Failed to generate thumbnail buffer');

package/lib/Utils/use-cache-manager-auth-state.d.ts

@@ -0,0 +1,13 @@
+import type { AuthenticationState } from '../Types/index.js';
+/** Minimal interface compatible with any cache-manager v5 store (Redis, Memcached, keyv, @cacheable/node-cache, etc). */
+export type CacheManagerStore = {
+    set(key: string, value: string, ttl?: number): Promise<void>;
+    get(key: string): Promise<string | undefined | null>;
+    del(key: string): Promise<void>;
+    keys(pattern?: string): Promise<string[]>;
+};
+export declare const useCacheManagerAuthState: (store: CacheManagerStore, sessionKey: string) => Promise<{
+    state: AuthenticationState;
+    saveCreds: () => Promise<void>;
+    clearState: () => Promise<void>;
+}>;

package/lib/Utils/use-cache-manager-auth-state.js

@@ -0,0 +1,82 @@
+// Ported from @queenanya/baileys `addons/use-cache-manager-auth-state.ts`
+// (that fork credits it to `@innovatorssoft/baileys` make-cache-manager-store.js).
+// Adjustments for @vanzxy/baileys: import paths rewired to this fork's
+// Utils layout (auth-utils.js / generics.js), otherwise logic-for-logic
+// identical to the original — including the 2-year TTL on `creds` and the
+// `sessionKey*` wildcard sweep in `clearState()`.
+//
+// Store interface required (matches any cache-manager v5-compatible store,
+// e.g. Redis/Memcached/keyv, or this fork's own @cacheable/node-cache dep):
+//   store.get(key)              -> string | undefined | null
+//   store.set(key, value, ttl?) -> void
+//   store.del(key)              -> void
+//   store.keys(pattern?)        -> string[]   (used by clearState() for the wildcard sweep)
+import { proto } from '../../WAProto/index.js';
+import { initAuthCreds } from './auth-utils.js';
+import { BufferJSON } from './generics.js';
+
+export const useCacheManagerAuthState = async (store, sessionKey) => {
+    const defaultKey = (file) => `${sessionKey}:${file}`;
+    const writeData = async (file, data) => {
+        const ttl = file === 'creds' ? 63115200 : undefined; // 2 years for creds
+        await store.set(defaultKey(file), JSON.stringify(data, BufferJSON.replacer), ttl);
+    };
+    const readData = async (file) => {
+        try {
+            const data = await store.get(defaultKey(file));
+            return data !== null && data !== undefined ? JSON.parse(data, BufferJSON.reviver) : null;
+        }
+        catch {
+            return null;
+        }
+    };
+    const removeData = async (file) => {
+        try {
+            await store.del(defaultKey(file));
+        }
+        catch {
+            console.error(`[useCacheManagerAuthState] Error removing ${file} from session ${sessionKey}`);
+        }
+    };
+    const clearState = async () => {
+        try {
+            const keys = await store.keys(`${sessionKey}*`);
+            await Promise.all(keys.map((key) => store.del(key)));
+        }
+        catch {
+            // best-effort — not every store backend supports pattern listing
+        }
+    };
+    const creds = (await readData('creds')) || initAuthCreds();
+    return {
+        clearState,
+        state: {
+            creds,
+            keys: {
+                get: async (type, ids) => {
+                    const data = {};
+                    await Promise.all(ids.map(async (id) => {
+                        let value = await readData(`${type}-${id}`);
+                        if (type === 'app-state-sync-key' && value) {
+                            value = proto.Message.AppStateSyncKeyData.fromObject(value);
+                        }
+                        data[id] = value;
+                    }));
+                    return data;
+                },
+                set: async (data) => {
+                    const tasks = [];
+                    for (const category in data) {
+                        for (const id in data[category]) {
+                            const value = data[category][id];
+                            const key = `${category}-${id}`;
+                            tasks.push(value ? writeData(key, value) : removeData(key));
+                        }
+                    }
+                    await Promise.all(tasks);
+                }
+            }
+        },
+        saveCreds: () => writeData('creds', creds)
+    };
+};

package/lib/Utils/validate-connection.js

@@ -1,7 +1,7 @@
 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 } from '../Defaults/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';
@@ -94,11 +94,7 @@ export const generateRegistrationNode = ({ registrationId, signedPreKey, signedI
             onDemandReady: undefined,
             supportGuestChat: undefined
         },
-        version: {
-            primary: 10,
-            secondary: 15,
-            tertiary: 7
-        }
+        version: COMPANION_DEVICE_VERSION
     };
     const companionProto = proto.DeviceProps.encode(companion).finish();
     const registerPayload = {

package/lib/Utils/vcard.js

@@ -1,6 +1,17 @@
 // Vanz@Add --- ported from Bail-master addons/vcard.ts (type-only
 // annotations dropped; behavior unchanged).
 export const escapeVCard = (s) => s.replace(/\\/g, '\\\\').replace(/;/g, '\\;').replace(/,/g, '\\,').replace(/\n/g, '\\n');
+// Vanz@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) => {
@@ -49,11 +60,11 @@ export const parseVCard = (vcard) => {
             continue;
         const value = vp.join(':');
         if (key.startsWith('FN'))
-            contact.fullName = value.replace(/\\([;,n\\])/g, '$1');
+            contact.fullName = unescapeVCard(value);
         else if (key.startsWith('ORG'))
-            contact.organization = value.replace(/\\([;,n\\])/g, '$1');
+            contact.organization = unescapeVCard(value);
         else if (key.startsWith('TITLE'))
-            contact.title = value.replace(/\\([;,n\\])/g, '$1');
+            contact.title = unescapeVCard(value);
         else if (key.startsWith('TEL')) {
             contact.phones = contact.phones || [];
             const tm = key.match(/type=(\w+)/i);
@@ -67,7 +78,7 @@ export const parseVCard = (vcard) => {
         else if (key.startsWith('BDAY'))
             contact.birthday = value;
         else if (key.startsWith('NOTE'))
-            contact.note = value.replace(/\\n/g, '\n');
+            contact.note = unescapeVCard(value);
     }
     return contact;
 };