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

package/node_modules/{protobufjs/ext/descriptor/index.js → baileys/node_modules/protobufjs/ext/descriptor.js}

@@ -1,6 +1,6 @@
 "use strict";
-var $protobuf = require("../..");
-module.exports = exports = $protobuf.descriptor = $protobuf.Root.fromJSON(require("../../google/protobuf/descriptor.json")).lookup(".google.protobuf");
+var $protobuf = require("../light");
+module.exports = exports = $protobuf.descriptor = $protobuf.Root.fromJSON(require("../google/protobuf/descriptor.json")).lookup(".google.protobuf");
 
 var Namespace = $protobuf.Namespace,
     Root      = $protobuf.Root,
@@ -88,16 +88,24 @@ var numberRe  = patterns.numberRe,
  * @property {number} LITE_RUNTIME=3
  */
 
+/**
+ * Descriptor context.
+ * @interface IDescriptorContext
+ * @property {string} [edition="proto2"] Syntax or edition to use for direct object descriptor imports
+ * @property {IFeatureSet} [features] File-level features to apply for direct object descriptor imports
+ * @property {boolean} [keepCase=false] Uses proto field names as reflected field names
+ */
+
 /**
  * Creates a root from a descriptor set.
  * @param {IFileDescriptorSet|Reader|Uint8Array} descriptor Descriptor
+ * @param {{keepCase?: boolean}} [options] Conversion options
  * @returns {Root} Root instance
  */
-Root.fromDescriptor = function fromDescriptor(descriptor) {
+Root.fromDescriptor = function fromDescriptor(descriptor, options) {
 
-    // Decode the descriptor message if specified as a buffer:
-    if (typeof descriptor.length === "number")
-        descriptor = exports.FileDescriptorSet.decode(descriptor);
+    descriptor = decodeDescriptor(descriptor, exports.FileDescriptorSet);
+    options = options || {};
 
     var root = new Root();
 
@@ -108,26 +116,35 @@ Root.fromDescriptor = function fromDescriptor(descriptor) {
             filePackage = root;
             if ((fileDescriptor = descriptor.file[j])["package"] && fileDescriptor["package"].length)
                 filePackage = root.define(fileDescriptor["package"]);
-            var edition = editionFromDescriptor(fileDescriptor);
+            var fileOptions = fromDescriptorOptions(fileDescriptor.options, exports.FileOptions),
+                ctx = descriptorContext({
+                    edition: editionFromDescriptor(fileDescriptor),
+                    features: fileOptions && fileOptions.features,
+                    keepCase: options && options.keepCase
+                });
             if (fileDescriptor.name && fileDescriptor.name.length)
                 root.files.push(filePackage.filename = fileDescriptor.name);
+            var groupTypes = groupTypeNames(fileDescriptor.extension);
             if (fileDescriptor.messageType)
-                for (i = 0; i < fileDescriptor.messageType.length; ++i)
-                    filePackage.add(Type.fromDescriptor(fileDescriptor.messageType[i], edition));
+                for (i = 0; i < fileDescriptor.messageType.length; ++i) {
+                    var type = Type_fromDescriptor(fileDescriptor.messageType[i], ctx, false, 0);
+                    if (groupTypes[type.name])
+                        type.group = true;
+                    filePackage.add(type);
+                }
             if (fileDescriptor.enumType)
                 for (i = 0; i < fileDescriptor.enumType.length; ++i)
-                    filePackage.add(Enum.fromDescriptor(fileDescriptor.enumType[i], edition));
+                    filePackage.add(Enum_fromDescriptor(fileDescriptor.enumType[i], ctx, false));
             if (fileDescriptor.extension)
                 for (i = 0; i < fileDescriptor.extension.length; ++i)
-                    filePackage.add(Field.fromDescriptor(fileDescriptor.extension[i], edition));
+                    filePackage.add(Field_fromDescriptor(fileDescriptor.extension[i], ctx, false));
             if (fileDescriptor.service)
                 for (i = 0; i < fileDescriptor.service.length; ++i)
-                    filePackage.add(Service.fromDescriptor(fileDescriptor.service[i], edition));
-            var opts = fromDescriptorOptions(fileDescriptor.options, exports.FileOptions);
-            if (opts) {
-                var ks = Object.keys(opts);
+                    filePackage.add(Service_fromDescriptor(fileDescriptor.service[i], ctx, false));
+            if (fileOptions) {
+                var ks = Object.keys(fileOptions);
                 for (i = 0; i < ks.length; ++i)
-                    filePackage.setOption(ks[i], opts[ks[i]]);
+                    filePackage.setOption(ks[i], fileOptions[ks[i]]);
             }
         }
     }
@@ -217,70 +234,79 @@ var unnamedMessageIndex = 0;
 
 /**
  * Creates a type from a descriptor.
- *
- * Warning: this is not safe to use with editions protos, since it discards relevant file context.
- *
  * @param {IDescriptorProto|Reader|Uint8Array} descriptor Descriptor
- * @param {string} [edition="proto2"] The syntax or edition to use
- * @param {boolean} [nested=false] Whether or not this is a nested object
- * @param {number} [depth] Current nesting depth, defaults to `0`
+ * @param {string|IDescriptorContext} [editionOrContext="proto2"] Syntax/edition shorthand or descriptor context
  * @returns {Type} Type instance
  */
-Type.fromDescriptor = function fromDescriptor(descriptor, edition, nested, depth) {
+Type.fromDescriptor = function fromDescriptor(descriptor, editionOrContext) {
+    return Type_fromDescriptor(descriptor, descriptorContext(editionOrContext), false, 0);
+};
+
+function Type_fromDescriptor(descriptor, ctx, nested, depth) {
     if (depth === undefined)
         depth = 0;
     if (depth > $protobuf.util.nestingLimit)
         throw Error("max depth exceeded");
-    // Decode the descriptor message if specified as a buffer:
-    if (typeof descriptor.length === "number")
-        descriptor = exports.DescriptorProto.decode(descriptor);
+    descriptor = decodeDescriptor(descriptor, exports.DescriptorProto);
 
-    // Create the message type
     var type = new Type(descriptor.name.length ? descriptor.name : "Type" + unnamedMessageIndex++, fromDescriptorOptions(descriptor.options, exports.MessageOptions)),
-        i;
+        i,
+        mapEntries = Object.create(null);
 
-    if (!nested)
-        type._edition = edition;
+    if (!nested) {
+        type._edition = ctx.edition;
+        applyContextFeatures(type, ctx);
+    }
+
+    if (descriptor.nestedType)
+        for (i = 0; i < descriptor.nestedType.length; ++i)
+            if (descriptor.nestedType[i].options && descriptor.nestedType[i].options.mapEntry)
+                mapEntries[descriptor.nestedType[i].name] = descriptor.nestedType[i];
+
+    var groupTypes = groupTypeNames(descriptor.field, descriptor.extension);
 
     /* Oneofs */ if (descriptor.oneofDecl)
         for (i = 0; i < descriptor.oneofDecl.length; ++i)
-            type.add(OneOf.fromDescriptor(descriptor.oneofDecl[i]));
+            type.add(OneOf_fromDescriptor(descriptor.oneofDecl[i], ctx, true));
     /* Fields */ if (descriptor.field)
         for (i = 0; i < descriptor.field.length; ++i) {
-            var field = Field.fromDescriptor(descriptor.field[i], edition, true);
+            var field = FieldBase_fromDescriptor(descriptor.field[i], ctx, true, mapEntries);
             type.add(field);
             if (descriptor.field[i].hasOwnProperty("oneofIndex")) // eslint-disable-line no-prototype-builtins
                 type.oneofsArray[descriptor.field[i].oneofIndex].add(field);
         }
     /* Extension fields */ if (descriptor.extension)
         for (i = 0; i < descriptor.extension.length; ++i)
-            type.add(Field.fromDescriptor(descriptor.extension[i], edition, true));
+            type.add(Field_fromDescriptor(descriptor.extension[i], ctx, true));
     /* Nested types */ if (descriptor.nestedType)
         for (i = 0; i < descriptor.nestedType.length; ++i) {
-            type.add(Type.fromDescriptor(descriptor.nestedType[i], edition, true, depth + 1));
             if (descriptor.nestedType[i].options && descriptor.nestedType[i].options.mapEntry)
-                type.setOption("map_entry", true);
+                continue;
+            var nestedType = Type_fromDescriptor(descriptor.nestedType[i], ctx, true, depth + 1);
+            if (groupTypes[nestedType.name])
+                nestedType.group = true;
+            type.add(nestedType);
         }
     /* Nested enums */ if (descriptor.enumType)
         for (i = 0; i < descriptor.enumType.length; ++i)
-            type.add(Enum.fromDescriptor(descriptor.enumType[i], edition, true));
+            type.add(Enum_fromDescriptor(descriptor.enumType[i], ctx, true));
     /* Extension ranges */ if (descriptor.extensionRange && descriptor.extensionRange.length) {
         type.extensions = [];
         for (i = 0; i < descriptor.extensionRange.length; ++i)
-            type.extensions.push([ descriptor.extensionRange[i].start, descriptor.extensionRange[i].end ]);
+            type.extensions.push([ descriptor.extensionRange[i].start, descriptor.extensionRange[i].end - 1 ]);
     }
     /* Reserved... */ if (descriptor.reservedRange && descriptor.reservedRange.length || descriptor.reservedName && descriptor.reservedName.length) {
         type.reserved = [];
         /* Ranges */ if (descriptor.reservedRange)
             for (i = 0; i < descriptor.reservedRange.length; ++i)
-                type.reserved.push([ descriptor.reservedRange[i].start, descriptor.reservedRange[i].end ]);
+                type.reserved.push([ descriptor.reservedRange[i].start, descriptor.reservedRange[i].end - 1 ]);
         /* Names */ if (descriptor.reservedName)
             for (i = 0; i < descriptor.reservedName.length; ++i)
                 type.reserved.push(descriptor.reservedName[i]);
     }
 
     return type;
-};
+}
 
 /**
  * Converts a type to a descriptor.
@@ -323,19 +349,48 @@ Type.prototype.toDescriptor = function toDescriptor(edition) {
     }
     /* Extension ranges */ if (this.extensions)
         for (i = 0; i < this.extensions.length; ++i)
-            descriptor.extensionRange.push(exports.DescriptorProto.ExtensionRange.create({ start: this.extensions[i][0], end: this.extensions[i][1] }));
+            descriptor.extensionRange.push(exports.DescriptorProto.ExtensionRange.create({ start: this.extensions[i][0], end: this.extensions[i][1] + 1 }));
     /* Reserved... */ if (this.reserved)
         for (i = 0; i < this.reserved.length; ++i)
             /* Names */ if (typeof this.reserved[i] === "string")
                 descriptor.reservedName.push(this.reserved[i]);
             /* Ranges */ else
-                descriptor.reservedRange.push(exports.DescriptorProto.ReservedRange.create({ start: this.reserved[i][0], end: this.reserved[i][1] }));
+                descriptor.reservedRange.push(exports.DescriptorProto.ReservedRange.create({ start: this.reserved[i][0], end: this.reserved[i][1] + 1 }));
 
     descriptor.options = toDescriptorOptions(this.options, exports.MessageOptions);
 
     return descriptor;
 };
 
+// --- FieldBase ---
+
+function FieldBase_fromDescriptor(descriptor, ctx, nested, mapEntries) {
+    var entryName = descriptor.typeName && descriptor.typeName.substring(descriptor.typeName.lastIndexOf(".") + 1),
+        mapEntry = descriptor.label === 3 && descriptor.type === 11 && entryName
+            ? mapEntries[entryName]
+            : null;
+
+    return mapEntry
+        ? MapField_fromDescriptor(descriptor, mapEntry, ctx)
+        : Field_fromDescriptor(descriptor, ctx, nested);
+}
+
+function fieldNameFromDescriptor(descriptor, ctx) {
+    return ctx.keepCase && descriptor.name.length
+        ? descriptor.name
+        : descriptor.jsonName && descriptor.jsonName.length
+            ? descriptor.jsonName
+            : descriptor.name.length ? descriptor.name : "field" + descriptor.number;
+}
+
+function applyFieldNamesFromDescriptor(field, descriptor) {
+    if (descriptor.name.length && descriptor.name !== field.name)
+        field.protoName = descriptor.name;
+    if (descriptor.jsonName && descriptor.jsonName.length)
+        field.jsonName = descriptor.jsonName;
+    return field;
+}
+
 // --- Field ---
 
 /**
@@ -349,8 +404,9 @@ Type.prototype.toDescriptor = function toDescriptor(edition) {
  * @property {string} [extendee] Extended type name
  * @property {string} [defaultValue] Literal default value
  * @property {number} [oneofIndex] Oneof index if part of a oneof
- * @property {*} [jsonName] Not supported
+ * @property {string} [jsonName] JSON name (lowerCamelCase)
  * @property {IFieldOptions} [options] Field options
+ * @property {boolean} [proto3Optional] Whether this is a proto3 optional field
  */
 
 /**
@@ -404,19 +460,16 @@ Type.prototype.toDescriptor = function toDescriptor(edition) {
 
 /**
  * Creates a field from a descriptor.
- *
- * Warning: this is not safe to use with editions protos, since it discards relevant file context.
- *
  * @param {IFieldDescriptorProto|Reader|Uint8Array} descriptor Descriptor
- * @param {string} [edition="proto2"] The syntax or edition to use
- * @param {boolean} [nested=false] Whether or not this is a top-level object
+ * @param {string|IDescriptorContext} [editionOrContext="proto2"] Syntax/edition shorthand or descriptor context
  * @returns {Field} Field instance
  */
-Field.fromDescriptor = function fromDescriptor(descriptor, edition, nested) {
+Field.fromDescriptor = function fromDescriptor(descriptor, editionOrContext) {
+    return Field_fromDescriptor(descriptor, descriptorContext(editionOrContext), false);
+};
 
-    // Decode the descriptor message if specified as a buffer:
-    if (typeof descriptor.length === "number")
-        descriptor = exports.DescriptorProto.decode(descriptor);
+function Field_fromDescriptor(descriptor, ctx, nested) {
+    descriptor = decodeDescriptor(descriptor, exports.FieldDescriptorProto);
 
     if (typeof descriptor.number !== "number")
         throw Error("missing field id");
@@ -447,20 +500,22 @@ Field.fromDescriptor = function fromDescriptor(descriptor, edition, nested) {
             throw Error("illegal type name: " + extendee);
     } else
         extendee = undefined;
-    var field = new Field(
-        descriptor.name.length ? descriptor.name : "field" + descriptor.number,
+    var field = applyFieldNamesFromDescriptor(new Field(
+        fieldNameFromDescriptor(descriptor, ctx),
         descriptor.number,
         fieldType,
         fieldRule,
         extendee
-    );
+    ), descriptor);
 
     if (!nested)
-        field._edition = edition;
+        field._edition = ctx.edition;
 
     field.options = fromDescriptorOptions(descriptor.options, exports.FieldOptions);
-    if (descriptor.proto3_optional)
-        field.options.proto3_optional = true;
+    if (!nested)
+        applyContextFeatures(field, ctx);
+    if (descriptor.proto3Optional || descriptor.proto3_optional)
+        (field.options || (field.options = {})).proto3_optional = true;
 
     if (descriptor.defaultValue && descriptor.defaultValue.length) {
         var defaultValue = descriptor.defaultValue;
@@ -480,16 +535,34 @@ Field.fromDescriptor = function fromDescriptor(descriptor, edition, nested) {
         field.setOption("default", defaultValue);
     }
 
-    if (packableDescriptorType(descriptor.type)) {
-        if (edition === "proto3") { // defaults to packed=true (internal preset is packed=true)
-            if (descriptor.options && !descriptor.options.packed)
-                field.setOption("packed", false);
-        } else if ((!edition || edition === "proto2") && descriptor.options && descriptor.options.packed) // defaults to packed=false
-            field.setOption("packed", true);
+    return field;
+}
+
+// --- MapField ---
+
+function MapField_fromDescriptor(descriptor, entryDescriptor, ctx) {
+    function entryField(number) {
+        if (entryDescriptor.field)
+            for (var i = 0; i < entryDescriptor.field.length; ++i)
+                if (entryDescriptor.field[i].number === number)
+                    return entryDescriptor.field[i];
+        throw Error("invalid map entry descriptor: " + entryDescriptor.name);
     }
 
-    return field;
-};
+    var keyDescriptor = entryField(1),
+        valueDescriptor = entryField(2),
+        valueType = valueDescriptor.typeName && valueDescriptor.typeName.length
+            ? valueDescriptor.typeName
+            : fromDescriptorType(valueDescriptor.type);
+
+    return applyFieldNamesFromDescriptor(new MapField(
+        fieldNameFromDescriptor(descriptor, ctx),
+        descriptor.number,
+        fromDescriptorType(keyDescriptor.type),
+        valueType,
+        fromDescriptorOptions(descriptor.options, exports.FieldOptions)
+    ), descriptor);
+}
 
 /**
  * Converts a field to a descriptor.
@@ -497,7 +570,13 @@ Field.fromDescriptor = function fromDescriptor(descriptor, edition, nested) {
  * @param {string} [edition="proto2"] The syntax or edition to use
  */
 Field.prototype.toDescriptor = function toDescriptor(edition) {
-    var descriptor = exports.FieldDescriptorProto.create({ name: this.name, number: this.id });
+    // Emit descriptor names in FieldDescriptorProto form, including json_name only
+    // when it differs, and derive missing names so unresolved fields serialize consistently.
+    var protoName = this.protoName || this.name;
+    var jsonName = this.jsonName || $protobuf.util.jsonName(protoName);
+    var descriptor = exports.FieldDescriptorProto.create({ name: protoName, number: this.id });
+    if (jsonName !== protoName)
+        descriptor.jsonName = jsonName;
 
     if (this.map) {
 
@@ -540,7 +619,7 @@ Field.prototype.toDescriptor = function toDescriptor(edition) {
         if (this.options["default"] != null)
             descriptor.defaultValue = String(this.options["default"]);
         if (this.options.proto3_optional)
-            descriptor.proto3_optional = true;
+            descriptor.proto3Optional = true;
     }
 
     if (edition === "proto3") { // defaults to packed=true
@@ -567,7 +646,17 @@ Field.prototype.toDescriptor = function toDescriptor(edition) {
  * @interface IEnumValueDescriptorProto
  * @property {string} [name] Name
  * @property {number} [number] Value
- * @property {*} [options] Not supported
+ * @property {IEnumValueOptions} [options] Enum value options
+ */
+
+/**
+ * Properties of an EnumValueOptions message.
+ * @interface IEnumValueOptions
+ * @property {boolean} [deprecated]
+ * @property {IFeatureSet} [features]
+ * @property {boolean} [debugRedact]
+ * @property {*} [featureSupport]
+ * @property {Array.<*>} [uninterpretedOption]
  */
 
 /**
@@ -577,44 +666,77 @@ Field.prototype.toDescriptor = function toDescriptor(edition) {
  * @property {boolean} [deprecated]
  */
 
+/**
+ * Properties of a FeatureSet message.
+ * @interface IFeatureSet
+ * @property {number} [fieldPresence]
+ * @property {number} [enumType]
+ * @property {number} [repeatedFieldEncoding]
+ * @property {number} [utf8Validation]
+ * @property {number} [messageEncoding]
+ * @property {number} [jsonFormat]
+ * @property {number} [enforceNamingStyle]
+ * @property {number} [defaultSymbolVisibility]
+ */
+
 var unnamedEnumIndex = 0;
 
 /**
  * Creates an enum from a descriptor.
- *
- * Warning: this is not safe to use with editions protos, since it discards relevant file context.
- *
  * @param {IEnumDescriptorProto|Reader|Uint8Array} descriptor Descriptor
- * @param {string} [edition="proto2"] The syntax or edition to use
- * @param {boolean} [nested=false] Whether or not this is a top-level object
+ * @param {string|IDescriptorContext} [editionOrContext="proto2"] Syntax/edition shorthand or descriptor context
  * @returns {Enum} Enum instance
  */
-Enum.fromDescriptor = function fromDescriptor(descriptor, edition, nested) {
+Enum.fromDescriptor = function fromDescriptor(descriptor, editionOrContext) {
+    return Enum_fromDescriptor(descriptor, descriptorContext(editionOrContext), false);
+};
 
-    // Decode the descriptor message if specified as a buffer:
-    if (typeof descriptor.length === "number")
-        descriptor = exports.EnumDescriptorProto.decode(descriptor);
+function Enum_fromDescriptor(descriptor, ctx, nested) {
+    descriptor = decodeDescriptor(descriptor, exports.EnumDescriptorProto);
 
     // Construct values object
-    var values = {};
+    var values = {},
+        valuesOptions,
+        i;
     if (descriptor.value)
-        for (var i = 0; i < descriptor.value.length; ++i) {
+        for (i = 0; i < descriptor.value.length; ++i) {
             var name  = descriptor.value[i].name,
-                value = descriptor.value[i].number || 0;
-            values[name && name.length ? name : "NAME" + value] = value;
+                valueName = name && name.length ? name : "NAME" + (descriptor.value[i].number || 0),
+                value = descriptor.value[i].number || 0,
+                options = fromDescriptorOptions(descriptor.value[i].options, exports.EnumValueOptions);
+            if (valueName === "__proto__")
+                continue;
+            values[valueName] = value;
+            if (options)
+                (valuesOptions || (valuesOptions = {}))[valueName] = options;
         }
 
     var enm = new Enum(
         descriptor.name && descriptor.name.length ? descriptor.name : "Enum" + unnamedEnumIndex++,
         values,
-        fromDescriptorOptions(descriptor.options, exports.EnumOptions)
+        fromDescriptorOptions(descriptor.options, exports.EnumOptions),
+        undefined,
+        undefined,
+        valuesOptions
     );
 
-    if (!nested)
-        enm._edition = edition;
+    if (!nested) {
+        enm._edition = ctx.edition;
+        applyContextFeatures(enm, ctx);
+    }
+
+    /* Reserved... */ if (descriptor.reservedRange && descriptor.reservedRange.length || descriptor.reservedName && descriptor.reservedName.length) {
+        enm.reserved = [];
+        /* Ranges */ if (descriptor.reservedRange)
+            for (i = 0; i < descriptor.reservedRange.length; ++i)
+                enm.reserved.push([ descriptor.reservedRange[i].start, descriptor.reservedRange[i].end ]);
+        /* Names */ if (descriptor.reservedName)
+            for (i = 0; i < descriptor.reservedName.length; ++i)
+                enm.reserved.push(descriptor.reservedName[i]);
+    }
 
     return enm;
-};
+}
 
 /**
  * Converts an enum to a descriptor.
@@ -623,15 +745,30 @@ Enum.fromDescriptor = function fromDescriptor(descriptor, edition, nested) {
 Enum.prototype.toDescriptor = function toDescriptor() {
 
     // Values
-    var values = [];
-    for (var i = 0, ks = Object.keys(this.values); i < ks.length; ++i)
-        values.push(exports.EnumValueDescriptorProto.create({ name: ks[i], number: this.values[ks[i]] }));
-
-    return exports.EnumDescriptorProto.create({
+    var values = [],
+        i,
+        ks = Object.keys(this.values);
+    for (i = 0; i < ks.length; ++i)
+        values.push(exports.EnumValueDescriptorProto.create({
+            name: ks[i],
+            number: this.values[ks[i]],
+            options: this.valuesOptions && toDescriptorOptions(this.valuesOptions[ks[i]], exports.EnumValueOptions)
+        }));
+
+    var descriptor = exports.EnumDescriptorProto.create({
         name: this.name,
         value: values,
         options: toDescriptorOptions(this.options, exports.EnumOptions)
     });
+
+    /* Reserved... */ if (this.reserved)
+        for (i = 0; i < this.reserved.length; ++i)
+            /* Names */ if (typeof this.reserved[i] === "string")
+                descriptor.reservedName.push(this.reserved[i]);
+            /* Ranges */ else
+                descriptor.reservedRange.push(exports.EnumDescriptorProto.EnumReservedRange.create({ start: this.reserved[i][0], end: this.reserved[i][1] }));
+
+    return descriptor;
 };
 
 // --- OneOf ---
@@ -640,31 +777,42 @@ Enum.prototype.toDescriptor = function toDescriptor() {
  * Properties of a OneofDescriptorProto message.
  * @interface IOneofDescriptorProto
  * @property {string} [name] Oneof name
- * @property {*} [options] Not supported
+ * @property {IOneofOptions} [options] Oneof options
+ */
+
+/**
+ * Properties of a OneofOptions message.
+ * @interface IOneofOptions
+ * @property {IFeatureSet} [features]
+ * @property {Array.<*>} [uninterpretedOption]
  */
 
 var unnamedOneofIndex = 0;
 
 /**
  * Creates a oneof from a descriptor.
- *
- * Warning: this is not safe to use with editions protos, since it discards relevant file context.
- *
  * @param {IOneofDescriptorProto|Reader|Uint8Array} descriptor Descriptor
+ * @param {string|IDescriptorContext} [editionOrContext="proto2"] Syntax/edition shorthand or descriptor context
  * @returns {OneOf} OneOf instance
  */
-OneOf.fromDescriptor = function fromDescriptor(descriptor) {
+OneOf.fromDescriptor = function fromDescriptor(descriptor, editionOrContext) {
+    return OneOf_fromDescriptor(descriptor, descriptorContext(editionOrContext), false);
+};
 
-    // Decode the descriptor message if specified as a buffer:
-    if (typeof descriptor.length === "number")
-        descriptor = exports.OneofDescriptorProto.decode(descriptor);
+function OneOf_fromDescriptor(descriptor, ctx, nested) {
+    descriptor = decodeDescriptor(descriptor, exports.OneofDescriptorProto);
 
-    return new OneOf(
+    var oneof = new OneOf(
         // unnamedOneOfIndex is global, not per type, because we have no ref to a type here
-        descriptor.name && descriptor.name.length ? descriptor.name : "oneof" + unnamedOneofIndex++
-        // fromDescriptorOptions(descriptor.options, exports.OneofOptions) - only uninterpreted_option
+        descriptor.name && descriptor.name.length ? descriptor.name : "oneof" + unnamedOneofIndex++,
+        fromDescriptorOptions(descriptor.options, exports.OneofOptions)
     );
-};
+    if (!nested) {
+        oneof._edition = ctx.edition;
+        applyContextFeatures(oneof, ctx);
+    }
+    return oneof;
+}
 
 /**
  * Converts a oneof to a descriptor.
@@ -672,8 +820,8 @@ OneOf.fromDescriptor = function fromDescriptor(descriptor) {
  */
 OneOf.prototype.toDescriptor = function toDescriptor() {
     return exports.OneofDescriptorProto.create({
-        name: this.name
-        // options: toDescriptorOptions(this.options, exports.OneofOptions) - only uninterpreted_option
+        name: this.name,
+        options: toDescriptorOptions(this.options, exports.OneofOptions)
     });
 };
 
@@ -697,29 +845,28 @@ var unnamedServiceIndex = 0;
 
 /**
  * Creates a service from a descriptor.
- *
- * Warning: this is not safe to use with editions protos, since it discards relevant file context.
- *
  * @param {IServiceDescriptorProto|Reader|Uint8Array} descriptor Descriptor
- * @param {string} [edition="proto2"] The syntax or edition to use
- * @param {boolean} [nested=false] Whether or not this is a top-level object
+ * @param {string|IDescriptorContext} [editionOrContext="proto2"] Syntax/edition shorthand or descriptor context
  * @returns {Service} Service instance
  */
-Service.fromDescriptor = function fromDescriptor(descriptor, edition, nested) {
+Service.fromDescriptor = function fromDescriptor(descriptor, editionOrContext) {
+    return Service_fromDescriptor(descriptor, descriptorContext(editionOrContext), false);
+};
 
-    // Decode the descriptor message if specified as a buffer:
-    if (typeof descriptor.length === "number")
-        descriptor = exports.ServiceDescriptorProto.decode(descriptor);
+function Service_fromDescriptor(descriptor, ctx, nested) {
+    descriptor = decodeDescriptor(descriptor, exports.ServiceDescriptorProto);
 
     var service = new Service(descriptor.name && descriptor.name.length ? descriptor.name : "Service" + unnamedServiceIndex++, fromDescriptorOptions(descriptor.options, exports.ServiceOptions));
-    if (!nested)
-        service._edition = edition;
+    if (!nested) {
+        service._edition = ctx.edition;
+        applyContextFeatures(service, ctx);
+    }
     if (descriptor.method)
         for (var i = 0; i < descriptor.method.length; ++i)
-            service.add(Method.fromDescriptor(descriptor.method[i]));
+            service.add(Method_fromDescriptor(descriptor.method[i], ctx, true));
 
     return service;
-};
+}
 
 /**
  * Converts a service to a descriptor.
@@ -754,9 +901,6 @@ Service.prototype.toDescriptor = function toDescriptor() {
 
 /**
  * Properties of a MethodOptions message.
- *
- * Warning: this is not safe to use with editions protos, since it discards relevant file context.
- *
  * @interface IMethodOptions
  * @property {boolean} [deprecated]
  */
@@ -766,13 +910,15 @@ var unnamedMethodIndex = 0;
 /**
  * Creates a method from a descriptor.
  * @param {IMethodDescriptorProto|Reader|Uint8Array} descriptor Descriptor
+ * @param {string|IDescriptorContext} [editionOrContext="proto2"] Syntax/edition shorthand or descriptor context
  * @returns {Method} Reflected method instance
  */
-Method.fromDescriptor = function fromDescriptor(descriptor) {
+Method.fromDescriptor = function fromDescriptor(descriptor, editionOrContext) {
+    return Method_fromDescriptor(descriptor, descriptorContext(editionOrContext), false);
+};
 
-    // Decode the descriptor message if specified as a buffer:
-    if (typeof descriptor.length === "number")
-        descriptor = exports.MethodDescriptorProto.decode(descriptor);
+function Method_fromDescriptor(descriptor, ctx, nested) {
+    descriptor = decodeDescriptor(descriptor, exports.MethodDescriptorProto);
 
     var inputType = descriptor.inputType,
         outputType = descriptor.outputType;
@@ -786,7 +932,7 @@ Method.fromDescriptor = function fromDescriptor(descriptor) {
             throw Error("illegal type name: " + outputType);
     }
 
-    return new Method(
+    var method = new Method(
         // unnamedMethodIndex is global, not per service, because we have no ref to a service here
         descriptor.name && descriptor.name.length ? descriptor.name : "Method" + unnamedMethodIndex++,
         "rpc",
@@ -796,7 +942,12 @@ Method.fromDescriptor = function fromDescriptor(descriptor) {
         Boolean(descriptor.serverStreaming),
         fromDescriptorOptions(descriptor.options, exports.MethodOptions)
     );
-};
+    if (!nested) {
+        method._edition = ctx.edition;
+        applyContextFeatures(method, ctx);
+    }
+    return method;
+}
 
 /**
  * Converts a method to a descriptor.
@@ -815,6 +966,24 @@ Method.prototype.toDescriptor = function toDescriptor() {
 
 // --- utility ---
 
+function descriptorContext(editionOrContext) {
+    if (editionOrContext && typeof editionOrContext === "object") {
+        var ctx = $protobuf.util.merge({}, editionOrContext);
+        if (!ctx.edition)
+            ctx.edition = "proto2";
+        return ctx;
+    }
+    return { edition: editionOrContext || "proto2" };
+}
+
+function applyContextFeatures(object, ctx) {
+    if (!ctx.features)
+        return object;
+    var options = object.options || (object.options = {});
+    options.features = $protobuf.util.merge({}, ctx.features, options.features);
+    return object;
+}
+
 // Converts a descriptor type to a protobuf.js basic type
 function fromDescriptorType(type) {
     switch (type) {
@@ -838,26 +1007,20 @@ function fromDescriptorType(type) {
     throw Error("illegal type: " + type);
 }
 
-// Tests if a descriptor type is packable
-function packableDescriptorType(type) {
-    switch (type) {
-        case 1: // double
-        case 2: // float
-        case 3: // int64
-        case 4: // uint64
-        case 5: // int32
-        case 6: // fixed64
-        case 7: // fixed32
-        case 8: // bool
-        case 13: // uint32
-        case 14: // enum (!)
-        case 15: // sfixed32
-        case 16: // sfixed64
-        case 17: // sint32
-        case 18: // sint64
-            return true;
+function groupTypeNames() {
+    var names = Object.create(null);
+    for (var a = 0; a < arguments.length; ++a) {
+        var fields = arguments[a];
+        if (!fields)
+            continue;
+        for (var i = 0; i < fields.length; ++i)
+            if (fields[i].type === 10 && fields[i].typeName) {
+                var name = fields[i].typeName.split(".").pop();
+                if (name)
+                    names[name] = true;
+            }
     }
-    return false;
+    return names;
 }
 
 // Converts a protobuf.js basic type to a descriptor type
@@ -939,6 +1102,13 @@ function toDescriptorOptions(options, type) {
     return type.fromObject(toDescriptorOptionsRecursive(options, type));
 }
 
+// Decodes descriptor input supplied as either a reader or buffer.
+function decodeDescriptor(descriptor, type) {
+    if (descriptor instanceof $protobuf.Reader || typeof descriptor.length === "number")
+        return type.decode(descriptor);
+    return descriptor;
+}
+
 // Calculates the shortest relative path from `from` to `to`.
 function shortname(from, to) {
     var fromPath = from.fullName.split("."),
@@ -970,6 +1140,8 @@ function editionFromDescriptor(fileDescriptor) {
         switch(fileDescriptor.edition) {
             case exports.Edition.EDITION_2023:
                 return "2023";
+            case exports.Edition.EDITION_2024:
+                return "2024";
             default:
                 throw new Error("Unsupported edition " + fileDescriptor.edition);
         }
@@ -990,6 +1162,9 @@ function editionToDescriptor(edition, fileDescriptor) {
             case "2023":
                 fileDescriptor.edition = exports.Edition.EDITION_2023;
                 break;
+            case "2024":
+                fileDescriptor.edition = exports.Edition.EDITION_2024;
+                break;
             default:
                 throw new Error("Unsupported edition " + edition);
         }
@@ -1001,186 +1176,181 @@ function editionToDescriptor(edition, fileDescriptor) {
 /**
  * Reflected file descriptor set.
  * @name FileDescriptorSet
- * @type {Type}
+ * @type {$protobuf.Type}
  * @const
- * @tstype $protobuf.Type
  */
 
 /**
  * Reflected file descriptor proto.
  * @name FileDescriptorProto
- * @type {Type}
+ * @type {$protobuf.Type}
  * @const
- * @tstype $protobuf.Type
  */
 
 /**
  * Reflected descriptor proto.
  * @name DescriptorProto
- * @type {Type}
- * @property {Type} ExtensionRange
- * @property {Type} ReservedRange
- * @const
- * @tstype $protobuf.Type & {
+ * @type {$protobuf.Type & {
  *     ExtensionRange: $protobuf.Type,
  *     ReservedRange: $protobuf.Type
- * }
+ * }}
+ * @const
  */
 
 /**
  * Reflected field descriptor proto.
  * @name FieldDescriptorProto
- * @type {Type}
- * @property {Enum} Label
- * @property {Enum} Type
- * @const
- * @tstype $protobuf.Type & {
+ * @type {$protobuf.Type & {
  *     Label: $protobuf.Enum,
  *     Type: $protobuf.Enum
- * }
+ * }}
+ * @const
  */
 
 /**
  * Reflected oneof descriptor proto.
  * @name OneofDescriptorProto
- * @type {Type}
+ * @type {$protobuf.Type}
  * @const
- * @tstype $protobuf.Type
  */
 
 /**
  * Reflected enum descriptor proto.
  * @name EnumDescriptorProto
- * @type {Type}
+ * @type {$protobuf.Type}
  * @const
- * @tstype $protobuf.Type
  */
 
 /**
  * Reflected service descriptor proto.
  * @name ServiceDescriptorProto
- * @type {Type}
+ * @type {$protobuf.Type}
  * @const
- * @tstype $protobuf.Type
  */
 
 /**
  * Reflected enum value descriptor proto.
  * @name EnumValueDescriptorProto
- * @type {Type}
+ * @type {$protobuf.Type}
  * @const
- * @tstype $protobuf.Type
  */
 
 /**
  * Reflected method descriptor proto.
  * @name MethodDescriptorProto
- * @type {Type}
+ * @type {$protobuf.Type}
  * @const
- * @tstype $protobuf.Type
  */
 
 /**
  * Reflected file options.
  * @name FileOptions
- * @type {Type}
- * @property {Enum} OptimizeMode
- * @const
- * @tstype $protobuf.Type & {
+ * @type {$protobuf.Type & {
  *     OptimizeMode: $protobuf.Enum
- * }
+ * }}
+ * @const
  */
 
 /**
  * Reflected message options.
  * @name MessageOptions
- * @type {Type}
+ * @type {$protobuf.Type}
  * @const
- * @tstype $protobuf.Type
  */
 
 /**
  * Reflected field options.
  * @name FieldOptions
- * @type {Type}
- * @property {Enum} CType
- * @property {Enum} JSType
- * @const
- * @tstype $protobuf.Type & {
+ * @type {$protobuf.Type & {
  *     CType: $protobuf.Enum,
  *     JSType: $protobuf.Enum
- * }
+ * }}
+ * @const
  */
 
 /**
  * Reflected oneof options.
  * @name OneofOptions
- * @type {Type}
+ * @type {$protobuf.Type}
  * @const
- * @tstype $protobuf.Type
  */
 
 /**
  * Reflected enum options.
  * @name EnumOptions
- * @type {Type}
+ * @type {$protobuf.Type}
  * @const
- * @tstype $protobuf.Type
  */
 
 /**
  * Reflected enum value options.
  * @name EnumValueOptions
- * @type {Type}
+ * @type {$protobuf.Type}
  * @const
- * @tstype $protobuf.Type
  */
 
 /**
  * Reflected service options.
  * @name ServiceOptions
- * @type {Type}
+ * @type {$protobuf.Type}
  * @const
- * @tstype $protobuf.Type
  */
 
 /**
  * Reflected method options.
  * @name MethodOptions
- * @type {Type}
+ * @type {$protobuf.Type}
+ * @const
+ */
+
+/**
+ * Reflected feature set.
+ * @name FeatureSet
+ * @type {$protobuf.Type & {
+ *     FieldPresence: $protobuf.Enum,
+ *     EnumType: $protobuf.Enum,
+ *     RepeatedFieldEncoding: $protobuf.Enum,
+ *     Utf8Validation: $protobuf.Enum,
+ *     MessageEncoding: $protobuf.Enum,
+ *     JsonFormat: $protobuf.Enum,
+ *     EnforceNamingStyle: $protobuf.Enum,
+ *     VisibilityFeature: $protobuf.Type
+ * }}
+ * @const
+ */
+
+/**
+ * Reflected feature set defaults.
+ * @name FeatureSetDefaults
+ * @type {$protobuf.Type & {
+ *     FeatureSetEditionDefault: $protobuf.Type
+ * }}
  * @const
- * @tstype $protobuf.Type
  */
 
 /**
  * Reflected uninterpretet option.
  * @name UninterpretedOption
- * @type {Type}
- * @property {Type} NamePart
- * @const
- * @tstype $protobuf.Type & {
+ * @type {$protobuf.Type & {
  *     NamePart: $protobuf.Type
- * }
+ * }}
+ * @const
  */
 
 /**
  * Reflected source code info.
  * @name SourceCodeInfo
- * @type {Type}
- * @property {Type} Location
- * @const
- * @tstype $protobuf.Type & {
+ * @type {$protobuf.Type & {
  *     Location: $protobuf.Type
- * }
+ * }}
+ * @const
  */
 
 /**
  * Reflected generated code info.
  * @name GeneratedCodeInfo
- * @type {Type}
- * @property {Type} Annotation
- * @const
- * @tstype $protobuf.Type & {
+ * @type {$protobuf.Type & {
  *     Annotation: $protobuf.Type
- * }
+ * }}
+ * @const
  */