@bufbuild/protobuf 1.7.2 → 1.8.0

package/dist/esm/google/protobuf/descriptor_pb.d.ts

@@ -37,6 +37,10 @@ export declare enum Edition {
      * @generated from enum value: EDITION_2023 = 1000;
      */
     EDITION_2023 = 1000,
+    /**
+     * @generated from enum value: EDITION_2024 = 1001;
+     */
+    EDITION_2024 = 1001,
     /**
      * Placeholder editions for testing feature resolution.  These should not be
      * used or relyed on outside of tests.
@@ -59,7 +63,15 @@ export declare enum Edition {
     /**
      * @generated from enum value: EDITION_99999_TEST_ONLY = 99999;
      */
-    EDITION_99999_TEST_ONLY = 99999
+    EDITION_99999_TEST_ONLY = 99999,
+    /**
+     * Placeholder for specifying unbounded edition support.  This should only
+     * ever be used by plugins that can expect to never require any changes to
+     * support a new edition.
+     *
+     * @generated from enum value: EDITION_MAX = 2147483647;
+     */
+    EDITION_MAX = 2147483647
 }
 /**
  * The protocol compiler can output a FileDescriptorSet containing the .proto
@@ -471,12 +483,12 @@ export declare class FieldDescriptorProto extends Message<FieldDescriptorProto>
      * If true, this is a proto3 "optional". When a proto3 field is optional, it
      * tracks presence regardless of field type.
      *
-     * When proto3_optional is true, this field must be belong to a oneof to
-     * signal to old proto3 clients that presence is tracked for this field. This
-     * oneof is known as a "synthetic" oneof, and this field must be its sole
-     * member (each proto3 optional field gets its own synthetic oneof). Synthetic
-     * oneofs exist in the descriptor only, and do not generate any API. Synthetic
-     * oneofs must be ordered after all "real" oneofs.
+     * When proto3_optional is true, this field must belong to a oneof to signal
+     * to old proto3 clients that presence is tracked for this field. This oneof
+     * is known as a "synthetic" oneof, and this field must be its sole member
+     * (each proto3 optional field gets its own synthetic oneof). Synthetic oneofs
+     * exist in the descriptor only, and do not generate any API. Synthetic oneofs
+     * must be ordered after all "real" oneofs.
      *
      * For message fields, proto3_optional doesn't create any semantic change,
      * since non-repeated message fields always track presence. However it still
@@ -911,10 +923,6 @@ export declare class FileOptions extends Message<FileOptions> {
      * @generated from field: optional bool py_generic_services = 18 [default = false];
      */
     pyGenericServices?: boolean;
-    /**
-     * @generated from field: optional bool php_generic_services = 42 [default = false];
-     */
-    phpGenericServices?: boolean;
     /**
      * Is this file deprecated?
      * Depending on the target platform, this can emit Deprecated annotations
@@ -1078,10 +1086,6 @@ export declare class MessageOptions extends Message<MessageOptions> {
      */
     deprecated?: boolean;
     /**
-     * NOTE: Do not set the option in .proto files. Always use the maps syntax
-     * instead. The option should only be implicitly set by the proto compiler
-     * parser.
-     *
      * Whether the message is an automatically generated map entry type for the
      * maps field.
      *
@@ -1100,6 +1104,10 @@ export declare class MessageOptions extends Message<MessageOptions> {
      * The reflection APIs in such implementations still need to work as
      * if the field is a repeated message field.
      *
+     * NOTE: Do not set the option in .proto files. Always use the maps syntax
+     * instead. The option should only be implicitly set by the proto compiler
+     * parser.
+     *
      * @generated from field: optional bool map_entry = 7;
      */
     mapEntry?: boolean;
@@ -1201,19 +1209,11 @@ export declare class FieldOptions extends Message<FieldOptions> {
      * call from multiple threads concurrently, while non-const methods continue
      * to require exclusive access.
      *
-     * Note that implementations may choose not to check required fields within
-     * a lazy sub-message.  That is, calling IsInitialized() on the outer message
-     * may return true even if the inner message has missing required fields.
-     * This is necessary because otherwise the inner message would have to be
-     * parsed in order to perform the check, defeating the purpose of lazy
-     * parsing.  An implementation which chooses not to check required fields
-     * must be consistent about it.  That is, for any particular sub-message, the
-     * implementation must either *always* check its required fields, or *never*
-     * check its required fields, regardless of whether or not the message has
-     * been parsed.
-     *
-     * As of May 2022, lazy verifies the contents of the byte stream during
-     * parsing.  An invalid byte stream will cause the overall parsing to fail.
+     * Note that lazy message fields are still eagerly verified to check
+     * ill-formed wireformat or missing required fields. Calling IsInitialized()
+     * on the outer message would fail if the inner message has missing required
+     * fields. Failed verification would result in parsing failure (except when
+     * uninitialized messages are acceptable).
      *
      * @generated from field: optional bool lazy = 5 [default = false];
      */
@@ -1827,13 +1827,13 @@ export declare enum FeatureSet_Utf8Validation {
      */
     UTF8_VALIDATION_UNKNOWN = 0,
     /**
-     * @generated from enum value: NONE = 1;
+     * @generated from enum value: VERIFY = 2;
      */
-    NONE = 1,
+    VERIFY = 2,
     /**
-     * @generated from enum value: VERIFY = 2;
+     * @generated from enum value: NONE = 3;
      */
-    VERIFY = 2
+    NONE = 3
 }
 /**
  * @generated from enum google.protobuf.FeatureSet.MessageEncoding
@@ -2004,7 +2004,7 @@ export declare class SourceCodeInfo_Location extends Message<SourceCodeInfo_Loca
      * location.
      *
      * Each element is a field number or an index.  They form a path from
-     * the root FileDescriptorProto to the place where the definition occurs.
+     * the root FileDescriptorProto to the place where the definition appears.
      * For example, this path:
      *   [ 4, 3, 2, 7, 1 ]
      * refers to:

package/dist/esm/google/protobuf/descriptor_pb.js

@@ -18,7 +18,7 @@
 // The messages in this file describe the definitions found in .proto files.
 // A valid .proto file can be translated directly to a FileDescriptorProto
 // without any other information (e.g. without reading its imports).
-// @generated by protoc-gen-es v1.7.2 with parameter "bootstrap_wkt=true,ts_nocheck=false,target=ts"
+// @generated by protoc-gen-es v1.8.0 with parameter "bootstrap_wkt=true,ts_nocheck=false,target=ts"
 // @generated from file google/protobuf/descriptor.proto (package google.protobuf, syntax proto2)
 /* eslint-disable */
 import { proto2 } from "../../proto2.js";
@@ -57,6 +57,10 @@ export var Edition;
      * @generated from enum value: EDITION_2023 = 1000;
      */
     Edition[Edition["EDITION_2023"] = 1000] = "EDITION_2023";
+    /**
+     * @generated from enum value: EDITION_2024 = 1001;
+     */
+    Edition[Edition["EDITION_2024"] = 1001] = "EDITION_2024";
     /**
      * Placeholder editions for testing feature resolution.  These should not be
      * used or relyed on outside of tests.
@@ -80,6 +84,14 @@ export var Edition;
      * @generated from enum value: EDITION_99999_TEST_ONLY = 99999;
      */
     Edition[Edition["EDITION_99999_TEST_ONLY"] = 99999] = "EDITION_99999_TEST_ONLY";
+    /**
+     * Placeholder for specifying unbounded edition support.  This should only
+     * ever be used by plugins that can expect to never require any changes to
+     * support a new edition.
+     *
+     * @generated from enum value: EDITION_MAX = 2147483647;
+     */
+    Edition[Edition["EDITION_MAX"] = 2147483647] = "EDITION_MAX";
 })(Edition || (Edition = {}));
 // Retrieve enum metadata with: proto2.getEnumType(Edition)
 proto2.util.setEnumType(Edition, "google.protobuf.Edition", [
@@ -87,11 +99,13 @@ proto2.util.setEnumType(Edition, "google.protobuf.Edition", [
     { no: 998, name: "EDITION_PROTO2" },
     { no: 999, name: "EDITION_PROTO3" },
     { no: 1000, name: "EDITION_2023" },
+    { no: 1001, name: "EDITION_2024" },
     { no: 1, name: "EDITION_1_TEST_ONLY" },
     { no: 2, name: "EDITION_2_TEST_ONLY" },
     { no: 99997, name: "EDITION_99997_TEST_ONLY" },
     { no: 99998, name: "EDITION_99998_TEST_ONLY" },
     { no: 99999, name: "EDITION_99999_TEST_ONLY" },
+    { no: 2147483647, name: "EDITION_MAX" },
 ]);
 /**
  * The protocol compiler can output a FileDescriptorSet containing the .proto
@@ -872,7 +886,6 @@ FileOptions.fields = proto2.util.newFieldList(() => [
     { no: 16, name: "cc_generic_services", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true, default: false },
     { no: 17, name: "java_generic_services", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true, default: false },
     { no: 18, name: "py_generic_services", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true, default: false },
-    { no: 42, name: "php_generic_services", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true, default: false },
     { no: 23, name: "deprecated", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true, default: false },
     { no: 31, name: "cc_enable_arenas", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true, default: true },
     { no: 36, name: "objc_class_prefix", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
@@ -1469,8 +1482,8 @@ export class UninterpretedOption_NamePart extends Message {
 UninterpretedOption_NamePart.runtime = proto2;
 UninterpretedOption_NamePart.typeName = "google.protobuf.UninterpretedOption.NamePart";
 UninterpretedOption_NamePart.fields = proto2.util.newFieldList(() => [
-    { no: 1, name: "name_part", kind: "scalar", T: 9 /* ScalarType.STRING */ },
-    { no: 2, name: "is_extension", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
+    { no: 1, name: "name_part", kind: "scalar", T: 9 /* ScalarType.STRING */, req: true },
+    { no: 2, name: "is_extension", kind: "scalar", T: 8 /* ScalarType.BOOL */, req: true },
 ]);
 /**
  * TODO Enums in C++ gencode (and potentially other languages) are
@@ -1596,20 +1609,20 @@ export var FeatureSet_Utf8Validation;
      * @generated from enum value: UTF8_VALIDATION_UNKNOWN = 0;
      */
     FeatureSet_Utf8Validation[FeatureSet_Utf8Validation["UTF8_VALIDATION_UNKNOWN"] = 0] = "UTF8_VALIDATION_UNKNOWN";
-    /**
-     * @generated from enum value: NONE = 1;
-     */
-    FeatureSet_Utf8Validation[FeatureSet_Utf8Validation["NONE"] = 1] = "NONE";
     /**
      * @generated from enum value: VERIFY = 2;
      */
     FeatureSet_Utf8Validation[FeatureSet_Utf8Validation["VERIFY"] = 2] = "VERIFY";
+    /**
+     * @generated from enum value: NONE = 3;
+     */
+    FeatureSet_Utf8Validation[FeatureSet_Utf8Validation["NONE"] = 3] = "NONE";
 })(FeatureSet_Utf8Validation || (FeatureSet_Utf8Validation = {}));
 // Retrieve enum metadata with: proto2.getEnumType(FeatureSet_Utf8Validation)
 proto2.util.setEnumType(FeatureSet_Utf8Validation, "google.protobuf.FeatureSet.Utf8Validation", [
     { no: 0, name: "UTF8_VALIDATION_UNKNOWN" },
-    { no: 1, name: "NONE" },
     { no: 2, name: "VERIFY" },
+    { no: 3, name: "NONE" },
 ]);
 /**
  * @generated from enum google.protobuf.FeatureSet.MessageEncoding
@@ -1816,7 +1829,7 @@ export class SourceCodeInfo_Location extends Message {
          * location.
          *
          * Each element is a field number or an index.  They form a path from
-         * the root FileDescriptorProto to the place where the definition occurs.
+         * the root FileDescriptorProto to the place where the definition appears.
          * For example, this path:
          *   [ 4, 3, 2, 7, 1 ]
          * refers to:

package/dist/esm/google/protobuf/struct_pb.js

@@ -11,7 +11,7 @@
 // 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.
-// @generated by protoc-gen-es v1.7.2 with parameter "bootstrap_wkt=true,ts_nocheck=false,target=ts"
+// @generated by protoc-gen-es v1.8.0 with parameter "bootstrap_wkt=true,ts_nocheck=false,target=ts"
 // @generated from file google/protobuf/struct.proto (package google.protobuf, syntax proto3)
 /* eslint-disable */
 import { proto3 } from "../../proto3.js";

package/dist/esm/google/protobuf/type_pb.js

@@ -11,7 +11,7 @@
 // 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.
-// @generated by protoc-gen-es v1.7.2 with parameter "bootstrap_wkt=true,ts_nocheck=false,target=ts"
+// @generated by protoc-gen-es v1.8.0 with parameter "bootstrap_wkt=true,ts_nocheck=false,target=ts"
 // @generated from file google/protobuf/type.proto (package google.protobuf, syntax proto3)
 /* eslint-disable */
 import { proto3 } from "../../proto3.js";

package/dist/esm/google/protobuf/wrappers_pb.js

@@ -13,7 +13,7 @@
 // limitations under the License.
 import { Message } from "../../message.js";
 import { proto3 } from "../../proto3.js";
-import { ScalarType } from "../../field.js";
+import { ScalarType } from "../../scalar.js";
 import { protoInt64 } from "../../proto-int64.js";
 /**
  * Wrapper message for `double`.

package/dist/esm/index.d.ts

@@ -7,9 +7,11 @@ export { protoDelimited } from "./proto-delimited.js";
 export { codegenInfo } from "./codegen-info.js";
 export { Message } from "./message.js";
 export type { AnyMessage, PartialMessage, PlainMessage } from "./message.js";
+export { isMessage } from "./is-message.js";
 export type { FieldInfo } from "./field.js";
 export type { FieldList } from "./field-list.js";
-export { ScalarType, LongType } from "./field.js";
+export { LongType, ScalarType } from "./scalar.js";
+export type { ScalarValue } from "./scalar.js";
 export type { MessageType } from "./message-type.js";
 export type { EnumType, EnumValueInfo } from "./enum.js";
 export type { Extension } from "./extension.js";

package/dist/esm/index.js

@@ -19,7 +19,8 @@ export { protoBase64 } from "./proto-base64.js";
 export { protoDelimited } from "./proto-delimited.js";
 export { codegenInfo } from "./codegen-info.js";
 export { Message } from "./message.js";
-export { ScalarType, LongType } from "./field.js";
+export { isMessage } from "./is-message.js";
+export { LongType, ScalarType } from "./scalar.js";
 export { getExtension, setExtension, hasExtension, clearExtension, } from "./extension-accessor.js";
 export { MethodKind, MethodIdempotency } from "./service-type.js";
 export { WireType, BinaryWriter, BinaryReader } from "./binary-encoding.js";

package/dist/esm/is-message.d.ts

@@ -0,0 +1,22 @@
+import type { MessageType } from "./message-type.js";
+import type { AnyMessage } from "./message.js";
+import { Message } from "./message.js";
+/**
+ * Check whether the given object is any subtype of Message or is a specific
+ * Message by passing the type.
+ *
+ * Just like `instanceof`, `isMessage` narrows the type. The advantage of
+ * `isMessage` is that it compares identity by the message type name, not by
+ * class identity. This makes it robust against the dual package hazard and
+ * similar situations, where the same message is duplicated.
+ *
+ * This function is _mostly_ equivalent to the `instanceof` operator. For
+ * example, `isMessage(foo, MyMessage)` is the same as `foo instanceof MyMessage`,
+ * and `isMessage(foo)` is the same as `foo instanceof Message`. In most cases,
+ * `isMessage` should be preferred over `instanceof`.
+ *
+ * However, due to the fact that `isMessage` does not use class identity, there
+ * are subtle differences between this function and `instanceof`. Notably,
+ * calling `isMessage` on an explicit type of Message will return false.
+ */
+export declare function isMessage<T extends Message<T> = AnyMessage>(arg: unknown, type?: MessageType<T>): arg is T;

package/dist/esm/is-message.js

@@ -0,0 +1,48 @@
+// Copyright 2021-2024 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.
+import { Message } from "./message.js";
+/**
+ * Check whether the given object is any subtype of Message or is a specific
+ * Message by passing the type.
+ *
+ * Just like `instanceof`, `isMessage` narrows the type. The advantage of
+ * `isMessage` is that it compares identity by the message type name, not by
+ * class identity. This makes it robust against the dual package hazard and
+ * similar situations, where the same message is duplicated.
+ *
+ * This function is _mostly_ equivalent to the `instanceof` operator. For
+ * example, `isMessage(foo, MyMessage)` is the same as `foo instanceof MyMessage`,
+ * and `isMessage(foo)` is the same as `foo instanceof Message`. In most cases,
+ * `isMessage` should be preferred over `instanceof`.
+ *
+ * However, due to the fact that `isMessage` does not use class identity, there
+ * are subtle differences between this function and `instanceof`. Notably,
+ * calling `isMessage` on an explicit type of Message will return false.
+ */
+export function isMessage(arg, type) {
+    if (arg === null || typeof arg != "object") {
+        return false;
+    }
+    if (!Object.getOwnPropertyNames(Message.prototype).every((m) => m in arg && typeof arg[m] == "function")) {
+        return false;
+    }
+    const actualType = arg.getType();
+    if (actualType === null ||
+        typeof actualType != "function" ||
+        !("typeName" in actualType) ||
+        typeof actualType.typeName != "string") {
+        return false;
+    }
+    return type === undefined ? true : actualType.typeName == type.typeName;
+}

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

@@ -1,7 +1,6 @@
 import type { Message } from "./message.js";
 import type { MessageType } from "./message-type.js";
-import type { ScalarType } from "./field.js";
-import { LongType } from "./field.js";
+import type { ScalarType, LongType } from "./scalar.js";
 import type { IExtensionRegistry, IMessageTypeRegistry } from "./type-registry.js";
 /**
  * JsonFormat is the contract for serializing messages to and from JSON.

package/dist/esm/json-format.js

@@ -11,4 +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.
-import { LongType } from "./field.js";
+export {};

package/dist/esm/private/binary-format.d.ts

@@ -0,0 +1,7 @@
+import type { IBinaryWriter } from "../binary-encoding.js";
+import type { BinaryFormat, BinaryWriteOptions } from "../binary-format.js";
+import type { FieldInfo } from "../field.js";
+export declare function makeBinaryFormat(): BinaryFormat;
+export declare function writeMapEntry(writer: IBinaryWriter, options: BinaryWriteOptions, field: FieldInfo & {
+    kind: "map";
+}, key: string, value: any): void;

package/dist/esm/private/{binary-format-common.js → binary-format.js}

@@ -13,11 +13,13 @@
 // limitations under the License.
 import { BinaryReader, BinaryWriter, WireType } from "../binary-encoding.js";
 import { Message } from "../message.js";
-import { LongType, ScalarType } from "../field.js";
 import { wrapField } from "./field-wrapper.js";
-import { scalarDefaultValue, scalarTypeInfo } from "./scalars.js";
+import { scalarZeroValue } from "./scalars.js";
 import { assert } from "./assert.js";
-/* eslint-disable @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unnecessary-condition, no-case-declarations, prefer-const */
+import { isFieldSet } from "./reflect.js";
+import { LongType, ScalarType } from "../scalar.js";
+import { isMessage } from "../is-message.js";
+/* eslint-disable prefer-const,no-case-declarations,@typescript-eslint/no-explicit-any,@typescript-eslint/no-unsafe-argument,@typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-return */
 const unknownFieldsSymbol = Symbol("@bufbuild/protobuf/unknown-fields");
 // Default options for parsing binary data.
 const readDefaults = {
@@ -35,7 +37,7 @@ function makeReadOptions(options) {
 function makeWriteOptions(options) {
     return options ? Object.assign(Object.assign({}, writeDefaults), options) : writeDefaults;
 }
-export function makeBinaryFormatCommon() {
+export function makeBinaryFormat() {
     return {
         makeReadOptions,
         makeWriteOptions,
@@ -90,6 +92,35 @@ export function makeBinaryFormatCommon() {
             }
         },
         readField,
+        writeMessage(message, writer, options) {
+            const type = message.getType();
+            for (const field of type.fields.byNumber()) {
+                if (!isFieldSet(field, message)) {
+                    if (field.req) {
+                        throw new Error(`cannot encode field ${type.typeName}.${field.name} to binary: required field not set`);
+                    }
+                    continue;
+                }
+                const value = field.oneof
+                    ? message[field.oneof.localName].value
+                    : message[field.localName];
+                writeField(field, value, writer, options);
+            }
+            if (options.writeUnknownFields) {
+                this.writeUnknownFields(message, writer);
+            }
+            return writer;
+        },
+        writeField(field, value, writer, options) {
+            // The behavior of our internal function has changed, it does no longer
+            // accept `undefined` values for singular scalar and map.
+            // For backwards-compatibility, we support the old form that is part of
+            // the public API through the interface BinaryFormat.
+            if (value === undefined) {
+                return undefined;
+            }
+            writeField(field, value, writer, options);
+        },
     };
 }
 function readField(target, // eslint-disable-line @typescript-eslint/no-explicit-any -- `any` is the best choice for dynamic access
@@ -138,7 +169,7 @@ reader, field, wireType, options) {
                 target[localName].push(readMessageField(reader, new messageType(), options, field));
             }
             else {
-                if (target[localName] instanceof Message) {
+                if (isMessage(target[localName])) {
                     readMessageField(reader, target[localName], options, field);
                 }
                 else {
@@ -161,7 +192,7 @@ reader, field, wireType, options) {
 function readMessageField(reader, message, options, field) {
     const format = message.getType().runtime.bin;
     const delimited = field === null || field === void 0 ? void 0 : field.delimited;
-    format.readMessage(message, reader, delimited ? field === null || field === void 0 ? void 0 : field.no : reader.uint32(), // eslint-disable-line @typescript-eslint/strict-boolean-expressions
+    format.readMessage(message, reader, delimited ? field.no : reader.uint32(), // eslint-disable-line @typescript-eslint/strict-boolean-expressions
     options, delimited);
     return message;
 }
@@ -170,7 +201,7 @@ function readMapEntry(field, reader, options) {
     const length = reader.uint32(), end = reader.pos + length;
     let key, val;
     while (reader.pos < end) {
-        let [fieldNo] = reader.tag();
+        const [fieldNo] = reader.tag();
         switch (fieldNo) {
             case 1:
                 key = readScalar(reader, field.K);
@@ -191,11 +222,7 @@ function readMapEntry(field, reader, options) {
         }
     }
     if (key === undefined) {
-        let keyRaw = scalarDefaultValue(field.K, LongType.BIGINT);
-        key =
-            field.K == ScalarType.BOOL
-                ? keyRaw.toString()
-                : keyRaw;
+        key = scalarZeroValue(field.K, LongType.BIGINT);
     }
     if (typeof key != "string" && typeof key != "number") {
         key = key.toString();
@@ -203,10 +230,10 @@ function readMapEntry(field, reader, options) {
     if (val === undefined) {
         switch (field.V.kind) {
             case "scalar":
-                val = scalarDefaultValue(field.V.T, LongType.BIGINT);
+                val = scalarZeroValue(field.V.T, LongType.BIGINT);
                 break;
             case "enum":
-                val = 0;
+                val = field.V.T.values[0].no;
                 break;
             case "message":
                 val = new field.V.T();
@@ -256,6 +283,47 @@ function readScalar(reader, type) {
             return reader.sint32();
     }
 }
+function writeField(field, value, writer, options) {
+    assert(value !== undefined);
+    const repeated = field.repeated;
+    switch (field.kind) {
+        case "scalar":
+        case "enum":
+            let scalarType = field.kind == "enum" ? ScalarType.INT32 : field.T;
+            if (repeated) {
+                assert(Array.isArray(value));
+                if (field.packed) {
+                    writePacked(writer, scalarType, field.no, value);
+                }
+                else {
+                    for (const item of value) {
+                        writeScalar(writer, scalarType, field.no, item);
+                    }
+                }
+            }
+            else {
+                writeScalar(writer, scalarType, field.no, value);
+            }
+            break;
+        case "message":
+            if (repeated) {
+                assert(Array.isArray(value));
+                for (const item of value) {
+                    writeMessageField(writer, options, field, item);
+                }
+            }
+            else {
+                writeMessageField(writer, options, field, value);
+            }
+            break;
+        case "map":
+            assert(typeof value == "object" && value != null);
+            for (const [key, val] of Object.entries(value)) {
+                writeMapEntry(writer, options, field, key, val);
+            }
+            break;
+    }
+}
 export function writeMapEntry(writer, options, field, key, value) {
     writer.tag(field.no, WireType.LengthDelimited);
     writer.fork();
@@ -277,26 +345,27 @@ export function writeMapEntry(writer, options, field, key, value) {
             break;
     }
     // write key, expecting key field number = 1
-    writeScalar(writer, field.K, 1, keyValue, true);
+    writeScalar(writer, field.K, 1, keyValue);
     // write value, expecting value field number = 2
     switch (field.V.kind) {
         case "scalar":
-            writeScalar(writer, field.V.T, 2, value, true);
+            writeScalar(writer, field.V.T, 2, value);
             break;
         case "enum":
-            writeScalar(writer, ScalarType.INT32, 2, value, true);
+            writeScalar(writer, ScalarType.INT32, 2, value);
             break;
         case "message":
+            assert(value !== undefined);
             writer.tag(2, WireType.LengthDelimited).bytes(value.toBinary(options));
             break;
     }
     writer.join();
 }
 // Value must not be undefined
-export function writeMessageField(writer, options, field, value) {
+function writeMessageField(writer, options, field, value) {
     const message = wrapField(field.T, value);
     // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
-    if (field === null || field === void 0 ? void 0 : field.delimited)
+    if (field.delimited)
         writer
             .tag(field.no, WireType.StartGroup)
             .raw(message.toBinary(options))
@@ -306,13 +375,12 @@ export function writeMessageField(writer, options, field, value) {
             .tag(field.no, WireType.LengthDelimited)
             .bytes(message.toBinary(options));
 }
-export function writeScalar(writer, type, fieldNo, value, emitIntrinsicDefault) {
-    let [wireType, method, isIntrinsicDefault] = scalarTypeInfo(type, value);
-    if (!isIntrinsicDefault || emitIntrinsicDefault) {
-        writer.tag(fieldNo, wireType)[method](value);
-    }
+function writeScalar(writer, type, fieldNo, value) {
+    assert(value !== undefined);
+    let [wireType, method] = scalarTypeInfo(type);
+    writer.tag(fieldNo, wireType)[method](value);
 }
-export function writePacked(writer, type, fieldNo, value) {
+function writePacked(writer, type, fieldNo, value) {
     if (!value.length) {
         return;
     }
@@ -323,3 +391,36 @@ export function writePacked(writer, type, fieldNo, value) {
     }
     writer.join();
 }
+/**
+ * Get information for writing a scalar value.
+ *
+ * Returns tuple:
+ * [0]: appropriate WireType
+ * [1]: name of the appropriate method of IBinaryWriter
+ * [2]: whether the given value is a default value for proto3 semantics
+ *
+ * If argument `value` is omitted, [2] is always false.
+ */
+// TODO replace call-sites writeScalar() and writePacked(), then remove
+function scalarTypeInfo(type) {
+    let wireType = WireType.Varint;
+    // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check -- INT32, UINT32, SINT32 are covered by the defaults
+    switch (type) {
+        case ScalarType.BYTES:
+        case ScalarType.STRING:
+            wireType = WireType.LengthDelimited;
+            break;
+        case ScalarType.DOUBLE:
+        case ScalarType.FIXED64:
+        case ScalarType.SFIXED64:
+            wireType = WireType.Bit64;
+            break;
+        case ScalarType.FIXED32:
+        case ScalarType.SFIXED32:
+        case ScalarType.FLOAT:
+            wireType = WireType.Bit32;
+            break;
+    }
+    const method = ScalarType[type].toLowerCase();
+    return [wireType, method];
+}

package/dist/esm/private/extensions.js

@@ -11,7 +11,7 @@
 // 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.
-import { scalarDefaultValue } from "./scalars.js";
+import { scalarZeroValue } from "./scalars.js";
 import { WireType } from "../binary-encoding.js";
 /**
  * Create a new extension using the given runtime.
@@ -55,7 +55,7 @@ function initExtensionField(ext) {
         case "enum":
             return field.T.values[0].no;
         case "scalar":
-            return scalarDefaultValue(field.T, field.L);
+            return scalarZeroValue(field.T, field.L);
         case "message":
             // eslint-disable-next-line no-case-declarations
             const T = field.T, value = new T();