@bufbuild/protobuf 2.12.0 → 2.13.0

package/dist/{cjs/codegenv2 → commonjs}/types.js

@@ -13,10 +13,3 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 Object.defineProperty(exports, "__esModule", { value: true });
-class brandv2 {
-    constructor() {
-        this.v = "codegenv2";
-        this.a = false;
-        this.b = false;
-    }
-}

package/dist/commonjs/unknown-enum.d.ts

@@ -0,0 +1,10 @@
+import type { DescEnum } from "./descriptors.js";
+import type { UnknownEnum } from "./types.js";
+/**
+ * Open enums can contain numeric values that are not in the set of values
+ * defined by the enum.
+ *
+ * This function returns true for those values, and narrows the type to
+ * `UnknownEnum`.
+ */
+export declare function isUnknownEnum(desc: DescEnum, value: number): value is UnknownEnum;

package/dist/commonjs/unknown-enum.js

@@ -0,0 +1,26 @@
+"use strict";
+// Copyright 2021-2026 Buf Technologies, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// 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.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isUnknownEnum = isUnknownEnum;
+/**
+ * Open enums can contain numeric values that are not in the set of values
+ * defined by the enum.
+ *
+ * This function returns true for those values, and narrows the type to
+ * `UnknownEnum`.
+ */
+function isUnknownEnum(desc, value) {
+    return desc.value[value] === undefined;
+}

package/dist/{cjs → commonjs}/wire/binary-encoding.d.ts

@@ -194,9 +194,11 @@ export declare class BinaryReader {
      * Skip one element and return the skipped data.
      *
      * When skipping StartGroup, provide the tags field number to check for
-     * matching field number in the EndGroup tag.
+     * matching field number in the EndGroup tag. Recursion into nested groups
+     * is guarded by the `recursionLimit` argument: When the limit is reached,
+     * this method throws.
      */
-    skip(wireType: WireType, fieldNo?: number): Uint8Array;
+    skip(wireType: WireType, fieldNo?: number, recursionLimit?: number): Uint8Array;
     protected varint64: () => [number, number];
     /**
      * Throws error if position in byte array is out of range.

package/dist/{cjs → commonjs}/wire/binary-encoding.js

@@ -328,9 +328,11 @@ class BinaryReader {
      * Skip one element and return the skipped data.
      *
      * When skipping StartGroup, provide the tags field number to check for
-     * matching field number in the EndGroup tag.
+     * matching field number in the EndGroup tag. Recursion into nested groups
+     * is guarded by the `recursionLimit` argument: When the limit is reached,
+     * this method throws.
      */
-    skip(wireType, fieldNo) {
+    skip(wireType, fieldNo, recursionLimit = 100) {
         let start = this.pos;
         switch (wireType) {
             case WireType.Varint:
@@ -349,6 +351,9 @@ class BinaryReader {
                 this.pos += len;
                 break;
             case WireType.StartGroup:
+                if (recursionLimit <= 0) {
+                    throw new Error("maximum recursion depth reached");
+                }
                 for (;;) {
                     const [fn, wt] = this.tag();
                     if (wt === WireType.EndGroup) {
@@ -357,7 +362,7 @@ class BinaryReader {
                         }
                         break;
                     }
-                    this.skip(wt, fn);
+                    this.skip(wt, fn, recursionLimit - 1);
                 }
                 break;
             default:

package/dist/{cjs → commonjs}/wire/size-delimited.d.ts

@@ -12,6 +12,20 @@ import type { BinaryReadOptions } from "../from-binary.js";
  * For details, see https://github.com/protocolbuffers/protobuf/issues/10229
  */
 export declare function sizeDelimitedEncode<Desc extends DescMessage>(messageDesc: Desc, message: MessageShape<Desc>, options?: BinaryWriteOptions): Uint8Array;
+/**
+ * Options for parsing size-delimited messages from a stream.
+ */
+export interface SizeDelimitedDecodeOptions extends BinaryReadOptions {
+    /**
+     * Limit the size of a single message in the stream, in bytes.
+     *
+     * If a message in the stream declares a size exceeding this limit, an
+     * error is raised before the message is buffered.
+     *
+     * The default limit is 64 MiB.
+     */
+    readMaxBytes: number;
+}
 /**
  * Parse a stream of size-delimited messages.
  *
@@ -20,8 +34,12 @@ export declare function sizeDelimitedEncode<Desc extends DescMessage>(messageDes
  *
  * This size-delimited format is compatible with other implementations.
  * For details, see https://github.com/protocolbuffers/protobuf/issues/10229
+ *
+ * Messages exceeding the limit given with the option readMaxBytes raise an
+ * error. The limit is 64 MiB by default. All other options are the
+ * standard binary read options, passed through to decode each message.
  */
-export declare function sizeDelimitedDecodeStream<Desc extends DescMessage>(messageDesc: Desc, iterable: AsyncIterable<Uint8Array>, options?: BinaryReadOptions): AsyncIterableIterator<MessageShape<Desc>>;
+export declare function sizeDelimitedDecodeStream<Desc extends DescMessage>(messageDesc: Desc, iterable: AsyncIterable<Uint8Array>, options?: Partial<SizeDelimitedDecodeOptions>): AsyncIterableIterator<MessageShape<Desc>>;
 /**
  * Decodes the size from the given size-delimited message, which may be
  * incomplete.

package/dist/{cjs → commonjs}/wire/size-delimited.js

@@ -53,6 +53,34 @@ function sizeDelimitedEncode(messageDesc, message, options) {
     writer.bytes((0, to_binary_js_1.toBinary)(messageDesc, message, options));
     return writer.finish();
 }
+// Default for SizeDelimitedDecodeOptions.readMaxBytes.
+const defaultReadMaxBytes = 64 * 1024 * 1024; // 64 MiB
+/**
+ * A growable byte buffer. Used in place of a resizable ArrayBuffer, which is
+ * not widely available.
+ */
+class ByteBuffer {
+    constructor() {
+        this.buffer = new Uint8Array(0);
+        this.length = 0;
+    }
+    get byteLength() {
+        return this.length;
+    }
+    bytes() {
+        return this.buffer.subarray(0, this.length);
+    }
+    append(chunk) {
+        const newByteLength = this.length + chunk.byteLength;
+        if (newByteLength > this.buffer.byteLength) {
+            const grown = new Uint8Array(Math.max(this.buffer.byteLength * 2, newByteLength));
+            grown.set(this.buffer.subarray(0, this.length));
+            this.buffer = grown;
+        }
+        this.buffer.set(chunk, this.length);
+        this.length += chunk.byteLength;
+    }
+}
 /**
  * Parse a stream of size-delimited messages.
  *
@@ -61,43 +89,53 @@ function sizeDelimitedEncode(messageDesc, message, options) {
  *
  * This size-delimited format is compatible with other implementations.
  * For details, see https://github.com/protocolbuffers/protobuf/issues/10229
+ *
+ * Messages exceeding the limit given with the option readMaxBytes raise an
+ * error. The limit is 64 MiB by default. All other options are the
+ * standard binary read options, passed through to decode each message.
  */
 function sizeDelimitedDecodeStream(messageDesc, iterable, options) {
     return __asyncGenerator(this, arguments, function* sizeDelimitedDecodeStream_1() {
         var _a, e_1, _b, _c;
-        // append chunk to buffer, returning updated buffer
-        function append(buffer, chunk) {
-            const n = new Uint8Array(buffer.byteLength + chunk.byteLength);
-            n.set(buffer);
-            n.set(chunk, buffer.length);
-            return n;
-        }
-        let buffer = new Uint8Array(0);
+        var _d;
+        const readMaxBytes = (_d = options === null || options === void 0 ? void 0 : options.readMaxBytes) !== null && _d !== void 0 ? _d : defaultReadMaxBytes;
+        let buffer = new ByteBuffer();
         try {
-            for (var _d = true, iterable_1 = __asyncValues(iterable), iterable_1_1; iterable_1_1 = yield __await(iterable_1.next()), _a = iterable_1_1.done, !_a; _d = true) {
+            for (var _e = true, iterable_1 = __asyncValues(iterable), iterable_1_1; iterable_1_1 = yield __await(iterable_1.next()), _a = iterable_1_1.done, !_a; _e = true) {
                 _c = iterable_1_1.value;
-                _d = false;
+                _e = false;
                 const chunk = _c;
-                buffer = append(buffer, chunk);
+                buffer.append(chunk);
+                const bytes = buffer.bytes();
+                let offset = 0;
                 for (;;) {
-                    const size = sizeDelimitedPeek(buffer);
+                    const size = sizeDelimitedPeek(bytes.subarray(offset));
                     if (size.eof) {
                         // size is incomplete, buffer more data
                         break;
                     }
-                    if (size.offset + size.size > buffer.byteLength) {
+                    if (size.size > readMaxBytes) {
+                        throw new Error(`message size ${size.size} is larger than configured readMaxBytes ${readMaxBytes}`);
+                    }
+                    const messageStart = offset + size.offset;
+                    const messageEnd = messageStart + size.size;
+                    if (messageEnd > bytes.byteLength) {
                         // message is incomplete, buffer more data
                         break;
                     }
-                    yield yield __await((0, from_binary_js_1.fromBinary)(messageDesc, buffer.subarray(size.offset, size.offset + size.size), options));
-                    buffer = buffer.subarray(size.offset + size.size);
+                    yield yield __await((0, from_binary_js_1.fromBinary)(messageDesc, bytes.subarray(messageStart, messageEnd), options));
+                    offset = messageEnd;
+                }
+                if (offset > 0) {
+                    buffer = new ByteBuffer();
+                    buffer.append(bytes.subarray(offset));
                 }
             }
         }
         catch (e_1_1) { e_1 = { error: e_1_1 }; }
         finally {
             try {
-                if (!_d && !_a && (_b = iterable_1.return)) yield __await(_b.call(iterable_1));
+                if (!_e && !_a && (_b = iterable_1.return)) yield __await(_b.call(iterable_1));
             }
             finally { if (e_1) throw e_1.error; }
         }

package/dist/esm/codegenv1/boot.d.ts

@@ -0,0 +1 @@
+export { boot } from "../codegenv2/boot.js";

package/dist/esm/codegenv1/boot.js

@@ -0,0 +1,14 @@
+// Copyright 2021-2026 Buf Technologies, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// 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.
+export { boot } from "../codegenv2/boot.js";

package/dist/esm/codegenv1/symbols.d.ts

@@ -132,4 +132,9 @@ export declare const symbols: {
         readonly bootstrapWktFrom: "../../json-value.js";
         readonly from: "@bufbuild/protobuf";
     };
+    readonly UnknownEnum: {
+        readonly typeOnly: true;
+        readonly bootstrapWktFrom: "../../types.js";
+        readonly from: "@bufbuild/protobuf";
+    };
 };

package/dist/esm/codegenv1/types.d.ts

@@ -56,11 +56,15 @@ export type GenService<RuntimeShape extends GenServiceMethods> = Omit<DescServic
  * @private
  */
 export type GenServiceMethods = Record<string, Pick<DescMethod, "input" | "output" | "methodKind">>;
-declare class brandv1<A, B = unknown> {
-    protected v: "codegenv1";
-    protected a: A | boolean;
-    protected b: B | boolean;
-}
+type brandv1<A, B = unknown> = {
+    /**
+     * @internal
+     */
+    readonly $codegenv1: {
+        a: A;
+        b: B;
+    };
+};
 /**
  * Union of the property names of all fields, including oneof members.
  * For an anonymous message (no generated message shape), it's simply a string.

package/dist/esm/codegenv1/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 brandv1 {
-    constructor() {
-        this.v = "codegenv1";
-        this.a = false;
-        this.b = false;
-    }
-}
 export {};

package/dist/esm/codegenv2/enum.d.ts

@@ -9,10 +9,21 @@ import type { JsonValue } from "../json-value.js";
 export declare function enumDesc<Shape extends number, JsonType extends JsonValue = JsonValue>(file: DescFile, path: number, ...paths: number[]): GenEnum<Shape, JsonType>;
 /**
  * Construct a TypeScript enum object at runtime from a descriptor.
+ *
+ * The returned object is identical to a transpiled TS enum and includes the
+ * reverse mapping, see https://www.typescriptlang.org/docs/handbook/enums.html#reverse-mappings
  */
-export declare function tsEnum(desc: DescEnum): enumObject;
-type enumObject = {
+export declare function tsEnum(desc: DescEnum): {
     [key: number]: string;
-    [k: string]: number | string;
+    [k: string]: string | number;
+};
+/**
+ * Construct an object enum at runtime from a descriptor.
+ *
+ * The returned object is a record of enum value name to integer value. It's
+ * a subset of transpiled TS enums - it does not include the reverse mapping,
+ * and only supports lookup by value name.
+ */
+export declare function objEnum(desc: DescEnum): {
+    [key: string]: number;
 };
-export {};

package/dist/esm/codegenv2/enum.js

@@ -25,6 +25,9 @@ export function enumDesc(file, path, ...paths) {
 }
 /**
  * Construct a TypeScript enum object at runtime from a descriptor.
+ *
+ * The returned object is identical to a transpiled TS enum and includes the
+ * reverse mapping, see https://www.typescriptlang.org/docs/handbook/enums.html#reverse-mappings
  */
 export function tsEnum(desc) {
     const enumObject = {};
@@ -34,3 +37,17 @@ export function tsEnum(desc) {
     }
     return enumObject;
 }
+/**
+ * Construct an object enum at runtime from a descriptor.
+ *
+ * The returned object is a record of enum value name to integer value. It's
+ * a subset of transpiled TS enums - it does not include the reverse mapping,
+ * and only supports lookup by value name.
+ */
+export function objEnum(desc) {
+    const enumObject = {};
+    for (const value of desc.values) {
+        enumObject[value.localName] = value.number;
+    }
+    return enumObject;
+}

package/dist/esm/codegenv2/symbols.d.ts

@@ -70,6 +70,11 @@ export declare const symbols: {
         readonly bootstrapWktFrom: "../../json-value.js";
         readonly from: "@bufbuild/protobuf";
     };
+    readonly UnknownEnum: {
+        readonly typeOnly: true;
+        readonly bootstrapWktFrom: "../../types.js";
+        readonly from: "@bufbuild/protobuf";
+    };
     readonly codegen: {
         readonly boot: {
             readonly typeOnly: false;
@@ -106,6 +111,11 @@ export declare const symbols: {
             readonly bootstrapWktFrom: "../../codegenv2/enum.js";
             readonly from: string;
         };
+        readonly objEnum: {
+            readonly typeOnly: false;
+            readonly bootstrapWktFrom: "../../codegenv2/enum.js";
+            readonly from: string;
+        };
         readonly GenFile: {
             readonly typeOnly: true;
             readonly bootstrapWktFrom: "../../codegenv2/types.js";

package/dist/esm/codegenv2/symbols.js

@@ -52,6 +52,7 @@ export const symbols = {
     protoInt64: { typeOnly: false, bootstrapWktFrom: "../../proto-int64.js", from: packageName },
     JsonValue: { typeOnly: true, bootstrapWktFrom: "../../json-value.js", from: packageName },
     JsonObject: { typeOnly: true, bootstrapWktFrom: "../../json-value.js", from: packageName },
+    UnknownEnum: { typeOnly: true, bootstrapWktFrom: "../../types.js", from: packageName },
     codegen: {
         boot: { typeOnly: false, bootstrapWktFrom: "../../codegenv2/boot.js", from: packageName + "/codegenv2" },
         fileDesc: { typeOnly: false, bootstrapWktFrom: "../../codegenv2/file.js", from: packageName + "/codegenv2" },
@@ -60,6 +61,7 @@ export const symbols = {
         messageDesc: { typeOnly: false, bootstrapWktFrom: "../../codegenv2/message.js", from: packageName + "/codegenv2" },
         serviceDesc: { typeOnly: false, bootstrapWktFrom: "../../codegenv2/service.js", from: packageName + "/codegenv2" },
         tsEnum: { typeOnly: false, bootstrapWktFrom: "../../codegenv2/enum.js", from: packageName + "/codegenv2" },
+        objEnum: { typeOnly: false, bootstrapWktFrom: "../../codegenv2/enum.js", from: packageName + "/codegenv2" },
         GenFile: { typeOnly: true, bootstrapWktFrom: "../../codegenv2/types.js", from: packageName + "/codegenv2" },
         GenEnum: { typeOnly: true, bootstrapWktFrom: "../../codegenv2/types.js", from: packageName + "/codegenv2" },
         GenExtension: { typeOnly: true, bootstrapWktFrom: "../../codegenv2/types.js", from: packageName + "/codegenv2" },

package/dist/esm/codegenv2/types.d.ts

@@ -62,11 +62,15 @@ export type GenService<RuntimeShape extends GenServiceMethods> = Omit<DescServic
  * @private
  */
 export type GenServiceMethods = Record<string, Pick<DescMethod, "input" | "output" | "methodKind">>;
-declare class brandv2<A, B = unknown> {
-    protected v: "codegenv2";
-    protected a: A | boolean;
-    protected b: B | boolean;
-}
+type brandv2<A, B = unknown> = {
+    /**
+     * @internal
+     */
+    readonly $codegenv2: {
+        a: A;
+        b: B;
+    };
+};
 /**
  * Union of the property names of all fields, including oneof members.
  * For an anonymous message (no generated message shape), it's simply a string.

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/create.js

@@ -17,11 +17,11 @@ import { scalarZeroValue } from "./reflect/scalar.js";
 import { isObject } from "./reflect/guard.js";
 import { unsafeGet, unsafeOneofCase, unsafeSet } from "./reflect/unsafe.js";
 import { isWrapperDesc } from "./wkt/wrappers.js";
-// bootstrap-inject google.protobuf.Edition.EDITION_PROTO3: const $name: Edition.$localName = $number;
+// bootstrap-inject google.protobuf.Edition.EDITION_PROTO3: const $name = $number;
 const EDITION_PROTO3 = 999;
-// bootstrap-inject google.protobuf.Edition.EDITION_PROTO2: const $name: Edition.$localName = $number;
+// bootstrap-inject google.protobuf.Edition.EDITION_PROTO2: const $name = $number;
 const EDITION_PROTO2 = 998;
-// bootstrap-inject google.protobuf.FeatureSet.FieldPresence.IMPLICIT: const $name: FeatureSet_FieldPresence.$localName = $number;
+// bootstrap-inject google.protobuf.FeatureSet.FieldPresence.IMPLICIT: const $name = $number;
 const IMPLICIT = 2;
 /**
  * Create a new message instance.

package/dist/esm/descriptors.d.ts

@@ -1,7 +1,7 @@
 import type { DescriptorProto, Edition, EnumDescriptorProto, EnumValueDescriptorProto, FeatureSet_FieldPresence, FieldDescriptorProto, FileDescriptorProto, MethodDescriptorProto, MethodOptions_IdempotencyLevel, OneofDescriptorProto, ServiceDescriptorProto } from "./wkt/gen/google/protobuf/descriptor_pb.js";
 import type { ScalarValue } from "./reflect/scalar.js";
-export type SupportedEdition = Extract<Edition, Edition.EDITION_PROTO2 | Edition.EDITION_PROTO3 | Edition.EDITION_2023 | Edition.EDITION_2024>;
-type SupportedFieldPresence = Extract<FeatureSet_FieldPresence, FeatureSet_FieldPresence.EXPLICIT | FeatureSet_FieldPresence.IMPLICIT | FeatureSet_FieldPresence.LEGACY_REQUIRED>;
+export type SupportedEdition = Extract<Edition, typeof Edition.EDITION_PROTO2 | typeof Edition.EDITION_PROTO3 | typeof Edition.EDITION_2023 | typeof Edition.EDITION_2024>;
+type SupportedFieldPresence = Extract<FeatureSet_FieldPresence, typeof FeatureSet_FieldPresence.EXPLICIT | typeof FeatureSet_FieldPresence.IMPLICIT | typeof FeatureSet_FieldPresence.LEGACY_REQUIRED>;
 /**
  * Scalar value types. This is a subset of field types declared by protobuf
  * enum google.protobuf.FieldDescriptorProto.Type The types GROUP and MESSAGE

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 {};