@bufbuild/protobuf 2.11.0 → 2.12.1

package/dist/esm/codegenv2/types.js

@@ -11,11 +11,4 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
-class brandv2 {
-    constructor() {
-        this.v = "codegenv2";
-        this.a = false;
-        this.b = false;
-    }
-}
 export {};

package/dist/esm/descriptors.d.ts

@@ -114,7 +114,7 @@ export interface DescEnum {
      * A prefix shared by all enum values.
      * For example, `my_enum_` for `enum MyEnum {MY_ENUM_A=0; MY_ENUM_B=1;}`
      */
-    readonly sharedPrefix?: string;
+    readonly sharedPrefix?: string | undefined;
     /**
      * Marked as deprecated in the protobuf source.
      */
@@ -192,8 +192,8 @@ export interface DescMessage {
      */
     readonly oneofs: DescOneof[];
     /**
-     * Fields and oneof groups for this message, ordered by their appearance in the
-     * protobuf source.
+     * Standalone fields and oneof groups for this message, ordered by
+     * their appearance in the protobuf source.
      */
     readonly members: (DescField | DescOneof)[];
     /**
@@ -283,6 +283,13 @@ interface descFieldAndExtensionShared {
      * See https://protobuf.dev/programming-guides/field_presence/
      */
     readonly presence: SupportedFieldPresence;
+    /**
+     * Whether to reject invalid UTF-8 when reading this field from the binary
+     * wire format. Reflects the resolved `utf8_validation` feature: true for
+     * VERIFY (proto3 and editions 2023+ default), false for NONE (proto2
+     * default).
+     */
+    readonly utf8Validation: boolean;
     /**
      * The compiler-generated descriptor.
      */
@@ -620,8 +627,8 @@ export interface DescMethod {
  */
 export interface DescComments {
     readonly leadingDetached: readonly string[];
-    readonly leading?: string;
-    readonly trailing?: string;
+    readonly leading?: string | undefined;
+    readonly trailing?: string | undefined;
     readonly sourcePath: readonly number[];
 }
 export {};

package/dist/esm/equals.d.ts

@@ -32,10 +32,15 @@ interface EqualsOptions {
     unknown?: boolean;
 }
 /**
- * Compare two messages of the same type.
+ * Compare two messages of the same type for equality.
  *
- * Note that this function disregards extensions and unknown fields, and that
- * NaN is not equal NaN, following the IEEE standard.
+ * Fields are compared one by one, but only when set: a field set in one message
+ * but not the other makes them unequal, while fields set in both are compared
+ * by value. Extensions and unknown fields are disregarded by default.
+ *
+ * Float and double values are compared with IEEE semantics: NaN does not equal
+ * NaN, and -0 equals 0 (with the exception for singular fields with implicit
+ * presence: -0 is set, +0 is unset).
  */
 export declare function equals<Desc extends DescMessage>(schema: Desc, a: MessageShape<Desc>, b: MessageShape<Desc>, options?: EqualsOptions): boolean;
 export {};

package/dist/esm/equals.js

@@ -17,10 +17,15 @@ import { ScalarType, } from "./descriptors.js";
 import { anyUnpack } from "./wkt/index.js";
 import { createExtensionContainer, getExtension } from "./extensions.js";
 /**
- * Compare two messages of the same type.
+ * Compare two messages of the same type for equality.
  *
- * Note that this function disregards extensions and unknown fields, and that
- * NaN is not equal NaN, following the IEEE standard.
+ * Fields are compared one by one, but only when set: a field set in one message
+ * but not the other makes them unequal, while fields set in both are compared
+ * by value. Extensions and unknown fields are disregarded by default.
+ *
+ * Float and double values are compared with IEEE semantics: NaN does not equal
+ * NaN, and -0 equals 0 (with the exception for singular fields with implicit
+ * presence: -0 is set, +0 is unset).
  */
 export function equals(schema, a, b, options) {
     if (a.$typeName != schema.typeName || b.$typeName != schema.typeName) {

package/dist/esm/extensions.d.ts

@@ -1,4 +1,5 @@
 import type { AnyDesc, DescEnum, DescEnumValue, DescExtension, DescField, DescFile, DescMessage, DescMethod, DescOneof, DescService } from "./descriptors.js";
+import type { BinaryReadOptions } from "./from-binary.js";
 import type { ReflectMessage } from "./reflect/reflect-types.js";
 import type { Extendee, ExtensionValueShape } from "./types.js";
 import type { EnumOptions, EnumValueOptions, FieldOptions, FileOptions, MessageOptions, MethodOptions, OneofOptions, ServiceOptions } from "./wkt/gen/google/protobuf/descriptor_pb.js";
@@ -16,7 +17,7 @@ import type { EnumOptions, EnumValueOptions, FieldOptions, FileOptions, MessageO
  *
  * If the extension does not extend the given message, an error is raised.
  */
-export declare function getExtension<Desc extends DescExtension>(message: Extendee<Desc>, extension: Desc): ExtensionValueShape<Desc>;
+export declare function getExtension<Desc extends DescExtension>(message: Extendee<Desc>, extension: Desc, options?: Partial<BinaryReadOptions>): ExtensionValueShape<Desc>;
 /**
  * Set an extension value on a message. If the message already has a value for
  * this extension, the value is replaced.

package/dist/esm/extensions.js

@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 import { create } from "./create.js";
-import { readField } from "./from-binary.js";
+import { makeReadContext, readField } from "./from-binary.js";
 import { reflect } from "./reflect/reflect.js";
 import { scalarZeroValue } from "./reflect/scalar.js";
 import { writeField } from "./to-binary.js";
@@ -32,14 +32,13 @@ import { isWrapperDesc } from "./wkt/wrappers.js";
  *
  * If the extension does not extend the given message, an error is raised.
  */
-export function getExtension(message, extension) {
+export function getExtension(message, extension, options) {
     assertExtendee(extension, message);
     const ufs = filterUnknownFields(message.$unknown, extension);
     const [container, field, get] = createExtensionContainer(extension);
+    const ctx = makeReadContext(options);
     for (const uf of ufs) {
-        readField(container, new BinaryReader(uf.data), field, uf.wireType, {
-            readUnknownFields: true,
-        });
+        readField(container, new BinaryReader(uf.data), field, uf.wireType, ctx);
     }
     return get();
 }

package/dist/esm/from-binary.d.ts

@@ -13,7 +13,20 @@ export interface BinaryReadOptions {
      * For more details see https://developers.google.com/protocol-buffers/docs/proto3#unknowns
      */
     readUnknownFields: boolean;
+    /**
+     * The maximum depth of nested messages to parse. If a message nests deeper
+     * than this limit, parsing fails with an error instead of exhausting the
+     * call stack. Defaults to 100.
+     */
+    recursionLimit: number;
+}
+interface BinaryReadContext extends BinaryReadOptions {
+    depth: number;
 }
+/**
+ * @private Only exported for getExtension()
+ */
+export declare function makeReadContext(options?: Partial<BinaryReadOptions>): BinaryReadContext;
 /**
  * Parse serialized binary data.
  */
@@ -29,6 +42,7 @@ export declare function fromBinary<Desc extends DescMessage>(schema: Desc, bytes
  */
 export declare function mergeFromBinary<Desc extends DescMessage>(schema: Desc, target: MessageShape<Desc>, bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MessageShape<Desc>;
 /**
- * @private
+ * @private Only exported for getExtension()
  */
-export declare function readField(message: ReflectMessage, reader: BinaryReader, field: DescField, wireType: WireType, options: BinaryReadOptions): void;
+export declare function readField(message: ReflectMessage, reader: BinaryReader, field: DescField, wireType: WireType, ctx: BinaryReadContext): void;
+export {};

package/dist/esm/from-binary.js

@@ -16,19 +16,18 @@ import { scalarZeroValue } from "./reflect/scalar.js";
 import { reflect } from "./reflect/reflect.js";
 import { BinaryReader, WireType } from "./wire/binary-encoding.js";
 import { varint32write } from "./wire/varint.js";
-// Default options for parsing binary data.
-const readDefaults = {
-    readUnknownFields: true,
-};
-function makeReadOptions(options) {
-    return options ? Object.assign(Object.assign({}, readDefaults), options) : readDefaults;
+/**
+ * @private Only exported for getExtension()
+ */
+export function makeReadContext(options) {
+    return Object.assign(Object.assign({ readUnknownFields: true, recursionLimit: 100 }, options), { depth: 0 });
 }
 /**
  * Parse serialized binary data.
  */
 export function fromBinary(schema, bytes, options) {
     const msg = reflect(schema, undefined, false);
-    readMessage(msg, new BinaryReader(bytes), makeReadOptions(options), false, bytes.byteLength);
+    readMessage(msg, new BinaryReader(bytes), makeReadContext(options), false, bytes.byteLength);
     return msg.message;
 }
 /**
@@ -41,7 +40,7 @@ export function fromBinary(schema, bytes, options) {
  * new data.
  */
 export function mergeFromBinary(schema, target, bytes, options) {
-    readMessage(reflect(schema, target, false), new BinaryReader(bytes), makeReadOptions(options), false, bytes.byteLength);
+    readMessage(reflect(schema, target, false), new BinaryReader(bytes), makeReadContext(options), false, bytes.byteLength);
     return target;
 }
 /**
@@ -52,8 +51,11 @@ export function mergeFromBinary(schema, target, bytes, options) {
  *
  * @private
  */
-function readMessage(message, reader, options, delimited, lengthOrDelimitedFieldNo) {
+function readMessage(message, reader, ctx, delimited, lengthOrDelimitedFieldNo) {
     var _a;
+    if (++ctx.depth > ctx.recursionLimit) {
+        throw new Error(`cannot decode ${message.desc} from binary: maximum recursion depth of ${ctx.recursionLimit} reached`);
+    }
     const end = delimited ? reader.len : reader.pos + lengthOrDelimitedFieldNo;
     let fieldNo;
     let wireType;
@@ -65,13 +67,15 @@ function readMessage(message, reader, options, delimited, lengthOrDelimitedField
         }
         const field = message.findNumber(fieldNo);
         if (!field) {
-            const data = reader.skip(wireType, fieldNo);
-            if (options.readUnknownFields) {
+            // Use remaining recursion budget for skipping nested groups
+            const recursionLimit = ctx.recursionLimit - ctx.depth;
+            const data = reader.skip(wireType, fieldNo, recursionLimit);
+            if (ctx.readUnknownFields) {
                 unknownFields.push({ no: fieldNo, wireType, data });
             }
             continue;
         }
-        readField(message, reader, field, wireType, options);
+        readField(message, reader, field, wireType, ctx);
     }
     if (delimited) {
         if (wireType != WireType.EndGroup || fieldNo !== lengthOrDelimitedFieldNo) {
@@ -81,15 +85,16 @@ function readMessage(message, reader, options, delimited, lengthOrDelimitedField
     if (unknownFields.length > 0) {
         message.setUnknown(unknownFields);
     }
+    ctx.depth--;
 }
 /**
- * @private
+ * @private Only exported for getExtension()
  */
-export function readField(message, reader, field, wireType, options) {
+export function readField(message, reader, field, wireType, ctx) {
     var _a;
     switch (field.fieldKind) {
         case "scalar":
-            message.set(field, readScalar(reader, field.scalar));
+            message.set(field, readScalar(reader, field.scalar, field.utf8Validation));
             break;
         case "enum":
             const val = readScalar(reader, ScalarType.INT32);
@@ -101,7 +106,7 @@ export function readField(message, reader, field, wireType, options) {
                 if (ok) {
                     message.set(field, val);
                 }
-                else if (options.readUnknownFields) {
+                else if (ctx.readUnknownFields) {
                     const bytes = [];
                     varint32write(val, bytes);
                     const unknownFields = (_a = message.getUnknown()) !== null && _a !== void 0 ? _a : [];
@@ -115,18 +120,18 @@ export function readField(message, reader, field, wireType, options) {
             }
             break;
         case "message":
-            message.set(field, readMessageField(reader, options, field, message.get(field)));
+            message.set(field, readMessageField(reader, ctx, field, message.get(field)));
             break;
         case "list":
-            readListField(reader, wireType, message.get(field), options);
+            readListField(reader, wireType, message.get(field), ctx);
             break;
         case "map":
-            readMapEntry(reader, message.get(field), options);
+            readMapEntry(reader, message.get(field), ctx);
             break;
     }
 }
 // Read a map field, expecting key field = 1, value field = 2
-function readMapEntry(reader, map, options) {
+function readMapEntry(reader, map, ctx) {
     const field = map.field();
     let key;
     let val;
@@ -139,18 +144,18 @@ function readMapEntry(reader, map, options) {
         const [fieldNo] = reader.tag();
         switch (fieldNo) {
             case 1:
-                key = readScalar(reader, field.mapKey);
+                key = readScalar(reader, field.mapKey, field.utf8Validation);
                 break;
             case 2:
                 switch (field.mapKind) {
                     case "scalar":
-                        val = readScalar(reader, field.scalar);
+                        val = readScalar(reader, field.scalar, field.utf8Validation);
                         break;
                     case "enum":
                         val = reader.int32();
                         break;
                     case "message":
-                        val = readMessageField(reader, options, field);
+                        val = readMessageField(reader, ctx, field);
                         break;
                 }
                 break;
@@ -174,11 +179,11 @@ function readMapEntry(reader, map, options) {
     }
     map.set(key, val);
 }
-function readListField(reader, wireType, list, options) {
+function readListField(reader, wireType, list, ctx) {
     var _a;
     const field = list.field();
     if (field.listKind === "message") {
-        list.add(readMessageField(reader, options, field));
+        list.add(readMessageField(reader, ctx, field));
         return;
     }
     const scalarType = (_a = field.scalar) !== null && _a !== void 0 ? _a : ScalarType.INT32;
@@ -186,24 +191,24 @@ function readListField(reader, wireType, list, options) {
         scalarType != ScalarType.STRING &&
         scalarType != ScalarType.BYTES;
     if (!packed) {
-        list.add(readScalar(reader, scalarType));
+        list.add(readScalar(reader, scalarType, field.utf8Validation));
         return;
     }
     const e = reader.uint32() + reader.pos;
     while (reader.pos < e) {
-        list.add(readScalar(reader, scalarType));
+        list.add(readScalar(reader, scalarType, field.utf8Validation));
     }
 }
-function readMessageField(reader, options, field, mergeMessage) {
+function readMessageField(reader, ctx, field, mergeMessage) {
     const delimited = field.delimitedEncoding;
     const message = mergeMessage !== null && mergeMessage !== void 0 ? mergeMessage : reflect(field.message, undefined, false);
-    readMessage(message, reader, options, delimited, delimited ? field.number : reader.uint32());
+    readMessage(message, reader, ctx, delimited, delimited ? field.number : reader.uint32());
     return message;
 }
-function readScalar(reader, type) {
+function readScalar(reader, type, validateUtf8 = false) {
     switch (type) {
         case ScalarType.STRING:
-            return reader.string();
+            return reader.string(validateUtf8);
         case ScalarType.BOOL:
             return reader.bool();
         case ScalarType.DOUBLE:

package/dist/esm/from-json.d.ts

@@ -16,34 +16,51 @@ export interface JsonReadOptions {
      * This option is required to read `google.protobuf.Any` and extensions
      * from JSON format.
      */
-    registry?: Registry;
+    registry?: Registry | undefined;
+    /**
+     * The maximum depth of nested messages to parse. If a message nests deeper
+     * than this limit, parsing fails with an error instead of exhausting the
+     * call stack. Defaults to 100.
+     */
+    recursionLimit: number;
 }
 /**
  * Parse a message from a JSON string.
+ *
+ * Duplicate keys are rejected.
  */
 export declare function fromJsonString<Desc extends DescMessage>(schema: Desc, json: string, options?: Partial<JsonReadOptions>): MessageShape<Desc>;
 /**
- * Parse a message from a JSON string, merging fields.
+ * Parse a message from a JSON string, merging fields into the target.
  *
  * Repeated fields are appended. Map entries are added, overwriting
  * existing keys.
  *
  * If a message field is already present, it will be merged with the
  * new data.
+ *
+ * Duplicate keys in the JSON are rejected, as in `fromJsonString`.
  */
 export declare function mergeFromJsonString<Desc extends DescMessage>(schema: Desc, target: MessageShape<Desc>, json: string, options?: Partial<JsonReadOptions>): MessageShape<Desc>;
 /**
  * Parse a message from a JSON value.
+ *
+ * Duplicate keys are rejected, but a value parsed by JSON.parse has already
+ * dropped duplicates (the last one wins). Use `fromJsonString` for strict
+ * duplicate-key checking.
  */
 export declare function fromJson<Desc extends DescMessage>(schema: Desc, json: JsonValue, options?: Partial<JsonReadOptions>): MessageShape<Desc>;
 /**
- * Parse a message from a JSON value, merging fields.
+ * Parse a message from a JSON value, merging fields into the target.
  *
  * Repeated fields are appended. Map entries are added, overwriting
  * existing keys.
  *
  * If a message field is already present, it will be merged with the
  * new data.
+ *
+ * Duplicate keys are rejected as in `fromJson`; use `mergeFromJsonString`
+ * for strict checking.
  */
 export declare function mergeFromJson<Desc extends DescMessage>(schema: Desc, target: MessageShape<Desc>, json: JsonValue, options?: Partial<JsonReadOptions>): MessageShape<Desc>;
 /**