@violetix/baileys 0.5.5 → 0.6.0

package/lib/Utils/a2ui.js

@@ -1,168 +0,0 @@
-// A2UI (Agent-to-UI) widget builder. Declarative components — Text, Image, Video, Button,
-// Card, Column, Row, Divider, CheckBox, TextField, ChoicePicker, plus the `listCard` shortcut
-// — compiled into the JSON payload WhatsApp carries in `interactiveMessage.bloksWidget`.
-//
-// Ported from @rennzsync/baileys (MIT).
-//
-// Every builder method registers a component and returns its id; ids are what the container
-// methods take, so a tree is written bottom-up:
-//
-//     const ui = new A2UI()
-//     const title = ui.text('Hello', { variant: 'h1' })
-//     const button = ui.button(ui.text('Press me'), { action: { name: 'noop' } })
-//     ui.root([ui.card(ui.column([title, button]))])
-//     await sock.sendMessage(jid, { a2ui: ui, text: 'Widget' })
-//
-// This is an internal WhatsApp format: a send can succeed while the recipient's client renders
-// nothing. Verify against your target client build before relying on it.
-import { randomUUID } from 'crypto';
-const DEFAULT_CATALOG_ID = 'https://a2ui.org/specification/v0_9/catalogs/basic/catalog.json';
-export class A2UI {
-    constructor({ catalogId = DEFAULT_CATALOG_ID, version = 'v0.9' } = {}) {
-        this._version = version;
-        this._catalogId = catalogId;
-        this._components = new Map();
-        this._counter = 0;
-        this._rootChildren = [];
-        this._listCardPayload = undefined;
-    }
-    #nextId(prefix) {
-        return `${prefix}_${(this._counter++).toString(36)}`;
-    }
-    #reg(id, component, extra = {}) {
-        id ??= this.#nextId(component.toLowerCase());
-        if (this._components.has(id)) {
-            throw new Error(`Component id "${id}" already used`);
-        }
-        this._components.set(id, { id, component, ...extra });
-        return id;
-    }
-    text(text, { id, variant = 'body' } = {}) {
-        return this.#reg(id, 'Text', { text, variant });
-    }
-    image(url, { id, variant, fit = 'cover' } = {}) {
-        return this.#reg(id, 'Image', { url, ...(variant ? { variant } : {}), fit });
-    }
-    video(url, { id } = {}) {
-        return this.#reg(id, 'Video', { url });
-    }
-    checkbox(label, { id, value = false } = {}) {
-        return this.#reg(id, 'CheckBox', { label, value });
-    }
-    textField(label, { id, variant = 'text' } = {}) {
-        return this.#reg(id, 'TextField', { label, variant });
-    }
-    button(childId, { id, variant = 'primary', action } = {}) {
-        if (!childId) {
-            throw new TypeError('button(childId) requires the id of a child component (e.g. from .text())');
-        }
-        return this.#reg(id, 'Button', { child: childId, variant, ...(action ? { action } : {}) });
-    }
-    card(childId, { id } = {}) {
-        if (!childId) {
-            throw new TypeError('card(childId) requires the id of a child component');
-        }
-        return this.#reg(id, 'Card', { child: childId });
-    }
-    column(children = [], { id, justify, align } = {}) {
-        if (!children.length) {
-            throw new TypeError('column(children) requires at least one child id');
-        }
-        return this.#reg(id, 'Column', { children, ...(justify ? { justify } : {}), ...(align ? { align } : {}) });
-    }
-    row(children = [], { id } = {}) {
-        if (!children.length) {
-            throw new TypeError('row(children) requires at least one child id');
-        }
-        return this.#reg(id, 'Row', { children });
-    }
-    divider({ id } = {}) {
-        return this.#reg(id, 'Divider', {});
-    }
-    choicePicker(label, options, { id, variant = 'mutuallyExclusive', value, displayStyle = 'checkbox', filterable = false } = {}) {
-        if (!Array.isArray(options) || !options.length) {
-            throw new TypeError('choicePicker(label, options) requires a non-empty options array of {label, value}');
-        }
-        return this.#reg(id, 'ChoicePicker', {
-            label,
-            variant,
-            ...(value !== undefined ? { value } : {}),
-            options,
-            displayStyle,
-            filterable
-        });
-    }
-    /** Names the top-level components. Required before `build()` unless `listCard` was used. */
-    root(children) {
-        if (!Array.isArray(children) || !children.length) {
-            throw new TypeError('root(children) requires a non-empty array of top-level component ids');
-        }
-        this._rootChildren = children;
-        return this;
-    }
-    /**
-     * Shortcut for the product-list widget, which uses its own payload shape rather than the
-     * component catalog. It replaces whatever the component methods built — `build()` returns
-     * this payload and ignores `root()`.
-     */
-    listCard({ title, items, fallbackText, uuid = randomUUID() } = {}) {
-        if (!title) {
-            throw new TypeError('listCard requires a title');
-        }
-        if (!Array.isArray(items) || !items.length) {
-            throw new TypeError('listCard requires a non-empty items array');
-        }
-        this._listCardPayload = {
-            uuid,
-            data: JSON.stringify({
-                type: 'list_card',
-                title,
-                fallback_text: fallbackText ?? '',
-                items: items.map(item => ({
-                    asset_id: item.assetId ?? randomUUID().replace(/-/g, '').slice(0, 17),
-                    asset_type: item.assetType ?? 'PRODUCT_ITEM',
-                    title: item.title,
-                    trailing_label: item.price ?? item.trailingLabel ?? '',
-                    trailing_emphasis: item.emphasis ?? 'strong'
-                }))
-            }),
-            type: 'im_a2ui',
-            fallback: fallbackText ?? ''
-        };
-        return this;
-    }
-    /** Compiles the tree into the `bloksWidget` payload. Called for you by `sendMessage`. */
-    build({ uuid = randomUUID(), surfaceId, type = 'im_a2ui', wrapped = true } = {}) {
-        if (this._listCardPayload) {
-            return this._listCardPayload;
-        }
-        if (!this._rootChildren.length) {
-            throw new Error('Call root([...ids]) before build()');
-        }
-        const root = { id: 'root', component: 'Column', children: this._rootChildren };
-        const components = [root, ...this._components.values()];
-        const data = wrapped
-            ? {
-                version: this._version,
-                createSurface: {
-                    surfaceId: surfaceId ?? `starcore-widget=${uuid}`,
-                    catalogId: this._catalogId,
-                    components
-                }
-            }
-            : { components };
-        return {
-            uuid,
-            data: JSON.stringify(data),
-            type
-        };
-    }
-}
-/** Accepts an `A2UI` instance or an already-built payload, and returns the payload. */
-export const buildA2UIWidget = (a2ui, options = {}) => {
-    const widget = typeof a2ui?.build === 'function' ? a2ui.build(options) : a2ui;
-    if (!widget || typeof widget.data !== 'string') {
-        throw new TypeError('a2ui must be an A2UI instance or a built widget payload with a `data` string');
-    }
-    return widget;
-};

package/lib/Utils/anchor-guard.d.ts

@@ -1,71 +0,0 @@
-export type AnchorGuardLimits = {
-    maxText: number;
-    maxCaption: number;
-    maxMentions: number;
-    maxGroupMentions: number;
-    maxButtons: number;
-    maxSections: number;
-    maxRows: number;
-    maxCards: number;
-    maxDepth: number;
-    maxNodes: number;
-    maxBytes: number;
-    maxParamsJson: number;
-    maxInvisibleRun: number;
-    maxCombiningRun: number;
-    maxNewlines: number;
-};
-export declare const ANCHORGUARD_DEFAULTS: AnchorGuardLimits;
-export type AnchorGuardDetectOptions = Partial<AnchorGuardLimits> & {
-    /** Pre-computed encoded size, checked against `maxBytes` without re-encoding. */
-    byteLength?: number;
-    /** Pass the `proto` namespace to also measure the encoded size. Costs an encode per check. */
-    proto?: any;
-};
-export type AnchorGuardDetectResult = {
-    flagged: boolean;
-    reasons: string[];
-};
-export declare const detectBug: (message: any, options?: AnchorGuardDetectOptions) => AnchorGuardDetectResult;
-export type AnchorGuardDetection = {
-    direction: 'incoming' | 'outgoing' | 'group-add';
-    jid?: string;
-    sender?: string;
-    message?: any;
-    content?: any;
-    reasons: string[];
-    burst?: boolean;
-};
-export type AnchorGuardOptions = {
-    /** Delete a flagged inbound message. Default `true`. */
-    autoDelete?: boolean;
-    /** `'auto'` revokes own messages and deletes others locally. Default `'auto'`. */
-    deleteMode?: 'auto' | 'everyone' | 'me';
-    /** Guard `messages.upsert`. Default `true`. */
-    guardIncoming?: boolean;
-    /** Wrap `sock.sendMessage` and reject crash payloads. Default `false`. */
-    guardOutgoing?: boolean;
-    /** Block the sender of a flagged message. Default `false`. */
-    blockOnBug?: boolean;
-    /** Only guard own chats. Default `false`. */
-    selfOnly?: boolean;
-    thresholds?: Partial<AnchorGuardLimits>;
-    onDetect?: (detection: AnchorGuardDetection) => void | Promise<void>;
-    proto?: any;
-    /** Messages from one sender inside `burstWindowMs` before it counts as a burst. `0` disables. */
-    burstThreshold?: number;
-    burstWindowMs?: number;
-    /** Remove the sender from the group on burst. Needs admin. Default `false`. */
-    kickOnBurst?: boolean;
-    /** Flag/kick when a burst-flagged inviter adds this account to a group. Default `false`. */
-    guardGroupAdds?: boolean;
-    /** Guard Meta AI's numbers instead of exempting them. Default `false`. */
-    metaAiNumbers?: boolean;
-    ownJid?: string;
-    logger?: any;
-};
-export declare const createAnchorGuard: (sock: any, options?: AnchorGuardOptions) => {
-    detect: (message: any) => AnchorGuardDetectResult;
-    stop: () => void;
-};
-export declare const createAntiBugGuard: typeof createAnchorGuard;

package/lib/Utils/anchor-guard.js

@@ -1,404 +0,0 @@
-// Anti force-close guard: detects payloads that crash WhatsApp clients — combining/invisible
-// char floods, mention bombs, oversized native-flow/list/carousel payloads, broken
-// buttonParamsJson, over-deep or circular message structures — then deletes them and optionally
-// blocks the sender.
-//
-// Ported from @rennzsync/baileys' anchor-guard, itself a port of
-// @rexxhayanasi/elaina-anchorguard (MIT).
-import { META_AI_JID } from '../WABinary/index.js';
-export const ANCHORGUARD_DEFAULTS = {
-    maxText: 65536,
-    maxCaption: 32768,
-    maxMentions: 1500,
-    maxGroupMentions: 200,
-    maxButtons: 100,
-    maxSections: 100,
-    maxRows: 300,
-    maxCards: 60,
-    maxDepth: 12,
-    maxNodes: 20000,
-    maxBytes: 3 * 1024 * 1024,
-    maxParamsJson: 262144,
-    maxInvisibleRun: 500,
-    maxCombiningRun: 100,
-    maxNewlines: 20000
-};
-// Escaped on purpose: literal invisible/combining characters make the source unreadable
-// and easy to corrupt on the next edit.
-const INVISIBLE = /[\u200b-\u200f\u202a-\u202e\u2060-\u2064\u206a-\u206f\ufeff\ufff9-\ufffb]/;
-const COMBINING = /[\u0300-\u036f\u0483-\u0489\u0591-\u05bd\u0610-\u061a\u064b-\u065f\u0670\u06d6-\u06dc\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\uaa70\uaaf6\uabed\ufe20-\ufe2f]/;
-/** Longest consecutive run of characters matching `matcher`. */
-const longestRun = (text, matcher) => {
-    let run = 0;
-    let best = 0;
-    for (const ch of text) {
-        if (matcher.test(ch)) {
-            run += 1;
-            if (run > best) {
-                best = run;
-            }
-        }
-        else {
-            run = 0;
-        }
-    }
-    return best;
-};
-const countChar = (text, ch) => {
-    let n = 0;
-    for (let i = 0; i < text.length; i += 1) {
-        if (text[i] === ch) {
-            n += 1;
-        }
-    }
-    return n;
-};
-const WRAPPERS = [
-    'ephemeralMessage',
-    'viewOnceMessage',
-    'viewOnceMessageV2',
-    'viewOnceMessageV2Extension',
-    'documentWithCaptionMessage',
-    'editedMessage',
-    'deviceSentMessage',
-    'botInvokeMessage'
-];
-const unwrapContent = (message) => {
-    let current = message;
-    let depth = 0;
-    while (current && typeof current === 'object' && depth < 64) {
-        const wrapper = WRAPPERS.find(w => current[w]?.message);
-        if (!wrapper) {
-            break;
-        }
-        current = current[wrapper].message;
-        depth += 1;
-    }
-    return { content: current, wrapDepth: depth };
-};
-/**
- * Inspects a message content object and reports why it looks like a crash payload.
- * Pure — no I/O, no mutation of the input.
- */
-export const detectBug = (message, options = {}) => {
-    const limits = { ...ANCHORGUARD_DEFAULTS, ...options };
-    const reasons = [];
-    if (!message || typeof message !== 'object') {
-        return { flagged: false, reasons };
-    }
-    const { content, wrapDepth } = unwrapContent(message);
-    if (wrapDepth >= 6) {
-        reasons.push(`wrapper nesting ${wrapDepth}`);
-    }
-    let nodes = 0;
-    const seen = new WeakSet();
-    // One traversal. The mention checks used to be a second full walk of the same tree, which
-    // doubled the cost of the guard on the path it is meant to protect: every inbound message.
-    const walk = (value, depth) => {
-        if (reasons.length > 40) {
-            return;
-        }
-        nodes += 1;
-        if (nodes > limits.maxNodes) {
-            reasons.push(`node count > ${limits.maxNodes}`);
-            return;
-        }
-        if (depth > limits.maxDepth) {
-            reasons.push(`structure depth > ${limits.maxDepth}`);
-            return;
-        }
-        if (typeof value === 'string') {
-            if (value.length > limits.maxText) {
-                reasons.push(`string length ${value.length} > ${limits.maxText}`);
-            }
-            if (countChar(value, '\n') > limits.maxNewlines) {
-                reasons.push('excessive newlines');
-            }
-            const invisibleRun = longestRun(value, INVISIBLE);
-            if (invisibleRun > limits.maxInvisibleRun) {
-                reasons.push(`invisible-char run ${invisibleRun}`);
-            }
-            const combiningRun = longestRun(value, COMBINING);
-            if (combiningRun > limits.maxCombiningRun) {
-                reasons.push(`combining-char run ${combiningRun}`);
-            }
-            return;
-        }
-        if (Array.isArray(value)) {
-            for (const item of value) {
-                walk(item, depth + 1);
-            }
-            return;
-        }
-        if (value && typeof value === 'object') {
-            if (seen.has(value)) {
-                reasons.push('circular structure');
-                return;
-            }
-            seen.add(value);
-            for (const key of Object.keys(value)) {
-                const child = value[key];
-                if (key === 'contextInfo' && child && typeof child === 'object') {
-                    if (Array.isArray(child.mentionedJid) && child.mentionedJid.length > limits.maxMentions) {
-                        reasons.push(`mentionedJid ${child.mentionedJid.length} > ${limits.maxMentions}`);
-                    }
-                    if (Array.isArray(child.groupMentions) && child.groupMentions.length > limits.maxGroupMentions) {
-                        reasons.push(`groupMentions ${child.groupMentions.length} > ${limits.maxGroupMentions}`);
-                    }
-                }
-                walk(child, depth + 1);
-            }
-        }
-    };
-    walk(content, 0);
-    const inspectInteractive = (node) => {
-        if (!node || typeof node !== 'object') {
-            return;
-        }
-        const nativeFlow = node.nativeFlowMessage || node.interactiveMessage?.nativeFlowMessage;
-        if (nativeFlow?.buttons) {
-            if (nativeFlow.buttons.length > limits.maxButtons) {
-                reasons.push(`nativeFlow buttons ${nativeFlow.buttons.length} > ${limits.maxButtons}`);
-            }
-            for (const button of nativeFlow.buttons) {
-                const params = button?.buttonParamsJson;
-                if (typeof params !== 'string') {
-                    continue;
-                }
-                if (params.length > limits.maxParamsJson) {
-                    reasons.push(`buttonParamsJson length ${params.length}`);
-                }
-                else if (params.length) {
-                    try {
-                        JSON.parse(params);
-                    }
-                    catch {
-                        reasons.push('buttonParamsJson invalid');
-                    }
-                }
-            }
-        }
-        const list = node.listMessage || node.interactiveMessage?.carouselMessage;
-        if (list?.sections && list.sections.length > limits.maxSections) {
-            reasons.push(`list sections ${list.sections.length} > ${limits.maxSections}`);
-        }
-        if (Array.isArray(list?.sections)) {
-            let rows = 0;
-            for (const section of list.sections) {
-                rows += Array.isArray(section?.rows) ? section.rows.length : 0;
-            }
-            if (rows > limits.maxRows) {
-                reasons.push(`list rows ${rows} > ${limits.maxRows}`);
-            }
-        }
-        const cards = node.interactiveMessage?.carouselMessage?.cards;
-        if (Array.isArray(cards) && cards.length > limits.maxCards) {
-            reasons.push(`carousel cards ${cards.length} > ${limits.maxCards}`);
-        }
-    };
-    inspectInteractive(content);
-    if (typeof options.byteLength === 'number' && options.byteLength > limits.maxBytes) {
-        reasons.push(`encoded size ${options.byteLength} > ${limits.maxBytes}`);
-    }
-    if (options.proto?.Message) {
-        try {
-            const encoded = options.proto.Message.encode(options.proto.Message.fromObject(message)).finish();
-            if (encoded.length > limits.maxBytes) {
-                reasons.push(`encoded size ${encoded.length} > ${limits.maxBytes}`);
-            }
-        }
-        catch (error) {
-            reasons.push(`proto encode failed: ${error.message}`);
-        }
-    }
-    return { flagged: reasons.length > 0, reasons };
-};
-const META_AI_USER = META_AI_JID.split('@')[0];
-const isMetaAiJid = (jid) => typeof jid === 'string' && jid.startsWith(META_AI_USER);
-/** Bounded so a bot in busy groups cannot grow the burst log without limit. */
-const MAX_BURST_SENDERS = 5000;
-/**
- * Attaches the guard to a socket: flags inbound crash payloads, optionally blocks the sender,
- * and rejects outgoing messages that would crash the recipient.
- */
-export const createAnchorGuard = (sock, options = {}) => {
-    const config = {
-        autoDelete: true,
-        deleteMode: 'auto',
-        guardIncoming: true,
-        // Off by default: this one replaces `sock.sendMessage` with a wrapper, which a host that
-        // also wraps `sendMessage` needs to know about. Opt in explicitly.
-        guardOutgoing: false,
-        blockOnBug: false,
-        selfOnly: false,
-        thresholds: {},
-        onDetect: null,
-        proto: null,
-        /** messages from one sender within burstWindowMs before it counts as a burst; 0 = off */
-        burstThreshold: 0,
-        burstWindowMs: 4000,
-        /** remove the sender from the group on burst (needs admin) */
-        kickOnBurst: false,
-        /** flag/kick when a burst-flagged inviter adds this account to a group */
-        guardGroupAdds: false,
-        /** guard Meta AI's own numbers instead of exempting them */
-        metaAiNumbers: false,
-        logger: sock?.logger,
-        ...options
-    };
-    const ownJid = config.ownJid || sock?.user?.id;
-    const detectOptions = { ...config.thresholds, proto: config.proto };
-    const burstLog = new Map();
-    const removeMessage = async (jid, key) => {
-        if (!config.autoDelete) {
-            return;
-        }
-        const revoke = config.deleteMode === 'everyone' || (config.deleteMode === 'auto' && key?.fromMe);
-        try {
-            if (revoke) {
-                await sock.sendMessage(jid, { delete: key });
-            }
-            else if (typeof sock.chatModify === 'function') {
-                await sock.chatModify({ deleteForMe: { key, timestamp: Date.now(), deleteMedia: false } }, jid);
-            }
-        }
-        catch (error) {
-            config.logger?.warn?.({ error: error.message }, 'anchorguard delete failed');
-        }
-    };
-    const maybeBlock = async (jid, key) => {
-        if (!config.blockOnBug || key?.fromMe || typeof sock.updateBlockStatus !== 'function') {
-            return;
-        }
-        try {
-            await sock.updateBlockStatus(jid, 'block');
-        }
-        catch (error) {
-            config.logger?.warn?.({ error: error.message }, 'anchorguard block failed');
-        }
-    };
-    const maybeKickBurst = async (groupJid, sender) => {
-        if (!config.kickOnBurst || !groupJid?.endsWith('@g.us') || typeof sock.groupParticipantsUpdate !== 'function') {
-            return;
-        }
-        try {
-            await sock.groupParticipantsUpdate(groupJid, [sender], 'remove');
-        }
-        catch (error) {
-            config.logger?.warn?.({ error: error.message }, 'anchorguard kick-on-burst failed');
-        }
-    };
-    const checkBurst = (sender) => {
-        if (!config.burstThreshold || !sender) {
-            return false;
-        }
-        const now = Date.now();
-        const stamps = (burstLog.get(sender) || []).filter(t => now - t < config.burstWindowMs);
-        stamps.push(now);
-        burstLog.set(sender, stamps);
-        // Senders whose window has fully expired are dropped, so the map tracks active senders
-        // only. Without this it keeps one entry per sender seen for the lifetime of the socket.
-        if (burstLog.size > MAX_BURST_SENDERS) {
-            for (const [key, times] of burstLog) {
-                if (!times.some(t => now - t < config.burstWindowMs)) {
-                    burstLog.delete(key);
-                }
-            }
-        }
-        return stamps.length > config.burstThreshold;
-    };
-    const handleUpsert = async ({ messages }) => {
-        if (!config.guardIncoming || !Array.isArray(messages)) {
-            return;
-        }
-        for (const msg of messages) {
-            const content = msg?.message;
-            if (!content) {
-                continue;
-            }
-            const jid = msg.key?.remoteJid;
-            const sender = msg.key?.participant || jid;
-            if (config.selfOnly && jid !== ownJid && !msg.key?.fromMe) {
-                continue;
-            }
-            if (!config.metaAiNumbers && isMetaAiJid(sender)) {
-                continue;
-            }
-            const result = detectBug(content, detectOptions);
-            const burst = checkBurst(sender);
-            if (!result.flagged && !burst) {
-                continue;
-            }
-            const reasons = burst
-                ? [...result.reasons, `burst > ${config.burstThreshold}/${config.burstWindowMs}ms`]
-                : result.reasons;
-            config.logger?.warn?.({ jid, sender, reasons }, 'anchorguard flagged incoming message');
-            await config.onDetect?.({ direction: 'incoming', message: msg, jid, sender, reasons, burst });
-            if (result.flagged) {
-                await removeMessage(jid, msg.key);
-            }
-            await maybeBlock(sender, msg.key);
-            if (burst) {
-                await maybeKickBurst(jid, sender);
-            }
-        }
-    };
-    const handleGroupParticipantsUpdate = async (update) => {
-        if (!config.guardGroupAdds || update?.action !== 'add') {
-            return;
-        }
-        const inviter = update?.author;
-        if (!inviter || (!config.metaAiNumbers && isMetaAiJid(inviter))) {
-            return;
-        }
-        if (checkBurst(inviter)) {
-            config.logger?.warn?.({ group: update.id, inviter }, 'anchorguard flagged burst group-add');
-            await config.onDetect?.({ direction: 'group-add', jid: update.id, sender: inviter, reasons: ['burst group-add'], burst: true });
-            await maybeKickBurst(update.id, inviter);
-        }
-    };
-    if (config.guardIncoming && sock?.ev?.on) {
-        sock.ev.on('messages.upsert', handleUpsert);
-    }
-    if (config.guardGroupAdds && sock?.ev?.on) {
-        sock.ev.on('group-participants.update', handleGroupParticipantsUpdate);
-    }
-    let originalSend = null;
-    let patchedSend = null;
-    if (config.guardOutgoing && typeof sock?.sendMessage === 'function') {
-        // Keep the unbound reference so `stop()` restores the exact function that was there.
-        // Restoring a bound copy instead stacks a `bind` layer per guard/stop cycle and makes
-        // the socket's own method unrecognisable to a host comparing identities.
-        originalSend = sock.sendMessage;
-        const callOriginal = originalSend.bind(sock);
-        patchedSend = async (jid, content, sendOptions) => {
-            const probe = detectBug(content, detectOptions);
-            if (probe.flagged) {
-                config.logger?.warn?.({ jid, reasons: probe.reasons }, 'anchorguard blocked outgoing message');
-                await config.onDetect?.({ direction: 'outgoing', jid, content, reasons: probe.reasons });
-                throw new Error(`anchorguard blocked outgoing message: ${probe.reasons.join('; ')}`);
-            }
-            return callOriginal(jid, content, sendOptions);
-        };
-        sock.sendMessage = patchedSend;
-    }
-    return {
-        detect: message => detectBug(message, detectOptions),
-        stop: () => {
-            if (config.guardIncoming && sock?.ev?.off) {
-                sock.ev.off('messages.upsert', handleUpsert);
-            }
-            if (config.guardGroupAdds && sock?.ev?.off) {
-                sock.ev.off('group-participants.update', handleGroupParticipantsUpdate);
-            }
-            // Only unwind our own wrapper. Restoring unconditionally would throw away a wrapper
-            // the host installed after this guard did.
-            if (patchedSend && sock.sendMessage === patchedSend) {
-                sock.sendMessage = originalSend;
-            }
-            burstLog.clear();
-        }
-    };
-};
-// kept for drop-in parity with @rexxhayanasi/elaina-anchorguard's export name
-export const createAntiBugGuard = createAnchorGuard;

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

@@ -1,44 +0,0 @@
-import { EventEmitter } from "events";
-import { Agent } from "https";
-export type ConnectionManagerSession = {
-    id: string;
-    [key: string]: any;
-};
-export type ConnectionManagerOptions = {
-    /** Build one socket for a session. Called again for every reconnect. */
-    create: (session: ConnectionManagerSession) => Promise<any> | any;
-    sessions?: ConnectionManagerSession[];
-    maxConcurrent?: number;
-    reconnect?: boolean;
-    baseDelayMs?: number;
-    maxDelayMs?: number;
-    maxAttempts?: number;
-    staggerMs?: number;
-    logger?: any;
-};
-export type ConnectionManagerStats = {
-    total: number;
-    idle: number;
-    connecting: number;
-    open: number;
-    reconnecting: number;
-    closed: number;
-    failed: number;
-    activeConnects: number;
-    queuedConnects: number;
-};
-export declare class ConnectionManager extends EventEmitter {
-    #private;
-    constructor(options: ConnectionManagerOptions);
-    start(): ConnectionManagerStats;
-    get(id: string): any | null;
-    stop(id: string): boolean;
-    close(): Promise<void>;
-    stats(): ConnectionManagerStats;
-}
-export declare const makeConnectionManager: (options: ConnectionManagerOptions) => ConnectionManager;
-export declare const makeWssAgent: (options?: {
-    maxSockets?: number;
-    keepAlive?: boolean;
-    keepAliveMsecs?: number;
-}) => Agent;