kage-baileys 3.0.6 → 3.2.4

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "kage-baileys",
-  "version": "3.0.6",
-  "description": "Kage Baileys una libreria de WhatsApp.",
+  "version": "3.2.4",
+  "description": "Kage Baileys: API de WhatsApp con comunidades, canales, medios y herramientas de diagnóstico.",
   "keywords": [
     "kage-baileys",
     "baileys",
@@ -17,7 +17,8 @@
   ],
   "homepage": "https://github.com/xrljosedv/kage-baileys",
   "repository": {
-    "url": "git+https://github.com/xrljosedv/kage-baileys.git"
+    "url": "git+https://github.com/xrljosedv/kage-baileys.git",
+    "type": "git"
   },
   "license": "MIT",
   "author": "xrljosedv",
@@ -25,30 +26,42 @@
   "types": "lib/index.d.ts",
   "files": [
     "lib/**/*",
-    "WAProto/*",
+    "WAProto/**/*",
     "engine-requirements.js",
     "scripts/**/*",
     "Example/**/*",
     "maintenance/**/*",
-    "test/**/*"
+    "test/**/*",
+    "licenses/**/*",
+    "README.MD",
+    "LICENSE",
+    "tsconfig.json"
   ],
   "scripts": {
     "gen:protobuf": "node scripts/generate-protobuf.cjs",
-    "lint": "node scripts/check-syntax.cjs",
+    "lint": "node scripts/check-syntax.cjs && node scripts/check-imports.cjs",
     "test": "node --test test/*.test.cjs",
-    "check": "npm run lint && npm test",
+    "check": "npm run lint && npm run check:types && npm test && npm run check:package",
     "example": "node Example/connection.cjs",
     "gen:types": "node scripts/generate-public-types.cjs",
     "check:engine": "node engine-requirements.js",
-    "prepublishOnly": "npm run gen:protobuf && npm run gen:types && npm run check"
+    "prepublishOnly": "npm run build && npm run check",
+    "maintenance": "node scripts/maintenance.cjs",
+    "check:imports": "node scripts/check-imports.cjs",
+    "check:types": "tsc -p tsconfig.json",
+    "build": "npm run check:engine && npm run gen:protobuf && npm run gen:types",
+    "check:package": "node scripts/check-package.cjs",
+    "prepack": "npm run check:package"
   },
   "dependencies": {
     "@adiwajshing/keyed-db": "^0.2.4",
     "@cacheable/node-cache": "^1.4.0",
     "@hapi/boom": "^9.1.3",
+    "@itsukichan/libsignal-node": "^1.0.1",
     "async-mutex": "^0.5.0",
     "axios": "^1.6.0",
     "cache-manager": "^5.7.6",
+    "cfonts": "^3.3.1",
     "chalk": "^4.1.2",
     "cheerio": "1.0.0",
     "fflate": "^0.8.0",
@@ -57,7 +70,6 @@
     "form-data": "^4.0.0",
     "gradient-string": "^2.0.2",
     "jimp": "1.6.1",
-    "kage-baileys": "^3.0.2",
     "libphonenumber-js": "^1.10.20",
     "libsignal": "^6.0.0",
     "link-preview-js": "4.0.4",
@@ -67,7 +79,9 @@
     "p-queue": "6.6.2",
     "pino": "^9.6",
     "protobufjs": "8.8.1",
+    "qrcode": "^1.5.4",
     "qrcode-terminal": "^0.12.0",
+    "unfurl.js": "^6.4.0",
     "uuid": "11.1.1",
     "ws": "^8.13.0"
   },
@@ -77,7 +91,9 @@
     "typescript": "^5.8.2"
   },
   "peerDependencies": {
+    "@napi-rs/image": "^1.12.0",
     "audio-decode": "^2.1.3",
+    "better-sqlite3": ">=11",
     "sharp": "^0.34.1"
   },
   "peerDependenciesMeta": {
@@ -86,6 +102,12 @@
     },
     "sharp": {
       "optional": true
+    },
+    "better-sqlite3": {
+      "optional": true
+    },
+    "@napi-rs/image": {
+      "optional": true
     }
   },
   "engines": {
@@ -94,5 +116,81 @@
   "optionalDependencies": {
     "@roamhq/wrtc": "*",
     "whatsapp-rust-bridge": "0.5.2"
+  },
+  "contributors": [
+    "David Zuniga"
+  ],
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "import": "./lib/index.mjs",
+      "require": "./lib/index.js"
+    },
+    "./*": "./*"
+  },
+  "overrides": {
+    "@itsukichan/libsignal-node": {
+      "protobufjs": "^7.6.6"
+    },
+    "ajv@^6.12.4": "^6.14.0",
+    "basic-ftp": "^5.2.4",
+    "brace-expansion@^1.1.7": "^1.1.13",
+    "brace-expansion@^2.0.1": "^2.0.3",
+    "flatted": "^3.4.2",
+    "glob@^10.2.2": "^10.5.0",
+    "glob@^10.3.10": "^10.5.0",
+    "glob@^10.5.0": "^10.5.0",
+    "handlebars": "^4.7.9",
+    "ip-address": "^10.1.1",
+    "js-yaml@^3.13.1": "^3.14.2",
+    "js-yaml@^4.1.0": "^4.1.1",
+    "markdown-it": "^14.1.1",
+    "minimatch@^3.0.4": "^3.1.5",
+    "minimatch@^3.1.2": "^3.1.5",
+    "minimatch@^5.0.1": "^5.1.8",
+    "minimatch@^9.0.4": "^9.0.9",
+    "minimatch@^9.0.5": "^9.0.9",
+    "picomatch@^2.0.4": "^2.3.2",
+    "picomatch@^2.3.1": "^2.3.2",
+    "picomatch@^4.0.0": "^4.0.4",
+    "picomatch@^4.0.2": "^4.0.4",
+    "socks": "^2.8.8",
+    "tar": "^7.5.11",
+    "tmp": "^0.2.5",
+    "underscore": "^1.13.8",
+    "yaml@^2.6.1": "^2.8.4",
+    "zod@^3.23.8": "^4.6.7"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "resolutions": {
+    "ajv@npm:^6.12.4": "^6.14.0",
+    "basic-ftp": "^5.2.4",
+    "brace-expansion@npm:^1.1.7": "^1.1.13",
+    "brace-expansion@npm:^2.0.1": "^2.0.3",
+    "flatted": "^3.4.2",
+    "glob@npm:^10.2.2": "^10.5.0",
+    "glob@npm:^10.3.10": "^10.5.0",
+    "glob@npm:^10.5.0": "^10.5.0",
+    "handlebars": "^4.7.9",
+    "ip-address": "^10.1.1",
+    "js-yaml@npm:^3.13.1": "^3.14.2",
+    "js-yaml@npm:^4.1.0": "^4.1.1",
+    "markdown-it": "^14.1.1",
+    "minimatch@npm:^3.0.4": "^3.1.5",
+    "minimatch@npm:^3.1.2": "^3.1.5",
+    "minimatch@npm:^5.0.1": "^5.1.8",
+    "minimatch@npm:^9.0.4": "^9.0.9",
+    "minimatch@npm:^9.0.5": "^9.0.9",
+    "picomatch@npm:^2.0.4": "^2.3.2",
+    "picomatch@npm:^2.3.1": "^2.3.2",
+    "picomatch@npm:^4.0.0": "^4.0.4",
+    "picomatch@npm:^4.0.2": "^4.0.4",
+    "socks": "^2.8.8",
+    "tar": "^7.5.11",
+    "tmp": "^0.2.5",
+    "underscore": "^1.13.8",
+    "yaml@npm:^2.6.1": "^2.8.4"
   }
 }

package/scripts/check-imports.cjs

@@ -0,0 +1,10 @@
+'use strict';
+const fs=require('node:fs'),path=require('node:path'),{createRequire}=require('node:module');
+const ts=require('typescript');const root=path.resolve(__dirname,'..');let checked=0;const failures=[];
+function scan(dir){for(const e of fs.readdirSync(dir,{withFileTypes:true})){const f=path.join(dir,e.name);if(e.isDirectory())scan(f);else if(/\.(?:c?js|mjs)$/.test(f)){
+ const tree=ts.createSourceFile(f,fs.readFileSync(f,'utf8'),ts.ScriptTarget.Latest,true);const req=createRequire(f);
+ function walk(n){let value;if(ts.isCallExpression(n)&&n.expression.getText(tree)==='require'&&n.arguments.length===1&&ts.isStringLiteral(n.arguments[0]))value=n.arguments[0].text;else if((ts.isImportDeclaration(n)||ts.isExportDeclaration(n))&&n.moduleSpecifier&&ts.isStringLiteral(n.moduleSpecifier))value=n.moduleSpecifier.text;
+ if(value?.startsWith('.')){checked++;try{req.resolve(value)}catch(err){failures.push({archivo:path.relative(root,f),ruta:value,error:err.code})}}ts.forEachChild(n,walk)}walk(tree);
+}}}
+for(const dir of ['lib','WAProto','scripts','test','Example'])scan(path.join(root,dir));
+console.log(JSON.stringify({importacionesLocales:checked,errores:failures},null,2));if(failures.length)process.exitCode=1;

package/scripts/check-package.cjs

@@ -0,0 +1,40 @@
+'use strict';
+const fs = require('node:fs');
+const path = require('node:path');
+const { createRequire } = require('node:module');
+const root = path.resolve(__dirname, '..');
+const pkg = require('../package.json');
+const failures = [];
+const entries = new Map();
+function scan(dir) {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        if (entry.name === 'node_modules' || entry.name === '.git') continue;
+        const file = path.join(dir, entry.name);
+        const relative = path.relative(root, file).replaceAll(path.sep, '/');
+        const key = relative.toLowerCase();
+        if (entries.has(key)) failures.push('Colisión de mayúsculas: ' + entries.get(key) + ' / ' + relative);
+        entries.set(key, relative);
+        if (entry.isDirectory()) scan(file);
+    }
+}
+scan(root);
+for (const entry of [pkg.main, pkg.types, pkg.exports['.'].import, 'WAProto/index.js', 'WAProto/index.d.ts', 'WAProto/WAProto.proto', 'licenses/upstream-MIT.txt', 'tsconfig.json']) {
+    if (!entry || !fs.existsSync(path.resolve(root, entry))) failures.push('Falta un archivo distribuido: ' + entry);
+}
+for (const item of require('../maintenance/api-coverage.json')) {
+    try {
+        const mod = require(path.join(root, item.archivo));
+        for (const name of item.exportaciones) if (!(name in mod)) failures.push('Exportación ausente: ' + item.archivo + ':' + name);
+    } catch (error) { failures.push(item.archivo + ': ' + error.message); }
+}
+const protocols = path.join(root, 'lib/WAUSync/Protocols');
+for (const name of ['USyncLIDProtocol', 'USyncBotProfileProtocol']) {
+    try { createRequire(path.join(root, pkg.main)).resolve(path.join(protocols, name)); }
+    catch (error) { failures.push(name + ': ' + error.message); }
+}
+if (failures.length) {
+    console.error(failures.join('\n'));
+    process.exitCode = 1;
+} else {
+    console.log('PACKAGE_OK: ' + pkg.name + '@' + pkg.version + '; sin colisiones; entradas CJS/ESM/tipos/protocolo presentes; API verificada.');
+}

package/scripts/check-syntax.cjs

@@ -8,7 +8,7 @@ function scan(dir) {
     for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
         const file = path.join(dir, entry.name);
         if (entry.isDirectory()) scan(file);
-        else if (/\.(?:js|cjs)$/.test(file)) {
+        else if (/\.(?:js|cjs|mjs)$/.test(file)) {
             const result = spawnSync(process.execPath, ['--check', file], { encoding: 'utf8' });
             if (result.status !== 0) { console.error(result.stderr); process.exit(1); }
             checked++;

package/scripts/generate-protobuf.cjs

@@ -11,10 +11,15 @@ pbjs.main(['-t', 'static-module', '-w', 'commonjs', '--keep-case', '-o', js, pat
     if (error) throw error;
     // Accept plain JSON int64 strings as well as Long instances in toObject.
     let source = fs.readFileSync(js, 'utf8');
+    // kage fix: inyecta decodificador base64 tolerante (evita "Error: invalid encoding"
+    // con base64 URL-safe, saltos de linea, padding roto o un caracter colgante residual
+    // en firmas/certificados de botMetadata.verificationMetadata.proofs).
+    const kageBase64Fix = fs.readFileSync(path.join(__dirname, 'kage-base64-fix.cjs'), 'utf8');
+    source = source.replace('var $protobuf = require("protobufjs/minimal");', 'var $protobuf = require("protobufjs/minimal");\n\n' + kageBase64Fix.trim());
     source = source.replace(/\$util\.Long\.prototype\.toString\.call\((message\.[\w]+)\)/g, 'kageLongString($1)');
     source = source.replace(/new \$util\.LongBits\((message\.[\w]+)\.low >>> 0, \1\.high >>> 0\)\.toNumber\((true)?\)/g, (_, value, unsigned) => `kageLongNumber(${value}, ${!!unsigned})`);
     source = source.replace(/\$util\.Long\.fromBits\((message\.[\w]+)\.low >>> 0, \1\.high >>> 0, (true|false)\)\.toBigInt\(\)/g, (_, value, unsigned) => `BigInt(kageLongString(${value}, ${unsigned}))`);
-    source += `\nfunction kageLongString(value, unsigned) {\n    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'bigint') return String(value);\n    const long = $util.Long.fromValue(value);\n    return (unsigned === true ? long.toUnsigned() : long).toString();\n}\nfunction kageLongNumber(value, unsigned) {\n    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'bigint') return Number(value);\n    const long = $util.Long.fromValue(value);\n    return (unsigned ? long.toUnsigned() : long.toSigned()).toNumber();\n}\nrequire('./compat.cjs')(module.exports.proto);\n`;
+    source += `\nfunction kageLongString(value, unsigned) {\n    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'bigint') return String(value);\n    const long = $util.Long.fromValue(value);\n    return (unsigned === true ? long.toUnsigned() : long).toString();\n}\nfunction kageLongNumber(value, unsigned) {\n    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'bigint') return Number(value);\n    const long = $util.Long.fromValue(value);\n    return (unsigned ? long.toUnsigned() : long.toSigned()).toNumber();\n}\nrequire('./compat.cjs')(module.exports.proto);\n`;  // kage-base64-fix.cjs es leído e inyectado arriba
     fs.writeFileSync(js, source);
     pbts.main(['-o', dts, js], error => {
         if (error) throw error;

package/scripts/generate-public-types.cjs

@@ -29,6 +29,11 @@ export interface WASocket {
     relayMessage(jid: string, message: WAMessageContent, options?: Record<string, any>): Promise<string>;
     sendMessage(jid: string, content: Record<string, any>, options?: Record<string, any>): Promise<WAMessage | undefined>;
     end(error?: Error): void;
+    registerSocketEndHandler(handler: () => void | Promise<void>): () => void;
+    updateServerTimeOffset(node: { attrs?: { t?: string | number } }): void;
+    sendUnifiedSession(): Promise<void>;
+    fetchAccountReachoutTimelock(): Promise<{ isActive: boolean; timeEnforcementEnds?: Date; enforcementType: string }>;
+    fetchNewChatMessageCap(): Promise<any>;
     [method: string]: any;
 }
 export declare function makeWASocket(config: SocketConfig): WASocket;
@@ -50,3 +55,7 @@ for (const name of Object.keys(api).sort()) {
 }
 fs.writeFileSync(path.resolve(__dirname, '../lib/index.d.ts'), declaration);
 console.log('Public core types and JavaScript-extra declarations generated.');
+
+const names = Object.keys(api).filter(name => name !== 'default' && name !== '__esModule' && /^[A-Za-z_$][\w$]*$/.test(name));
+const esm = "import api from './index.js';\nexport default api.default;\n" + names.map(name => `export const ${name} = api.${name};`).join('\n') + '\n';
+fs.writeFileSync(path.resolve(__dirname, '../lib/index.mjs'), esm);

package/scripts/kage-base64-fix.cjs

@@ -0,0 +1,45 @@
+'use strict';
+// ============================================================================
+// kage fix: decodificador base64 tolerante.
+// Evita "Error: invalid encoding" cuando WhatsApp/devlogs entregan firmas,
+// certificados o hashes con base64 URL-safe, saltos de linea, padding roto
+// o un caracter suelto residual (longitud % 4 === 1). En ese ultimo caso se
+// descarta unicamente el caracter colgante y el resto se decodifica intacto.
+// Este archivo es inyectado automaticamente por scripts/generate-protobuf.cjs
+// al final de WAProto/index.js tras cada regeneracion.
+// ============================================================================
+(function () {
+    var b64 = $protobuf.util.base64;
+    if (b64.__kageTolerant)
+        return;
+    var nativeDecode = b64.decode;
+    var nativeLength = b64.length;
+    var clean = function (string) {
+        var s = $String(string).replace(/[\r\n\t\s]/g, "").replace(/-/g, "+").replace(/_/g, "/");
+        var rem = s.length % 4;
+        if (rem === 2)
+            s += "==";
+        else if (rem === 3)
+            s += "=";
+        else if (rem === 1)
+            s = s.slice(0, -1); // caracter colgante: 6 bits sin datos, no aporta bytes
+        return s;
+    };
+    b64.length = function (string) {
+        if (typeof string !== "string")
+            return nativeLength(string);
+        return nativeLength(clean(string));
+    };
+    b64.decode = function (string, buffer, start) {
+        if (typeof string !== "string")
+            return nativeDecode(string, buffer, start);
+        var s = clean(string);
+        try {
+            return nativeDecode(s, buffer, start);
+        } catch (e) {
+            // ultimo recurso: elimina cualquier caracter residual no-base64
+            return nativeDecode(s.replace(/[^A-Za-z0-9+/=]/g, ""), buffer, start);
+        }
+    };
+    b64.__kageTolerant = true;
+})();

package/scripts/maintenance.cjs

@@ -0,0 +1,10 @@
+'use strict';
+const fs=require('node:fs'),path=require('node:path'),{spawnSync}=require('node:child_process');
+const root=path.resolve(__dirname,'..');const api=require('../lib');const pb=require('protobufjs');const schema=pb.loadSync(path.join(root,'WAProto/WAProto.proto')).resolveAll();let types=0,fields=0;
+function walk(n){if(n.fieldsArray){types++;fields+=n.fieldsArray.length;if(Object.keys(n.fieldsById).length!==n.fieldsArray.length)throw new Error('Identificadores duplicados en '+n.fullName)}for(const c of n.nestedArray||[])walk(c)}walk(schema);
+const coverage=require('../maintenance/api-coverage.json').map(item=>{const mod=require(path.join(root,item.archivo));return {archivo:item.archivo,exportaciones:item.exportaciones.length,faltantes:item.exportaciones.filter(k=>!(k in mod))}});
+const imports=spawnSync(process.execPath,[path.join(__dirname,'check-imports.cjs')],{encoding:'utf8'});
+const report={paquete:require('../package.json').name,version:require('../package.json').version,node:process.version,estructuraUnica:!fs.existsSync(path.join(root,'vendor')),exportacionesPublicas:Object.keys(api).length,tiposProtocolo:types,camposProtocolo:fields,cobertura:coverage,importaciones:JSON.parse(imports.stdout),alcance:'Validación local. Los recorridos reales de WhatsApp necesitan una sesión y servicios compatibles.'};
+fs.writeFileSync(path.join(root,'maintenance/verification.json'),JSON.stringify(report,null,2)+'\n');
+console.log(JSON.stringify({paquete:report.paquete,version:report.version,estructuraUnica:report.estructuraUnica,exportaciones:report.exportacionesPublicas,tipos:types,campos:fields,modulosVerificados:coverage.length,errores:coverage.filter(x=>x.faltantes.length).length+report.importaciones.errores.length},null,2));
+if(!report.estructuraUnica||imports.status||coverage.some(x=>x.faltantes.length))process.exitCode=1;

package/test/advanced.test.cjs

@@ -0,0 +1,24 @@
+'use strict';
+const test=require('node:test'),assert=require('node:assert/strict'),fs=require('node:fs'),path=require('node:path');const api=require('../lib');const logger=require('pino')({level:'silent'});
+const cases=[
+ ['bloque de código',{code:'console.log(1)',language:'javascript'},'botForwardedMessage'],
+ ['tabla',{table:[['Título'],['Valor']]},'botForwardedMessage'],
+ ['enlaces',{links:[{text:'Ejemplo',title:'Ejemplo',url:'https://example.com'}]},'botForwardedMessage'],
+ ['respuesta enriquecida',{richResponse:[{text:'Hola'}]},'botForwardedMessage'],
+ ['flujo nativo',{text:'Opciones',nativeFlow:[{text:'Sí',id:'si'}]},'interactiveMessage'],
+ ['pago',{paymentInviteServiceType:3},'paymentInviteMessage'],
+ ['contenido oculto',{text:'Hola',spoiler:true},'spoilerMessage'],
+ ['visualización única V2',{text:'Hola',viewOnceV2:true},'viewOnceMessageV2'],
+ ['visualización única extendida',{text:'Hola',viewOnceV2Extension:true},'viewOnceMessageV2Extension'],
+ ['estado de grupo',{text:'Hola',groupStatus:true},'groupStatusMessageV2'],
+ ['contenido directo',{raw:true,conversation:'Hola'},'conversation']
+];
+for(const[name,content,key]of cases)test('formato avanzado: '+name,async()=>{
+ const m=await api.generateWAMessageContent(content,{logger,userJid:'123@s.whatsapp.net'});const decoded=api.proto.Message.decode(api.proto.Message.encode(api.proto.Message.fromObject(m)).finish());assert.ok(decoded[key],key);
+});
+test('el contenido raw no modifica el objeto del consumidor',async()=>{const m={raw:true,conversation:'Prueba'};await api.generateWAMessageContent(m,{logger});assert.equal(m.raw,true)});
+test('citas de canal conservan el contenido y el identificador',async()=>{const m=await api.generateWAMessage('123@newsletter',{text:'Respuesta'},{logger,userJid:'123@s.whatsapp.net',quoted:{key:{id:'ABC',remoteJid:'123@newsletter',fromMe:false},message:{conversation:'Original'}}});assert.equal(m.message.extendedTextMessage.contextInfo.stanzaId,'ABC')});
+test('nombres alternativos del esquema conservan el mismo campo al codificar',()=>{const T=api.proto.Message.ExtendedTextMessage;const m=T.fromObject({faviconMmsMetadata:{thumbnailWidth:32}});const r=T.decode(T.encode(m).finish());assert.equal(r.faviconMmsMetadata.thumbnailWidth,32)});
+test('todos los módulos declarados conservan sus exportaciones',()=>{for(const item of require('../maintenance/api-coverage.json')){const mod=require('../'+item.archivo);for(const k of item.exportaciones)assert.ok(k in mod,item.archivo+': '+k)}});
+test('una sola raíz de paquete, sin módulos duplicados en carpetas privadas',()=>{assert.equal(fs.existsSync(path.join(__dirname,'../vendor')),false);assert.equal(fs.existsSync(path.join(__dirname,'../lib/KageExtra')),false)});
+test('banner solicitado y colores en terminales compatibles',()=>{const output=[];api.say('kage baileys',{font:'simple',align:'center',gradient:['red','magenta'],stream:{columns:40,isTTY:false,write:x=>output.push(x)}});api.say('Creado por xrljosedv',{font:'console',align:'center',colors:['cyan','magenta','yellow'],stream:{columns:40,isTTY:false,write:x=>output.push(x)}});assert.match(output.join(''),/KAGE BAILEYS/);assert.match(output.join(''),/Creado por xrljosedv/);assert.ok(!output.join('').includes('\x1b['))});

package/test/base64-fix.test.cjs

@@ -0,0 +1,49 @@
+'use strict';
+// Test del fix base64 tolerante: evita "Error: invalid encoding" en
+// BotSignatureVerificationUseCaseProof (signature / certificateChain).
+const { test } = require('node:test');
+const assert = require('node:assert');
+const path = require('path');
+const WAProto = require(path.join(__dirname, '..', 'WAProto', 'index.js'));
+
+const makeProof = (signature, certificateChain) => ({
+    messageContextInfo: {
+        botMetadata: {
+            verificationMetadata: {
+                proofs: [{ version: 1, useCase: 'WA_BOT_MSG', signature, certificateChain }]
+            }
+        }
+    }
+});
+
+test('base64 estandar con padding correcto se decodifica igual que siempre', () => {
+    const msg = WAProto.proto.Message.fromObject(makeProof('AAAA', ['QQ==']));
+    assert.strictEqual(Buffer.from(msg.messageContextInfo.botMetadata.verificationMetadata.proofs[0].certificateChain[0]).toString(), 'A');
+});
+
+test('base64 URL-safe (- y _) se acepta sin error', () => {
+    // 'a-b_' es URL-safe; en base64 estricto lanzaria invalid encoding por los caracteres
+    const msg = WAProto.proto.Message.fromObject(makeProof('AAAA', ['_-__']));
+    assert.ok(msg.messageContextInfo.botMetadata.verificationMetadata.proofs[0].certificateChain[0].length >= 0);
+});
+
+test('base64 sin padding se completa automaticamente', () => {
+    // 'QQ' (2 chars) sin '==' debe decodificar a 'A'
+    const msg = WAProto.proto.Message.fromObject(makeProof('AAAA', ['QQ']));
+    assert.strictEqual(Buffer.from(msg.messageContextInfo.botMetadata.verificationMetadata.proofs[0].certificateChain[0]).toString(), 'A');
+});
+
+test('base64 con saltos de linea no lanza invalid encoding', () => {
+    const msg = WAProto.proto.Message.fromObject(makeProof('AAAA', ['QQ==\n']));
+    assert.strictEqual(Buffer.from(msg.messageContextInfo.botMetadata.verificationMetadata.proofs[0].certificateChain[0]).toString(), 'A');
+});
+
+test('certificado con caracter colgante (len % 4 === 1) no lanza invalid encoding', () => {
+    // Reproduce el caso real de WhatsApp: cadena de 1169 chars (resto 1).
+    // El caracter colgante se descarta (6 bits sin datos) y el resto se decodifica.
+    const broken = 'TklYRUwuTWVzc2FnZUJ1aWxkZXJWNC43LVZlcmlmaWNhdGlvblNpZ25hdHVyZS5NZXRhZGF0YQ' + 'A';
+    const msg = WAProto.proto.Message.fromObject(makeProof('AAAA', [broken]));
+    const bytes = msg.messageContextInfo.botMetadata.verificationMetadata.proofs[0].certificateChain[0];
+    assert.ok(bytes.length > 0);
+    assert.strictEqual(Buffer.from(bytes).toString('utf8', 0, 8), 'NIXEL.Me');
+});

package/test/maintenance.test.cjs

@@ -31,7 +31,7 @@ test('single canonical proto resolves every message, enum and wire identifier',
         for (const child of node.nestedArray || []) walk(child);
     }
     walk(root);
-    assert.equal(fields, 2705); assert.equal(types, 539);
+    assert.ok(fields >= 2705); assert.ok(types >= 539);
     assert.equal(fs.existsSync(path.join(__dirname, '../WAProto/WAProto.kage-original.proto')), false);
 });
 test('restored media, bot and sync fields survive serialization', () => {

package/test/npm-publication.test.cjs

@@ -0,0 +1,141 @@
+'use strict';
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const api = require('../lib');
+const logger = require('pino')({ level: 'silent' });
+const tick = () => new Promise(resolve => setImmediate(resolve));
+function makeSocket() {
+    return api.makeWASocket({
+        auth: { creds: api.initAuthCreds(), keys: { get: async () => ({}), set: async () => {} } },
+        logger, waWebSocketUrl: 'wss://127.0.0.1:1', connectTimeoutMs: 1000,
+        fireInitQueries: false, kageTools: { banner: false }
+    });
+}
+test('Android archive has no filenames differing only in case', () => {
+    const seen = new Map();
+    function scan(dir) {
+        for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
+            if (e.name === 'node_modules' || e.name === '.git') continue;
+            const f = path.join(dir, e.name), key = f.toLowerCase();
+            assert.ok(!seen.has(key), (seen.get(key) || '') + ' / ' + f);
+            seen.set(key, f);
+            if (e.isDirectory()) scan(f);
+        }
+    }
+    scan(path.join(__dirname, '..'));
+});
+test('canonical LID protocol retains query, parser and per-user LID', () => {
+    const { USyncLIDProtocol } = require('../lib/WAUSync/Protocols/USyncLIDProtocol');
+    const p = new USyncLIDProtocol();
+    assert.deepEqual(p.getQueryElement(), { tag: 'lid', attrs: {} });
+    assert.equal(p.getUserElement(), null);
+    assert.deepEqual(p.getUserElement({ lid: '123@lid' }), { tag: 'lid', attrs: { jid: '123@lid' } });
+    assert.equal(p.parser({ tag: 'lid', attrs: { val: '123@lid' } }), '123@lid');
+    const query = new api.USyncQuery().withLIDProtocol();
+    assert.equal(query.protocols.find(p => p.name === 'lid').getUserElement({ lid: '123@lid' }).attrs.jid, '123@lid');
+});
+test('complete socket exposes every method in the supplemental surface', async () => {
+    const socket = makeSocket();
+    try {
+        for (const layer of require('../maintenance/reference-socket-surface.json')) {
+            for (const name of layer.methods) assert.ok(name in socket, layer.layer + ':' + name);
+        }
+    } finally { socket.end(); await tick(); }
+});
+test('socket end hooks run once, can be removed, and isolate rejected hooks', async () => {
+    const socket = makeSocket(); let calls = 0;
+    socket.registerSocketEndHandler(() => { calls++; });
+    socket.registerSocketEndHandler(async () => { calls++; throw new Error('expected cleanup error'); });
+    const remove = socket.registerSocketEndHandler(() => { calls += 100; });
+    remove(); socket.end(); socket.end(); await tick();
+    assert.equal(calls, 2);
+    socket.registerSocketEndHandler(() => { calls++; });
+    assert.equal(calls, 3);
+});
+test('account restriction and chat cap use existing WMex transport with correct paths', async () => {
+    const mex = require('../lib/Socket/mex'); const old = mex.executeWMexQuery;
+    const calls = [], events = []; const socket = makeSocket();
+    socket.ev.on('connection.update', e => { if (e.reachoutTimeLock) events.push(e.reachoutTimeLock); });
+    mex.executeWMexQuery = async (...args) => {
+        calls.push(args);
+        if (args[2] === api.XWAPaths.xwa2_fetch_account_reachout_timelock) {
+            return { is_active: true, time_enforcement_ends: '1800000000', enforcement_type: 'test' };
+        }
+        return { quota: 10, usage: 2 };
+    };
+    try {
+        const state = await socket.fetchAccountReachoutTimelock();
+        assert.equal(state.isActive, true);
+        assert.equal(state.timeEnforcementEnds.getTime(), 1800000000000);
+        assert.equal(state.enforcementType, 'test'); assert.equal(events.length, 1);
+        assert.deepEqual(await socket.fetchNewChatMessageCap(), { quota: 10, usage: 2 });
+        assert.deepEqual(calls[1][0], { input: { type: 'INDIVIDUAL_NEW_CHAT_MSG' } });
+        assert.equal(calls[0][1], api.QueryIds.REACHOUT_TIMELOCK);
+        assert.equal(calls[1][1], api.QueryIds.MESSAGE_CAPPING_INFO);
+        assert.equal(calls[0][3], socket.query);
+        assert.equal(calls[1][3], socket.query);
+    } finally { mex.executeWMexQuery = old; socket.end(); await tick(); }
+});
+test('closed socket ignores session telemetry and invalid server timestamps', async () => {
+    const socket = makeSocket();
+    socket.updateServerTimeOffset({ attrs: { t: 'Infinity' } });
+    socket.updateServerTimeOffset({ attrs: { t: 'invalid' } });
+    socket.updateServerTimeOffset({ attrs: { t: '0' } });
+    socket.updateServerTimeOffset({ attrs: { t: String(Math.floor(Date.now() / 1000)) } });
+    await socket.sendUnifiedSession(); socket.end(); await socket.sendUnifiedSession(); await tick();
+});
+test('Jimp resizing, cropping, effects and Kage thumbnails work with patched Zod', async () => {
+    const { Jimp } = require('jimp');
+    const image = new Jimp({ width: 32, height: 24, color: 0xff0000ff });
+    image.resize({ w: 64 }).crop({ x: 1, y: 1, w: 40, h: 20 }).flip({ horizontal: true });
+    image.contain({ w: 48, h: 48 }).cover({ w: 32, h: 32 }).rotate(90).circle();
+    image.color([{ apply: 'red', params: [10] }]);
+    const png = await image.getBuffer('image/png');
+    const thumbnail = await api.extractImageThumb(png, 16);
+    assert.equal(thumbnail.original.width, 32);
+    const thumbImage = await Jimp.read(thumbnail.buffer);
+    assert.equal(thumbImage.bitmap.width, 16);
+    const profile = await api.generateProfilePicture(png);
+    assert.ok(Buffer.isBuffer(profile.img));
+});
+test('npm overrides include each requested resolution and preserve major selection', () => {
+    const p = require('../package.json');
+    for (const [selector, range] of Object.entries(p.resolutions)) assert.equal(p.overrides[selector.replace('@npm:', '@')], range);
+    assert.equal(p.overrides['@itsukichan/libsignal-node'].protobufjs, '^7.6.6');
+    assert.equal(p.overrides['zod@^3.23.8'], '^4.6.7');
+    assert.equal(p.publishConfig.access, 'public');
+    assert.equal(api.KAGE_BUILD.version, p.version);
+});
+test('username builders and multimedia/account constants are exposed on active API', () => {
+    const user = new api.USyncUser().withUsername('example').withUsernameKey('key');
+    assert.equal(user.username, 'example'); assert.equal(user.usernameKey, 'key');
+    const query = new api.USyncQuery().withUsernameProtocol().withUser(user);
+    assert.equal(query.protocols[0].name, 'username');
+    assert.equal(api.QueryIds.REACHOUT_TIMELOCK, '23983697327930364');
+    assert.equal(api.QueryIds.MESSAGE_CAPPING_INFO, '24503548349331633');
+    assert.equal(api.QueryIds.SUBSCRIBED, '6388546374527196');
+    assert.equal(api.XWAPaths.xwa2_newsletter_subscribed, 'xwa2_newsletter_subscribed');
+    assert.equal(api.XWAPaths.xwa2_message_capping_info, 'xwa2_message_capping_info');
+    assert.equal(api.MEDIA_HKDF_KEY_MAPPING['sticker-pack'], 'Sticker Pack');
+    assert.equal(api.MEDIA_HKDF_KEY_MAPPING['product-catalog-image'], 'Product Catalog Image');
+    assert.ok(api.MEDIA_KEYS.includes('sticker-pack'));
+});
+test('retry manager accepts legacy and supplemental signatures and clears timers/caches', () => {
+    const manager = new api.MessageRetryManager(logger, 3);
+    const one = { conversation: 'one' }, two = { conversation: 'two' };
+    manager.addRecentMessage({ to: '1@s.whatsapp.net', id: 'a' }, one);
+    manager.addRecentMessage('2@s.whatsapp.net', 'b', two);
+    assert.equal(manager.getRecentMessage('1@s.whatsapp.net', 'a').message, one);
+    assert.equal(manager.getRecentMessage({ to: '2@s.whatsapp.net', id: 'b' }).message, two);
+    const key = Buffer.from([1, 2]); manager.saveBaseKey('address', 'b', key); key[0] = 9;
+    assert.equal(manager.hasSameBaseKey('address', 'b', Buffer.from([1, 2])), true);
+    manager.deleteBaseKey('address', 'b');
+    assert.equal(manager.hasSameBaseKey('address', 'b', Buffer.from([1, 2])), false);
+    manager.schedulePhoneRequest('a', () => assert.fail('cancelled timer fired'), 60000);
+    manager.clear();
+    assert.equal(manager.getRecentMessage('1@s.whatsapp.net', 'a'), undefined);
+    assert.deepEqual(Object.keys(manager.pendingPhoneRequests), []);
+    assert.equal(manager.statistics.totalRetries, 0);
+});