@japofc/baileys 2.1.0

package/lib/Framework/Context.js

@@ -0,0 +1,89 @@
+import { MediaManager } from './MediaManager.js';
+
+// JAP@Framework --- message context helper: wraps a WAMessage with reply,
+// react, session, and media helpers so command handlers don't have to touch
+// the raw socket API.
+//
+// Kept from upstream's fix pass:
+//  - text getter also reads imageMessage/videoMessage/documentMessage
+//    captions, so a command sent as an image caption still matches
+//  - reply()/react()/replySticker()/replyVoiceNote() throw when remoteJid is
+//    missing instead of silently no-op'ing, so a handler can't believe a
+//    reply went out when it never did
+export class Context {
+    constructor(bot, message) {
+        this.bot = bot;
+        this.message = message;
+    }
+
+    get remoteJid() {
+        return this.message.key.remoteJid;
+    }
+
+    /** Text content, including image/video/document captions so caption-only commands still match. */
+    get text() {
+        return (this.message.message?.conversation ||
+            this.message.message?.extendedTextMessage?.text ||
+            this.message.message?.imageMessage?.caption ||
+            this.message.message?.videoMessage?.caption ||
+            this.message.message?.documentMessage?.caption ||
+            undefined);
+    }
+
+    get quoted() {
+        return this.message.message?.extendedTextMessage?.contextInfo?.quotedMessage;
+    }
+
+    session() {
+        return this.bot.sessions?.get(this.remoteJid || '');
+    }
+
+    setSession(data) {
+        this.bot.sessions?.set(this.remoteJid || '', data);
+    }
+
+    updateSession(updater) {
+        this.bot.sessions?.update(this.remoteJid || '', updater);
+    }
+
+    clearSession() {
+        this.bot.sessions?.delete(this.remoteJid || '');
+    }
+
+    async reply(content, options) {
+        if (!this.remoteJid)
+            throw new Error('Cannot reply: remoteJid is undefined');
+        await this.bot.sendMessage(this.remoteJid, {
+            ...content
+        }, {
+            quoted: this.message,
+            ...options
+        });
+    }
+
+    async react(emoji) {
+        if (!this.remoteJid)
+            throw new Error('Cannot react: remoteJid is undefined');
+        await this.bot.sendMessage(this.remoteJid, {
+            react: { text: emoji, key: this.message.key }
+        });
+    }
+
+    async replySticker(inputPathOrBuffer, metadata) {
+        if (!this.remoteJid)
+            throw new Error('Cannot reply: remoteJid is undefined');
+        const buffer = await MediaManager.convertToSticker(inputPathOrBuffer, metadata);
+        await this.reply({ sticker: buffer });
+    }
+
+    async replyVoiceNote(inputPathOrBuffer) {
+        if (!this.remoteJid)
+            throw new Error('Cannot reply: remoteJid is undefined');
+        const buffer = await MediaManager.convertToVoiceNote(inputPathOrBuffer);
+        await this.reply({
+            audio: buffer,
+            mimetype: 'audio/ogg; codecs=opus',
+            ptt: true
+        });
+    }
+}

package/lib/Framework/MediaManager.d.ts

@@ -0,0 +1,17 @@
+export interface StickerMetadata {
+    packname?: string;
+    author?: string;
+}
+
+/** Image/video → WebP sticker and audio → OGG Opus voice-note conversion. */
+export class MediaManager {
+    /** Generate a temp file path with a given extension. */
+    static getTempFile(ext: string): string;
+    /**
+     * Convert image/video to a WebP sticker buffer.
+     * packname/author EXIF needs the optional `node-webpmux` peer dep.
+     */
+    static convertToSticker(inputPathOrBuffer: string | Buffer, metadata?: StickerMetadata): Promise<Buffer>;
+    /** Convert audio to OGG Opus voice-note format (mono, 16kHz, VOIP mode). */
+    static convertToVoiceNote(inputPathOrBuffer: string | Buffer): Promise<Buffer>;
+}

package/lib/Framework/MediaManager.js

@@ -0,0 +1,151 @@
+import { randomBytes } from 'crypto';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+
+// JAP@Framework --- media conversion helpers: image/video → WebP stickers
+// (with optional packname/author EXIF), audio → OGG Opus voice notes.
+//
+// JAP@Fix vs upstream: original hard-`require()`'d `node-webpmux` and
+// pulled in `ffmpeg-static` (bundles a per-platform ffmpeg binary) alongside
+// `fluent-ffmpeg`. `fluent-ffmpeg` is already an optional peer dep in this
+// fork, lazy-loaded via the getFfmpeg() pattern established in
+// Utils/MessageBuilder.js (15-08-26) — reused verbatim here instead of
+// re-introducing a static import or a second ffmpeg-binary dependency.
+// `node-webpmux` is lazy-loaded the same way, and only when packname/author
+// metadata is actually requested.
+let _ffmpeg;
+const getFfmpeg = async () => {
+    if (_ffmpeg === undefined) {
+        _ffmpeg = await import('fluent-ffmpeg').then((m) => m.default ?? m).catch(() => null);
+    }
+    if (!_ffmpeg)
+        throw new Error('fluent-ffmpeg is required for sticker/voice-note conversion. Install it with: npm i fluent-ffmpeg');
+    return _ffmpeg;
+};
+
+let _webpmux;
+const getWebpmux = async () => {
+    if (_webpmux === undefined) {
+        _webpmux = await import('node-webpmux').then((m) => m.default ?? m).catch(() => null);
+    }
+    if (!_webpmux)
+        throw new Error('node-webpmux is required for sticker packname/author metadata. Install it with: npm i node-webpmux (conversion without metadata does not need this package)');
+    return _webpmux;
+};
+
+export class MediaManager {
+    /** Generate a temp file path with a given extension */
+    static getTempFile(ext) {
+        return path.join(os.tmpdir(), `baileys-fw-${randomBytes(8).toString('hex')}.${ext}`);
+    }
+
+    /**
+     * Convert image or video to a WebP sticker buffer.
+     * Applies packname/author EXIF metadata when provided (requires the
+     * optional `node-webpmux` peer dependency — only loaded if metadata is given).
+     */
+    static async convertToSticker(inputPathOrBuffer, metadata) {
+        const ffmpegLib = await getFfmpeg();
+        const tempInput = MediaManager.getTempFile('in');
+        const tempOutput = MediaManager.getTempFile('webp');
+        try {
+            if (Buffer.isBuffer(inputPathOrBuffer)) {
+                await fs.promises.writeFile(tempInput, inputPathOrBuffer);
+            }
+            else {
+                await fs.promises.copyFile(inputPathOrBuffer, tempInput);
+            }
+            await new Promise((resolve, reject) => {
+                ffmpegLib(tempInput)
+                    .outputOptions([
+                    '-vcodec', 'libwebp',
+                    '-vf', 'scale=512:512:force_original_aspect_ratio=decrease,pad=512:512:(ow-iw)/2:(oh-ih)/2:color=white@0',
+                    '-loop', '0',
+                    '-preset', 'default',
+                    '-an', '-vsync', '0',
+                    '-t', '00:00:05'
+                ])
+                    .output(tempOutput)
+                    .on('end', () => resolve())
+                    .on('error', (err) => reject(err))
+                    .run();
+            });
+            const webpBuffer = await fs.promises.readFile(tempOutput);
+            if (metadata?.packname || metadata?.author) {
+                // EXIF header: fixed 22-byte TIFF/IFD preamble (magic + one IFD
+                // entry pointing at the WhatsApp tag 0x0741) followed by a
+                // little-endian payload length and a little-endian offset to
+                // where the payload begins (always 22, the header's own size).
+                const exifJson = JSON.stringify({
+                    'sticker-pack-id': `com.jap.sticker.${randomBytes(4).toString('hex')}`,
+                    'sticker-pack-name': metadata.packname || '',
+                    'sticker-pack-publisher': metadata.author || '',
+                    emojis: ['🤖']
+                });
+                const exifBytes = Buffer.from(exifJson, 'utf8');
+                const exifHeader = Buffer.from([
+                    0x49, 0x49, 0x2a, 0x00, // TIFF byte order (little-endian) + magic number
+                    0x08, 0x00, 0x00, 0x00, // offset to first IFD
+                    0x01, 0x00, // number of IFD entries
+                    0x41, 0x57, 0x07, 0x00, // tag 0x0741 (WhatsApp), type 0x0007 (undefined)
+                    0x00, 0x00, 0x00, 0x00, // payload length placeholder — filled below
+                    0x16, 0x00, 0x00, 0x00 // offset to payload data (fixed: 22 = header size)
+                ]);
+                exifHeader.writeUInt32LE(exifBytes.length, 14);
+                const fullExif = Buffer.concat([exifHeader, exifBytes]);
+                const webpmux = await getWebpmux();
+                const img = new webpmux.Image();
+                await img.load(webpBuffer);
+                img.exif = fullExif;
+                return await img.save(null);
+            }
+            return webpBuffer;
+        }
+        finally {
+            await fs.promises.unlink(tempInput).catch(() => { });
+            await fs.promises.unlink(tempOutput).catch(() => { });
+        }
+    }
+
+    /**
+     * Convert audio to OGG Opus voice note format.
+     * Mono, 16kHz, VOIP application mode — required by WA for PTT playback.
+     */
+    static async convertToVoiceNote(inputPathOrBuffer) {
+        const ffmpegLib = await getFfmpeg();
+        const tempInput = MediaManager.getTempFile('in');
+        const tempOutput = MediaManager.getTempFile('ogg');
+        try {
+            if (Buffer.isBuffer(inputPathOrBuffer)) {
+                await fs.promises.writeFile(tempInput, inputPathOrBuffer);
+            }
+            else {
+                await fs.promises.copyFile(inputPathOrBuffer, tempInput);
+            }
+            await new Promise((resolve, reject) => {
+                ffmpegLib(tempInput)
+                    .inputOptions(['-y'])
+                    .outputOptions([
+                    '-c:a', 'libopus',
+                    '-ac', '1', // mono channel (required by WA)
+                    '-ar', '16000', // 16kHz sample rate
+                    '-application', 'voip',
+                    '-b:a', '32k',
+                    '-compression_level', '10',
+                    '-vbr', 'on'
+                ])
+                    .format('ogg')
+                    .output(tempOutput)
+                    .on('end', () => resolve())
+                    .on('error', (err) => reject(err))
+                    .run();
+            });
+            return await fs.promises.readFile(tempOutput);
+        }
+        finally {
+            await fs.promises.unlink(tempInput).catch(() => { });
+            await fs.promises.unlink(tempOutput).catch(() => { });
+        }
+    }
+}

package/lib/Framework/SessionManager.d.ts

@@ -0,0 +1,13 @@
+import type { SQLiteStore } from './Store/SQLiteStore.js';
+
+/** Per-JID session CRUD backed by a SQLiteStore. */
+export class SessionManager {
+    constructor(store: SQLiteStore);
+    store: SQLiteStore;
+    key(jid: string): string;
+    get(jid: string): any;
+    set(jid: string, data: any): void;
+    update(jid: string, updater: (prev: any) => any): void;
+    delete(jid: string): void;
+    has(jid: string): boolean;
+}

package/lib/Framework/SessionManager.js

@@ -0,0 +1,33 @@
+// JAP@Framework --- per-JID session CRUD backed by SQLiteStore. Unchanged logic
+// from upstream; only the SQLiteStore instance it wraps is now created via
+// an async factory (see Store/SQLiteStore.js).
+export class SessionManager {
+    constructor(store) {
+        this.store = store;
+    }
+
+    key(jid) {
+        return `session_${jid}`;
+    }
+
+    get(jid) {
+        return this.store.get(this.key(jid));
+    }
+
+    set(jid, data) {
+        this.store.set(this.key(jid), data);
+    }
+
+    update(jid, updater) {
+        const prev = this.get(jid);
+        this.set(jid, updater(prev));
+    }
+
+    delete(jid) {
+        this.store.del(this.key(jid));
+    }
+
+    has(jid) {
+        return this.get(jid) !== undefined;
+    }
+}

package/lib/Framework/StatsManager.d.ts

@@ -0,0 +1,26 @@
+export interface StatRow {
+    jid: string;
+    count: number;
+}
+
+export interface GhostEntry {
+    jid: string;
+    isTotalGhost: boolean;
+    lastActive?: number;
+}
+
+/** Group activity tracking: message/sticker counts, leaderboards, ghost detection. */
+export class StatsManager {
+    constructor(db: any, groupMetaFn: (groupJid: string) => Promise<any>);
+    /** Async factory (better-sqlite3 is lazy-loaded). Replaces `new StatsManager(dbPath, …)`. */
+    static create(dbPath: string, groupMetaFn: (groupJid: string) => Promise<any>): Promise<StatsManager>;
+    /** Record a message observation for stats. */
+    observeMessage(groupJid: string, userJid: string, isSticker?: boolean): void;
+    /** Top message senders for a group. */
+    getTopUsers(groupJid: string, limit?: number): StatRow[];
+    /** Top sticker senders for a group. */
+    getTopStickers(groupJid: string, limit?: number): StatRow[];
+    /** Detect inactive members ("ghosts"). Throws Boom(503) when disconnected. */
+    getGhosts(groupJid: string, socketConnected: boolean, inactiveDays?: number): Promise<GhostEntry[]>;
+    close(): void;
+}

package/lib/Framework/StatsManager.js

@@ -0,0 +1,119 @@
+import { Boom } from '@hapi/boom';
+import { jidNormalizedUser } from '../WABinary/index.js';
+
+// JAP@Framework --- group activity tracking: message counts, sticker counts,
+// leaderboards, ghost (inactive member) detection.
+//
+// Kept from upstream's P0-P3 pass:
+//  - all participant JIDs normalized via jidNormalizedUser() before storing/
+//    querying, so PN/LID/device (:0, :42) variants resolve to the same row
+//  - getTopUsers/getTopStickers guard limit to a positive integer
+//  - getGhosts throws Boom(503) instead of a bare Error when the socket
+//    isn't connected, so callers can branch on statusCode
+//
+// JAP@Fix vs upstream: same issue as SQLiteStore — `better-sqlite3` was a
+// hard top-level import. Reused the lazy loadBetterSqlite3() pattern and
+// moved construction behind an async `StatsManager.create()` factory.
+async function loadBetterSqlite3() {
+    try {
+        const mod = (await import('better-sqlite3'));
+        return mod.default ?? mod;
+    }
+    catch (err) {
+        const helpful = new Error('`better-sqlite3` is required for the Framework StatsManager. Install it as a peer dependency: `npm install better-sqlite3` (or `yarn add better-sqlite3`).');
+        helpful.cause = err;
+        throw helpful;
+    }
+}
+
+export class StatsManager {
+    constructor(db, groupMetaFn) {
+        this.db = db;
+        this.groupMetaFn = groupMetaFn;
+        this.db.exec(`
+			CREATE TABLE IF NOT EXISTS group_stats (
+				group_jid    TEXT NOT NULL,
+				user_jid     TEXT NOT NULL,
+				msg_count    INTEGER NOT NULL DEFAULT 0,
+				sticker_count INTEGER NOT NULL DEFAULT 0,
+				last_active  INTEGER NOT NULL,
+				PRIMARY KEY (group_jid, user_jid)
+			)
+		`);
+        this.insertStmt = this.db.prepare(`
+			INSERT INTO group_stats (group_jid, user_jid, msg_count, sticker_count, last_active)
+			VALUES (?, ?, ?, ?, ?)
+			ON CONFLICT(group_jid, user_jid) DO UPDATE SET
+				msg_count     = msg_count + excluded.msg_count,
+				sticker_count = sticker_count + excluded.sticker_count,
+				last_active   = excluded.last_active
+		`);
+        this.getStatsStmt = this.db.prepare('SELECT user_jid, msg_count, sticker_count, last_active FROM group_stats WHERE group_jid = ?');
+        this.getTopMsgStmt = (limit) => this.db.prepare(`SELECT user_jid AS jid, msg_count AS count FROM group_stats WHERE group_jid = ? ORDER BY msg_count DESC LIMIT ${limit}`);
+        this.getTopStickerStmt = (limit) => this.db.prepare(`SELECT user_jid AS jid, sticker_count AS count FROM group_stats WHERE group_jid = ? ORDER BY sticker_count DESC LIMIT ${limit}`);
+    }
+
+    /** JAP@Port: replaces the old synchronous `new StatsManager(dbPath, groupMetaFn)`. */
+    static async create(dbPath, groupMetaFn) {
+        const Database = await loadBetterSqlite3();
+        return new StatsManager(new Database(dbPath), groupMetaFn);
+    }
+
+    /** Record a message observation for stats. Normalizes both JIDs before storing. */
+    observeMessage(groupJid, userJid, isSticker) {
+        const normalizedGroupJid = jidNormalizedUser(groupJid);
+        const normalizedUserJid = jidNormalizedUser(userJid);
+        const msgCount = 1;
+        const stickerCount = isSticker ? 1 : 0;
+        const now = Date.now();
+        this.insertStmt.run(normalizedGroupJid, normalizedUserJid, msgCount, stickerCount, now);
+    }
+
+    /** Top message senders for a group. */
+    getTopUsers(groupJid, limit = 10) {
+        const safeLimit = Math.max(1, Math.floor(limit));
+        const normalizedGroupJid = jidNormalizedUser(groupJid);
+        return this.getTopMsgStmt(safeLimit).all(normalizedGroupJid);
+    }
+
+    /** Top sticker senders for a group. */
+    getTopStickers(groupJid, limit = 10) {
+        const safeLimit = Math.max(1, Math.floor(limit));
+        const normalizedGroupJid = jidNormalizedUser(groupJid);
+        return this.getTopStickerStmt(safeLimit).all(normalizedGroupJid);
+    }
+
+    /** Detect inactive members ("ghosts") in a group. */
+    async getGhosts(groupJid, socketConnected, inactiveDays = 30) {
+        if (!socketConnected) {
+            throw new Boom('Socket not connected — cannot fetch group metadata for ghost detection', {
+                statusCode: 503
+            });
+        }
+        const normalizedGroupJid = jidNormalizedUser(groupJid);
+        const cutoff = Date.now() - inactiveDays * 24 * 60 * 60 * 1000;
+        const rows = this.getStatsStmt.all(normalizedGroupJid);
+        const statsMap = new Map();
+        for (const row of rows) {
+            statsMap.set(jidNormalizedUser(row.user_jid), row.last_active);
+        }
+        const groupMeta = await this.groupMetaFn(groupJid);
+        return groupMeta.participants
+            .map(p => {
+            const normalizedJid = jidNormalizedUser(p.id);
+            const lastActive = statsMap.get(normalizedJid);
+            if (!lastActive) {
+                return { jid: normalizedJid, isTotalGhost: true };
+            }
+            if (lastActive < cutoff) {
+                return { jid: normalizedJid, isTotalGhost: false, lastActive };
+            }
+            return null;
+        })
+            .filter((g) => g !== null);
+    }
+
+    close() {
+        this.db.close();
+    }
+}

package/lib/Framework/Store/SQLiteStore.d.ts

@@ -0,0 +1,11 @@
+/** Generic key-value store backed by better-sqlite3 (lazy-loaded). */
+export class SQLiteStore {
+    constructor(db: any);
+    /** Async factory — await this instead of `new SQLiteStore(dbPath)`. */
+    static create(dbPath: string): Promise<SQLiteStore>;
+    get(key: string): any;
+    /** `undefined`/`null` values delete the key. */
+    set(key: string, value: any): void;
+    del(key: string): void;
+    close(): void;
+}

package/lib/Framework/Store/SQLiteStore.js

@@ -0,0 +1,73 @@
+// JAP@Framework --- generic key-value store backed by better-sqlite3. Used by
+// SessionManager to persist per-JID session state to disk instead of RAM.
+//
+// JAP@Fix vs upstream: `better-sqlite3` was a hard top-level `import`, which
+// would crash the whole Framework import at module-load time for anyone who
+// hasn't installed it (it's an optional peer dep in this fork, same as
+// use-sqlite-auth-state). Switched to the lazy `loadBetterSqlite3()` loader
+// already used by Utils/use-sqlite-auth-state.js, and moved construction
+// behind an async `SQLiteStore.create()` factory since the loader is async.
+async function loadBetterSqlite3() {
+    try {
+        const mod = (await import('better-sqlite3'));
+        return mod.default ?? mod;
+    }
+    catch (err) {
+        const helpful = new Error('`better-sqlite3` is required for the Framework SQLiteStore. Install it as a peer dependency: `npm install better-sqlite3` (or `yarn add better-sqlite3`).');
+        helpful.cause = err;
+        throw helpful;
+    }
+}
+
+export class SQLiteStore {
+    constructor(db) {
+        this.db = db;
+        this.db.exec(`
+			CREATE TABLE IF NOT EXISTS kv_store (
+				key   TEXT PRIMARY KEY,
+				value TEXT NOT NULL
+			)
+		`);
+        this.getStmt = this.db.prepare('SELECT value FROM kv_store WHERE key = ?');
+        this.setStmt = this.db.prepare('INSERT INTO kv_store (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value');
+        this.delStmt = this.db.prepare('DELETE FROM kv_store WHERE key = ?');
+    }
+
+    /** JAP@Port: replaces the old synchronous `new SQLiteStore(dbPath)` — await this instead. */
+    static async create(dbPath) {
+        const Database = await loadBetterSqlite3();
+        return new SQLiteStore(new Database(dbPath));
+    }
+
+    get(key) {
+        const row = this.getStmt.get(key);
+        if (!row)
+            return undefined;
+        try {
+            return JSON.parse(row.value);
+        }
+        catch {
+            // Fallback for legacy non-JSON rows (migration safety)
+            return row.value;
+        }
+    }
+
+    set(key, value) {
+        // guard undefined/null — delegate to del so callers don't need to check
+        if (value === undefined || value === null) {
+            this.del(key);
+            return;
+        }
+        // always JSON.stringify — raw string storage breaks round-trip for
+        // values that are valid JSON (numbers, booleans, JSON objects serialized as strings)
+        this.setStmt.run(key, JSON.stringify(value));
+    }
+
+    del(key) {
+        this.delStmt.run(key);
+    }
+
+    close() {
+        this.db.close();
+    }
+}

package/lib/Framework/index.d.ts

@@ -0,0 +1,9 @@
+export { Bot, resolveSocketVersionConfig } from './Bot.js';
+export { Context } from './Context.js';
+export { MediaManager } from './MediaManager.js';
+export { SessionManager } from './SessionManager.js';
+export { StatsManager } from './StatsManager.js';
+export { SQLiteStore } from './Store/SQLiteStore.js';
+export type { BotConfig, BotMiddleware, BotCommandHandler } from './Bot.js';
+export type { StickerMetadata } from './MediaManager.js';
+export type { StatRow, GhostEntry } from './StatsManager.js';

package/lib/Framework/index.js

@@ -0,0 +1,10 @@
+// JAP@Port --- Enterprise Bot Framework exports.
+// Design notes: SQLiteStore/StatsManager are lazy-loaded (see
+// Store/SQLiteStore.js and StatsManager.js), MediaManager spawns the system
+// `ffmpeg` binary instead of bundling fluent-ffmpeg/ffmpeg-static.
+export { Bot, resolveSocketVersionConfig } from './Bot.js';
+export { Context } from './Context.js';
+export { MediaManager } from './MediaManager.js';
+export { SessionManager } from './SessionManager.js';
+export { StatsManager } from './StatsManager.js';
+export { SQLiteStore } from './Store/SQLiteStore.js';

package/lib/Signal/Group/ciphertext-message.d.ts

@@ -0,0 +1,9 @@
+export class CiphertextMessage {
+    UNSUPPORTED_VERSION: number;
+    CURRENT_VERSION: number;
+    WHISPER_TYPE: number;
+    PREKEY_TYPE: number;
+    SENDERKEY_TYPE: number;
+    SENDERKEY_DISTRIBUTION_TYPE: number;
+    ENCRYPTED_MESSAGE_OVERHEAD: number;
+}

package/lib/Signal/Group/ciphertext-message.js

@@ -0,0 +1,11 @@
+export class CiphertextMessage {
+    constructor() {
+        this.UNSUPPORTED_VERSION = 1;
+        this.CURRENT_VERSION = 3;
+        this.WHISPER_TYPE = 2;
+        this.PREKEY_TYPE = 3;
+        this.SENDERKEY_TYPE = 4;
+        this.SENDERKEY_DISTRIBUTION_TYPE = 5;
+        this.ENCRYPTED_MESSAGE_OVERHEAD = 53;
+    }
+}

package/lib/Signal/Group/group-session-builder.d.ts

@@ -0,0 +1,7 @@
+export class GroupSessionBuilder {
+    constructor(senderKeyStore: any);
+    senderKeyStore: any;
+    process(senderKeyName: any, senderKeyDistributionMessage: any): Promise<void>;
+    create(senderKeyName: any): Promise<SenderKeyDistributionMessage>;
+}
+import { SenderKeyDistributionMessage } from './sender-key-distribution-message.js';

package/lib/Signal/Group/group-session-builder.js

@@ -0,0 +1,29 @@
+import * as keyhelper from './keyhelper.js';
+import { SenderKeyDistributionMessage } from './sender-key-distribution-message.js';
+import { SenderKeyName } from './sender-key-name.js';
+import { SenderKeyRecord } from './sender-key-record.js';
+export class GroupSessionBuilder {
+    constructor(senderKeyStore) {
+        this.senderKeyStore = senderKeyStore;
+    }
+    async process(senderKeyName, senderKeyDistributionMessage) {
+        const senderKeyRecord = await this.senderKeyStore.loadSenderKey(senderKeyName);
+        senderKeyRecord.addSenderKeyState(senderKeyDistributionMessage.getId(), senderKeyDistributionMessage.getIteration(), senderKeyDistributionMessage.getChainKey(), senderKeyDistributionMessage.getSignatureKey());
+        await this.senderKeyStore.storeSenderKey(senderKeyName, senderKeyRecord);
+    }
+    async create(senderKeyName) {
+        const senderKeyRecord = await this.senderKeyStore.loadSenderKey(senderKeyName);
+        if (senderKeyRecord.isEmpty()) {
+            const keyId = keyhelper.generateSenderKeyId();
+            const senderKey = keyhelper.generateSenderKey();
+            const signingKey = keyhelper.generateSenderSigningKey();
+            senderKeyRecord.setSenderKeyState(keyId, 0, senderKey, signingKey);
+            await this.senderKeyStore.storeSenderKey(senderKeyName, senderKeyRecord);
+        }
+        const state = senderKeyRecord.getSenderKeyState();
+        if (!state) {
+            throw new Error('No session state available');
+        }
+        return new SenderKeyDistributionMessage(state.getKeyId(), state.getSenderChainKey().getIteration(), state.getSenderChainKey().getSeed(), state.getSigningKeyPublic());
+    }
+}

package/lib/Signal/Group/group_cipher.d.ts

@@ -0,0 +1,10 @@
+export class GroupCipher {
+    constructor(senderKeyStore: any, senderKeyName: any);
+    senderKeyStore: any;
+    senderKeyName: any;
+    encrypt(paddedPlaintext: any): Promise<any>;
+    decrypt(senderKeyMessageBytes: any): Promise<any>;
+    getSenderKey(senderKeyState: any, iteration: any): any;
+    getPlainText(iv: any, key: any, ciphertext: any): Promise<any>;
+    getCipherText(iv: any, key: any, plaintext: any): Promise<any>;
+}