@openclaw/whatsapp 2026.7.2-beta.5 → 2026.7.2-beta.7

package/node_modules/{protobufjs → baileys/node_modules/protobufjs}/src/reader_buffer.js

@@ -3,7 +3,14 @@ module.exports = BufferReader;
 
 // extends Reader
 var Reader = require("./reader");
-(BufferReader.prototype = Object.create(Reader.prototype)).constructor = BufferReader;
+BufferReader.prototype = Object.create(Reader.prototype, {
+    constructor: {
+        value: BufferReader,
+        writable: true,
+        enumerable: false,
+        configurable: true
+    }
+});
 
 var util = require("./util/minimal");
 
@@ -21,7 +28,7 @@ function BufferReader(buffer) {
      * Read buffer.
      * @name BufferReader#buf
      * @type {Buffer}
-     */
+    */
 }
 
 BufferReader._configure = function () {
@@ -30,15 +37,34 @@ BufferReader._configure = function () {
         BufferReader.prototype._slice = util.Buffer.prototype.slice;
 };
 
+/**
+ * Returns raw bytes from the backing buffer without advancing the reader.
+ * @name BufferReader#raw
+ * @function
+ * @param {number} start Start offset
+ * @param {number} end End offset
+ * @returns {Buffer} Raw bytes
+ */
+BufferReader.prototype.raw = function read_raw_buffer(start, end) {
+    return this._slice.call(this.buf, start, end);
+};
 
 /**
  * @override
  */
 BufferReader.prototype.string = function read_string_buffer() {
-    var len = this.uint32(); // modifies pos
+    var len = this.uint32(), // modifies pos
+        start = this.pos,
+        end = this.pos + len;
+
+    /* istanbul ignore if */
+    if (end > this.len)
+        throw RangeError("index out of range: " + this.pos + " + " + len + " > " + this.len);
+
+    this.pos = end;
     return this.buf.utf8Slice
-        ? this.buf.utf8Slice(this.pos, this.pos = Math.min(this.pos + len, this.len))
-        : this.buf.toString("utf-8", this.pos, this.pos = Math.min(this.pos + len, this.len));
+        ? this.buf.utf8Slice(start, end)
+        : this.buf.toString("utf-8", start, end);
 };
 
 /**

package/node_modules/{protobufjs → baileys/node_modules/protobufjs}/src/root.js

@@ -3,7 +3,15 @@ module.exports = Root;
 
 // extends Namespace
 var Namespace = require("./namespace");
-((Root.prototype = Object.create(Namespace.prototype)).constructor = Root).className = "Root";
+Root.prototype = Object.create(Namespace.prototype, {
+    constructor: {
+        value: Root,
+        writable: true,
+        enumerable: false,
+        configurable: true
+    }
+});
+Root.className = "Root";
 
 var Field   = require("./field"),
     Enum    = require("./enum"),
@@ -59,7 +67,10 @@ function Root(options) {
  * @returns {Root} Root namespace
  */
 Root.fromJSON = function fromJSON(json, root, depth) {
-    depth = util.checkDepth(depth);
+    if (depth === undefined)
+        depth = 0;
+    if (depth > util.recursionLimit)
+        throw Error("max depth exceeded");
     if (!root)
         root = new Root();
     if (json.options)
@@ -132,8 +143,9 @@ Root.prototype.load = function load(filename, options, callback) {
         var idx = filename.lastIndexOf("google/protobuf/");
         if (idx > -1) {
             var altname = filename.substring(idx);
-            if (altname in common) return altname;
+            if (Object.prototype.hasOwnProperty.call(common, altname)) return altname;
         }
+        if (Object.prototype.hasOwnProperty.call(common, filename)) return filename;
         return null;
     }
 
@@ -183,7 +195,7 @@ Root.prototype.load = function load(filename, options, callback) {
         self.files.push(filename);
 
         // Shortcut bundled definitions
-        if (filename in common) {
+        if (Object.prototype.hasOwnProperty.call(common, filename)) {
             if (sync) {
                 process(filename, common[filename], depth);
             } else {

package/node_modules/{protobufjs → baileys/node_modules/protobufjs}/src/rpc/service.js

@@ -4,7 +4,14 @@ module.exports = Service;
 var util = require("../util/minimal");
 
 // Extends EventEmitter
-(Service.prototype = Object.create(util.EventEmitter.prototype)).constructor = Service;
+Service.prototype = Object.create(util.EventEmitter.prototype, {
+    constructor: {
+        value: Service,
+        writable: true,
+        enumerable: false,
+        configurable: true
+    }
+});
 
 /**
  * A service method callback as used by {@link rpc.ServiceMethod|ServiceMethod}.
@@ -23,10 +30,16 @@ var util = require("../util/minimal");
  * @typedef rpc.ServiceMethod
  * @template TReq extends Message<TReq>
  * @template TRes extends Message<TRes>
- * @type {function}
- * @param {TReq|Properties<TReq>} request Request message or plain object
- * @param {rpc.ServiceMethodCallback<TRes>} [callback] Node-style callback called with the error, if any, and the response message
- * @returns {Promise<Message<TRes>>} Promise if `callback` has been omitted, otherwise `undefined`
+ * @type {{
+ *   (request: TReq|Properties<TReq>, callback: rpc.ServiceMethodCallback<TRes>): void;
+ *   (request: TReq|Properties<TReq>): Promise<TRes>;
+ *   readonly name: string;
+ *   readonly path: string;
+ *   readonly requestType: string;
+ *   readonly responseType: string;
+ *   readonly requestStream: true|undefined;
+ *   readonly responseStream: true|undefined;
+ * }}
  */
 
 /**

package/node_modules/{protobufjs → baileys/node_modules/protobufjs}/src/service.js

@@ -3,7 +3,15 @@ module.exports = Service;
 
 // extends Namespace
 var Namespace = require("./namespace");
-((Service.prototype = Object.create(Namespace.prototype)).constructor = Service).className = "Service";
+Service.prototype = Object.create(Namespace.prototype, {
+    constructor: {
+        value: Service,
+        writable: true,
+        enumerable: false,
+        configurable: true
+    }
+});
+Service.className = "Service";
 
 var Method = require("./method"),
     util   = require("./util"),
@@ -39,7 +47,9 @@ function Service(name, options) {
  * Service descriptor.
  * @interface IService
  * @extends INamespace
+ * @property {string} [edition] Edition
  * @property {Object.<string,IMethod>} methods Method descriptors
+ * @property {string|null} [comment] Service comment
  */
 
 /**
@@ -51,7 +61,10 @@ function Service(name, options) {
  * @throws {TypeError} If arguments are invalid
  */
 Service.fromJSON = function fromJSON(name, json, depth) {
-    depth = util.checkDepth(depth);
+    if (depth === undefined)
+        depth = 0;
+    if (depth > util.recursionLimit)
+        throw Error("max depth exceeded");
     var service = new Service(name, json.options);
     /* istanbul ignore else */
     if (json.methods)

package/node_modules/{protobufjs → baileys/node_modules/protobufjs}/src/tokenize.js

@@ -225,6 +225,7 @@ function tokenize(source, alternateCommentMode) {
             curr,
             start,
             isDoc,
+            nextLineIsComment,
             isLeadingComment = offset === 0;
         do {
             if (offset === length)
@@ -278,7 +279,11 @@ function tokenize(source, alternateCommentMode) {
                                     // Trailing comment cannot not be multi-line
                                     break;
                                 }
-                            } while (isDoubleSlashCommentLine(offset));
+                                nextLineIsComment = isDoubleSlashCommentLine(offset);
+                                if (nextLineIsComment) {
+                                    line++;
+                                }
+                            } while (nextLineIsComment);
                         } else {
                             offset = Math.min(length, findEndOfLine(offset) + 1);
                         }

package/node_modules/{protobufjs → baileys/node_modules/protobufjs}/src/type.js

@@ -3,7 +3,15 @@ module.exports = Type;
 
 // extends Namespace
 var Namespace = require("./namespace");
-((Type.prototype = Object.create(Namespace.prototype)).constructor = Type).className = "Type";
+Type.prototype = Object.create(Namespace.prototype, {
+    constructor: {
+        value: Type,
+        writable: true,
+        enumerable: false,
+        configurable: true
+    }
+});
+Type.className = "Type";
 
 var Enum      = require("./enum"),
     OneOf     = require("./oneof"),
@@ -89,6 +97,13 @@ function Type(name, options) {
      * @private
      */
     this._ctor = null;
+
+    /**
+     * Cached fields by JSON name.
+     * @type {Object.<string,Field>|null}
+     * @private
+     */
+    this._fieldsByJsonName = null; // used by ext/protojson
 }
 
 Object.defineProperties(Type.prototype, {
@@ -148,6 +163,7 @@ Object.defineProperties(Type.prototype, {
     /**
      * The registered constructor, if any registered, otherwise a generic constructor.
      * Assigning a function replaces the internal constructor. If the function does not extend {@link Message} yet, its prototype will be setup accordingly and static methods will be populated. If it already extends {@link Message}, it will just replace the internal constructor.
+     * When assigning manually, add the type to its parent namespace/root first if fields reference other reflected types, because constructor setup resolves field defaults.
      * @name Type#ctor
      * @type {Constructor<{}>}
      */
@@ -160,7 +176,13 @@ Object.defineProperties(Type.prototype, {
             // Ensure proper prototype
             var prototype = ctor.prototype;
             if (!(prototype instanceof Message)) {
-                (ctor.prototype = new Message()).constructor = ctor;
+                ctor.prototype = new Message();
+                Object.defineProperty(ctor.prototype, "constructor", {
+                    value: ctor,
+                    writable: true,
+                    enumerable: false,
+                    configurable: true
+                });
                 util.merge(ctor.prototype, prototype);
             }
 
@@ -171,11 +193,15 @@ Object.defineProperties(Type.prototype, {
             util.merge(ctor, Message, true);
 
             this._ctor = ctor;
+            delete this.decode;
+            delete this.fromObject;
 
             // Messages have non-enumerable default values on their prototype
             var i = 0;
-            for (; i < /* initializes */ this.fieldsArray.length; ++i)
-                this._fieldsArray[i].resolve(); // ensures a proper value
+            for (var field; i < /* initializes */ this.fieldsArray.length; ++i) {
+                field = this._fieldsArray[i].resolve(); // ensures a proper value
+                ctor.prototype[field.name] = field.defaultValue;
+            }
 
             // Messages have non-enumerable getters and setters for each virtual oneof field
             var ctorProperties = {};
@@ -197,7 +223,7 @@ Object.defineProperties(Type.prototype, {
  */
 Type.generateConstructor = function generateConstructor(mtype) {
     /* eslint-disable no-unexpected-multiline */
-    var gen = util.codegen(["p"], mtype.name);
+    var gen = util.codegen(["p"]);
     // explicitly initialize mutable object/array fields so that these aren't just inherited from the prototype
     for (var i = 0, field; i < mtype.fieldsArray.length; ++i)
         if ((field = mtype._fieldsArray[i]).map) gen
@@ -211,7 +237,7 @@ Type.generateConstructor = function generateConstructor(mtype) {
 };
 
 function clearCache(type) {
-    type._fieldsById = type._fieldsArray = type._oneofsArray = null;
+    type._fieldsById = type._fieldsArray = type._oneofsArray = type._fieldsByJsonName = null;
     delete type.encode;
     delete type.decode;
     delete type.verify;
@@ -222,11 +248,13 @@ function clearCache(type) {
  * Message type descriptor.
  * @interface IType
  * @extends INamespace
+ * @property {string} [edition] Edition
  * @property {Object.<string,IOneOf>} [oneofs] Oneof descriptors
  * @property {Object.<string,IField>} fields Field descriptors
  * @property {number[][]} [extensions] Extension ranges
  * @property {Array.<number[]|string>} [reserved] Reserved ranges
  * @property {boolean} [group=false] Whether a legacy group or not
+ * @property {string|null} [comment] Message type comment
  */
 
 /**
@@ -411,10 +439,9 @@ Type.prototype.remove = function remove(object) {
         // See Type#add for the reason why extension fields are excluded here.
 
         /* istanbul ignore if */
-        if (!this.fields || this.fields[object.name] !== object)
+        if (!util.remove(this.fields, object, object.name))
             throw Error(object + " is not a member of " + this);
 
-        delete this.fields[object.name];
         object.parent = null;
         object.onRemove(this);
         return clearCache(this);
@@ -422,10 +449,9 @@ Type.prototype.remove = function remove(object) {
     if (object instanceof OneOf) {
 
         /* istanbul ignore if */
-        if (!this.oneofs || this.oneofs[object.name] !== object)
+        if (!util.remove(this.oneofs, object, object.name))
             throw Error(object + " is not a member of " + this);
 
-        delete this.oneofs[object.name];
         object.parent = null;
         object.onRemove(this);
         return clearCache(this);
@@ -454,7 +480,7 @@ Type.prototype.isReservedName = function isReservedName(name) {
 /**
  * Creates a new message of this type using the specified properties.
  * @param {Object.<string,*>} [properties] Properties to set
- * @returns {Message<{}>} Message instance
+ * @returns {ReflectedMessage} Message instance
  */
 Type.prototype.create = function create(properties) {
     return new this.ctor(properties);
@@ -468,6 +494,14 @@ Type.prototype.setup = function setup() {
     // Sets up everything at once so that the prototype chain does not have to be re-evaluated
     // multiple times (V8, soft-deopt prototype-check).
 
+    // Resolve feature defaults incl. field presence before generating codecs
+    var root = this.root;
+    if (root && root._needsRecursiveFeatureResolution) {
+        var edition = root._edition || this._edition;
+        if (edition)
+            root._resolveFeaturesRecursive(edition);
+    }
+
     var fullName = this.fullName,
         types    = [];
     for (var i = 0; i < /* initializes */ this.fieldsArray.length; ++i)
@@ -482,7 +516,8 @@ Type.prototype.setup = function setup() {
     this.decode = decoder(this)({
         Reader : Reader,
         types  : types,
-        util   : util
+        util   : util,
+        C      : this.ctor
     });
     this.verify = verifier(this)({
         types : types,
@@ -490,7 +525,8 @@ Type.prototype.setup = function setup() {
     });
     this.fromObject = converter.fromObject(this)({
         types : types,
-        util  : util
+        util  : util,
+        C     : this.ctor
     });
     this.toObject = converter.toObject(this)({
         types : types,
@@ -500,15 +536,13 @@ Type.prototype.setup = function setup() {
     // Inject custom wrappers for common types
     var wrapper = wrappers[fullName];
     if (wrapper) {
-        var originalThis = Object.create(this);
-        // if (wrapper.fromObject) {
-            originalThis.fromObject = this.fromObject;
-            this.fromObject = wrapper.fromObject.bind(originalThis);
-        // }
-        // if (wrapper.toObject) {
-            originalThis.toObject = this.toObject;
-            this.toObject = wrapper.toObject.bind(originalThis);
-        // }
+        var wrapperThis = Object.create(this);
+        // Reuse this type's runtime constructor in wrapper fromObject/toObject
+        wrapperThis._ctor = this.ctor;
+        wrapperThis.fromObject = this.fromObject;
+        this.fromObject = wrapper.fromObject.bind(wrapperThis);
+        wrapperThis.toObject = this.toObject;
+        this.toObject = wrapper.toObject.bind(wrapperThis);
     }
 
     return this;
@@ -531,27 +565,25 @@ Type.prototype.encode = function encode_setup(message, writer) { // eslint-disab
  * @returns {Writer} writer
  */
 Type.prototype.encodeDelimited = function encodeDelimited(message, writer) {
-    return this.encode(message, writer && writer.len ? writer.fork() : writer).ldelim();
+    return this.encode(message, (writer || Writer.create()).fork()).ldelim();
 };
 
 /**
  * Decodes a message of this type.
  * @param {Reader|Uint8Array} reader Reader or buffer to decode from
  * @param {number} [length] Length of the message, if known beforehand
- * @param {number} [end] Expected group end tag, if decoding a group
- * @param {number} [depth] Current nesting depth
- * @returns {Message<{}>} Decoded message
+ * @returns {ReflectedMessage} Decoded message
  * @throws {Error} If the payload is not a reader or valid buffer
  * @throws {util.ProtocolError<{}>} If required fields are missing
  */
-Type.prototype.decode = function decode_setup(reader, length, end, depth) {
-    return this.setup().decode(reader, length, end, depth); // overrides this method
+Type.prototype.decode = function decode_setup(reader, length) { // eslint-disable-line no-unused-vars
+    return this.setup().decode.apply(this, arguments); // overrides this method
 };
 
 /**
  * Decodes a message of this type preceeded by its byte length as a varint.
  * @param {Reader|Uint8Array} reader Reader or buffer to decode from
- * @returns {Message<{}>} Decoded message
+ * @returns {ReflectedMessage} Decoded message
  * @throws {Error} If the payload is not a reader or valid buffer
  * @throws {util.ProtocolError} If required fields are missing
  */
@@ -564,21 +596,19 @@ Type.prototype.decodeDelimited = function decodeDelimited(reader) {
 /**
  * Verifies that field values are valid and that required fields are present.
  * @param {Object.<string,*>} message Plain object to verify
- * @param {number} [depth] Current nesting depth
  * @returns {null|string} `null` if valid, otherwise the reason why it is not
  */
-Type.prototype.verify = function verify_setup(message, depth) {
-    return this.setup().verify(message, depth); // overrides this method
+Type.prototype.verify = function verify_setup(message) { // eslint-disable-line no-unused-vars
+    return this.setup().verify.apply(this, arguments); // overrides this method
 };
 
 /**
  * Creates a new message of this type from a plain object. Also converts values to their respective internal types.
  * @param {Object.<string,*>} object Plain object to convert
- * @param {number} [depth] Current nesting depth
- * @returns {Message<{}>} Message instance
+ * @returns {ReflectedMessage} Message instance
  */
-Type.prototype.fromObject = function fromObject(object, depth) {
-    return this.setup().fromObject(object, depth);
+Type.prototype.fromObject = function fromObject(object) { // eslint-disable-line no-unused-vars
+    return this.setup().fromObject.apply(this, arguments);
 };
 
 /**
@@ -610,6 +640,18 @@ Type.prototype.toObject = function toObject(message, options) { // eslint-disabl
     return this.setup().toObject.apply(this, arguments);
 };
 
+/**
+ * Gets the type url for this type.
+ * @param {string} [prefix] Custom type url prefix, defaults to `"type.googleapis.com"`
+ * @returns {string} The type url
+ */
+Type.prototype.getTypeUrl = function getTypeUrl(prefix) {
+    if (prefix === undefined)
+        prefix = "type.googleapis.com";
+    var fullName = this.fullName;
+    return prefix + "/" + (fullName.charAt(0) === "." ? fullName.substring(1) : fullName);
+};
+
 /**
  * Decorator function as returned by {@link Type.d} (TypeScript).
  * @typedef TypeDecorator
@@ -617,6 +659,7 @@ Type.prototype.toObject = function toObject(message, options) { // eslint-disabl
  * @param {Constructor<T>} target Target constructor
  * @returns {undefined}
  * @template T extends Message<T>
+ * @deprecated Legacy TypeScript decorator support. Will be removed in a future release.
  */
 
 /**
@@ -624,6 +667,7 @@ Type.prototype.toObject = function toObject(message, options) { // eslint-disabl
  * @param {string} [typeName] Type name, defaults to the constructor's name
  * @returns {TypeDecorator<T>} Decorator function
  * @template T extends Message<T>
+ * @deprecated Legacy TypeScript decorator support. Will be removed in a future release.
  */
 Type.d = function decorateType(typeName) {
     return function typeDecorator(target) {

package/node_modules/baileys/node_modules/protobufjs/src/typescript.js

@@ -0,0 +1,25 @@
+"use strict";
+/* eslint-disable no-unused-vars */
+
+// Global TypeScript helper typedefs. The unused vars anchor these typedefs so
+// both TypeScript checkJs and pbts can discover them from this script file.
+
+/**
+ * Constructor type.
+ * @template T
+ * @typedef {Function & { new(...params: any[]): T; prototype: T }} Constructor
+ */
+var Constructor;
+
+/**
+ * Properties type.
+ * @template T
+ * @typedef {{ [P in keyof T]?: T[P] }} Properties
+ */
+var Properties;
+
+/**
+ * Dynamically reflected message type.
+ * @typedef {Message<{}> & { [k: string]: any }} ReflectedMessage
+ */
+var ReflectedMessage;

package/node_modules/{@protobufjs/aspromise/index.d.ts → baileys/node_modules/protobufjs/src/util/aspromise.d.ts}

@@ -1,13 +1,13 @@
-export = asPromise;
-
-type asPromiseCallback = (error: Error | null, ...params: any[]) => {};
-
-/**
- * Returns a promise from a node-style callback function.
- * @memberof util
- * @param {asPromiseCallback} fn Function to call
- * @param {*} ctx Function context
- * @param {...*} params Function arguments
- * @returns {Promise<*>} Promisified function
- */
-declare function asPromise(fn: asPromiseCallback, ctx: any, ...params: any[]): Promise<any>;
+export = asPromise;
+
+type asPromiseCallback = (error: Error | null, ...params: any[]) => {};
+
+/**
+ * Returns a promise from a node-style callback function.
+ * @memberof util
+ * @param {asPromiseCallback} fn Function to call
+ * @param {*} ctx Function context
+ * @param {...*} params Function arguments
+ * @returns {Promise<*>} Promisified function
+ */
+declare function asPromise(fn: asPromiseCallback, ctx: any, ...params: any[]): Promise<any>;

package/node_modules/{@protobufjs/aspromise/index.js → baileys/node_modules/protobufjs/src/util/aspromise.js}

@@ -1,52 +1,52 @@
-"use strict";
-module.exports = asPromise;
-
-/**
- * Callback as used by {@link util.asPromise}.
- * @typedef asPromiseCallback
- * @type {function}
- * @param {Error|null} error Error, if any
- * @param {...*} params Additional arguments
- * @returns {undefined}
- */
-
-/**
- * Returns a promise from a node-style callback function.
- * @memberof util
- * @param {asPromiseCallback} fn Function to call
- * @param {*} ctx Function context
- * @param {...*} params Function arguments
- * @returns {Promise<*>} Promisified function
- */
-function asPromise(fn, ctx/*, varargs */) {
-    var params  = new Array(arguments.length - 1),
-        offset  = 0,
-        index   = 2,
-        pending = true;
-    while (index < arguments.length)
-        params[offset++] = arguments[index++];
-    return new Promise(function executor(resolve, reject) {
-        params[offset] = function callback(err/*, varargs */) {
-            if (pending) {
-                pending = false;
-                if (err)
-                    reject(err);
-                else {
-                    var params = new Array(arguments.length - 1),
-                        offset = 0;
-                    while (offset < params.length)
-                        params[offset++] = arguments[offset];
-                    resolve.apply(null, params);
-                }
-            }
-        };
-        try {
-            fn.apply(ctx || null, params);
-        } catch (err) {
-            if (pending) {
-                pending = false;
-                reject(err);
-            }
-        }
-    });
-}
+"use strict";
+module.exports = asPromise;
+
+/**
+ * Callback as used by {@link util.asPromise}.
+ * @typedef asPromiseCallback
+ * @type {function}
+ * @param {Error|null} error Error, if any
+ * @param {...*} params Additional arguments
+ * @returns {undefined}
+ */
+
+/**
+ * Returns a promise from a node-style callback function.
+ * @memberof util
+ * @param {asPromiseCallback} fn Function to call
+ * @param {*} ctx Function context
+ * @param {...*} params Function arguments
+ * @returns {Promise<*>} Promisified function
+ */
+function asPromise(fn, ctx/*, varargs */) {
+    var params  = new Array(arguments.length - 1),
+        offset  = 0,
+        index   = 2,
+        pending = true;
+    while (index < arguments.length)
+        params[offset++] = arguments[index++];
+    return new Promise(function executor(resolve, reject) {
+        params[offset] = function callback(err/*, varargs */) {
+            if (pending) {
+                pending = false;
+                if (err)
+                    reject(err);
+                else {
+                    var params = new Array(arguments.length - 1),
+                        offset = 0;
+                    while (offset < params.length)
+                        params[offset++] = arguments[offset];
+                    resolve.apply(null, params);
+                }
+            }
+        };
+        try {
+            fn.apply(ctx || null, params);
+        } catch (err) {
+            if (pending) {
+                pending = false;
+                reject(err);
+            }
+        }
+    });
+}