@bufbuild/protobuf 2.0.0-alpha.3 → 2.0.0-beta.1

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

@@ -1,5 +1,6 @@
 import type { Message } from "../types.js";
 import type { DescEnum, DescExtension, DescField, DescFile, DescMessage, DescMethod, DescService } from "../descriptors.js";
+import type { JsonValue } from "../json-value.js";
 /**
  * Describes a protobuf source file.
  *
@@ -14,9 +15,9 @@ export type GenDescFile = DescFile;
  *
  * @private
  */
-export type GenDescMessage<RuntimeShape extends Message> = Omit<DescMessage, "field"> & {
+export type GenDescMessage<RuntimeShape extends Message, JsonType = JsonValue> = Omit<DescMessage, "field"> & {
     field: Record<MessageFieldNames<RuntimeShape>, DescField>;
-} & brand<RuntimeShape>;
+} & brandv1<RuntimeShape, JsonType>;
 /**
  * Describes an enumeration in a protobuf source file.
  *
@@ -25,7 +26,7 @@ export type GenDescMessage<RuntimeShape extends Message> = Omit<DescMessage, "fi
  *
  * @private
  */
-export type GenDescEnum<RuntimeShape> = DescEnum & brand<RuntimeShape>;
+export type GenDescEnum<RuntimeShape, JsonType extends JsonValue = JsonValue> = DescEnum & brandv1<RuntimeShape, JsonType>;
 /**
  * Describes an extension in a protobuf source file.
  *
@@ -34,7 +35,7 @@ export type GenDescEnum<RuntimeShape> = DescEnum & brand<RuntimeShape>;
  *
  * @private
  */
-export type GenDescExtension<Extendee extends Message = Message, RuntimeShape = unknown> = DescExtension & brand<Extendee, RuntimeShape>;
+export type GenDescExtension<Extendee extends Message = Message, RuntimeShape = unknown> = DescExtension & brandv1<Extendee, RuntimeShape>;
 /**
  * Describes a service declaration in a protobuf source file.
  *
@@ -52,7 +53,8 @@ export type GenDescService<RuntimeShape extends GenDescServiceMethods> = Omit<De
  * @private
  */
 export type GenDescServiceMethods = Record<string, Pick<DescMethod, "input" | "output" | "methodKind">>;
-declare class brand<A, B = unknown> {
+declare class brandv1<A, B = unknown> {
+    protected v: "codegenv1";
     protected a: A | boolean;
     protected b: B | boolean;
 }

package/dist/esm/codegenv1/types.js

@@ -11,8 +11,9 @@
 // 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 brand {
+class brandv1 {
     constructor() {
+        this.v = "codegenv1";
         this.a = false;
         this.b = false;
     }

package/dist/esm/create.d.ts

@@ -6,4 +6,4 @@ import type { MessageInitShape, MessageShape } from "./types.js";
  * The second argument is an optional initializer object, where all fields are
  * optional.
  */
-export declare function create<Desc extends DescMessage>(messageDesc: Desc, init?: MessageInitShape<Desc>): MessageShape<Desc>;
+export declare function create<Desc extends DescMessage>(schema: Desc, init?: MessageInitShape<Desc>): MessageShape<Desc>;

package/dist/esm/create.js

@@ -20,6 +20,8 @@ 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;
 const EDITION_PROTO3 = 999;
+// bootstrap-inject google.protobuf.Edition.EDITION_PROTO2: const $name: Edition.$localName = $number;
+const EDITION_PROTO2 = 998;
 // bootstrap-inject google.protobuf.FeatureSet.FieldPresence.IMPLICIT: const $name: FeatureSet_FieldPresence.$localName = $number;
 const IMPLICIT = 2;
 /**
@@ -28,13 +30,13 @@ const IMPLICIT = 2;
  * The second argument is an optional initializer object, where all fields are
  * optional.
  */
-export function create(messageDesc, init) {
-    if (isMessage(init, messageDesc)) {
+export function create(schema, init) {
+    if (isMessage(init, schema)) {
         return init;
     }
-    const message = createZeroMessage(messageDesc);
+    const message = createZeroMessage(schema);
     if (init !== undefined) {
-        initMessage(messageDesc, message, init);
+        initMessage(schema, message, init);
     }
     return message;
 }
@@ -63,12 +65,7 @@ function initMessage(messageDesc, message, init) {
         // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check -- no need to convert enum
         switch (field.fieldKind) {
             case "message":
-                if (isWrapperDesc(field.message)) {
-                    value = initScalar(field.message.fields[0], value);
-                }
-                else {
-                    value = toMessage(value, field.message);
-                }
+                value = toMessage(field, value);
                 break;
             case "scalar":
                 value = initScalar(field, value);
@@ -96,7 +93,7 @@ function initMap(field, value) {
             return convertObjectValues(value, toU8Arr);
         }
         if (field.mapKind == "message") {
-            return convertObjectValues(value, (val) => toMessage(val, field.message));
+            return convertObjectValues(value, (val) => toMessage(field, val));
         }
     }
     return value;
@@ -107,14 +104,29 @@ function initList(field, value) {
             return value.map(toU8Arr);
         }
         if (field.listKind == "message") {
-            return value.map((item) => toMessage(item, field.message));
+            return value.map((item) => toMessage(field, item));
         }
     }
     return value;
 }
-function toMessage(value, message) {
-    if (!isMessage(value, message) && isObject(value)) {
-        return create(message, value);
+function toMessage(field, value) {
+    if (field.fieldKind == "message" &&
+        !field.oneof &&
+        isWrapperDesc(field.message)) {
+        // Types from google/protobuf/wrappers.proto are unwrapped when used in
+        // a singular field that is not part of a oneof group.
+        return initScalar(field.message.fields[0], value);
+    }
+    if (isObject(value)) {
+        if (field.message.typeName == "google.protobuf.Struct" &&
+            field.parent.typeName !== "google.protobuf.Value") {
+            // google.protobuf.Struct is represented with JsonObject when used in a
+            // field, except when used in google.protobuf.Value.
+            return value;
+        }
+        if (!isMessage(value, field.message)) {
+            return create(field.message, value);
+        }
     }
     return value;
 }
@@ -136,9 +148,7 @@ const messagePrototypes = new WeakMap();
  */
 function createZeroMessage(desc) {
     let msg;
-    if (desc.file.edition == EDITION_PROTO3) {
-        // we special case proto3: since it does not have default values, we let
-        // the `optional` keyword generate an optional property.
+    if (!needsPrototypeChain(desc)) {
         msg = {};
         for (const member of desc.members) {
             if (member.kind == "oneof" || member.presence == IMPLICIT) {
@@ -147,8 +157,7 @@ function createZeroMessage(desc) {
         }
     }
     else {
-        // for everything but proto3, we support default values, and track presence
-        // via the prototype chain
+        // Support default values and track presence via the prototype chain
         const cached = messagePrototypes.get(desc);
         let prototype;
         let members;
@@ -200,6 +209,24 @@ function createZeroMessage(desc) {
     msg.$typeName = desc.typeName;
     return msg;
 }
+/**
+ * Do we need the prototype chain to track field presence?
+ */
+function needsPrototypeChain(desc) {
+    switch (desc.file.edition) {
+        case EDITION_PROTO3:
+            // proto3 always uses implicit presence, we never need the prototype chain.
+            return false;
+        case EDITION_PROTO2:
+            // proto2 never uses implicit presence, we always need the prototype chain.
+            return true;
+        default:
+            // If a message uses scalar or enum fields with explicit presence, we need
+            // the prototype chain to track presence. This rule does not apply to fields
+            // in a oneof group - they use a different mechanism to track presence.
+            return desc.fields.some((f) => f.presence != IMPLICIT && f.fieldKind != "message" && !f.oneof);
+    }
+}
 /**
  * Returns a zero value for oneof groups, and for every field kind except
  * messages. Scalar and enum fields can have default values.

package/dist/esm/equals.d.ts

@@ -6,4 +6,4 @@ import type { DescMessage } from "./descriptors.js";
  * Note that this function disregards extensions and unknown fields, and that
  * NaN is not equal NaN, following the IEEE standard.
  */
-export declare function equals<Desc extends DescMessage>(messageDesc: Desc, a: MessageShape<Desc>, b: MessageShape<Desc>): boolean;
+export declare function equals<Desc extends DescMessage>(schema: Desc, a: MessageShape<Desc>, b: MessageShape<Desc>): boolean;

package/dist/esm/equals.js

@@ -19,15 +19,14 @@ import { reflect } from "./reflect/reflect.js";
  * Note that this function disregards extensions and unknown fields, and that
  * NaN is not equal NaN, following the IEEE standard.
  */
-export function equals(messageDesc, a, b) {
-    if (a.$typeName != messageDesc.typeName ||
-        b.$typeName != messageDesc.typeName) {
+export function equals(schema, a, b) {
+    if (a.$typeName != schema.typeName || b.$typeName != schema.typeName) {
         return false;
     }
     if (a === b) {
         return true;
     }
-    return reflectEquals(reflect(messageDesc, a), reflect(messageDesc, b));
+    return reflectEquals(reflect(schema, a), reflect(schema, b));
 }
 function reflectEquals(a, b) {
     for (const f of a.fields) {
@@ -76,15 +75,11 @@ function fieldEquals(f, a, b) {
                     case "enum":
                         return false;
                     case "message":
-                        // TODO fix type error
-                        // @ts-expect-error TODO
                         if (!reflectEquals(va, vb)) {
                             return false;
                         }
                         break;
                     case "scalar":
-                        // TODO fix type error
-                        // @ts-expect-error TODO
                         if (!scalarEquals(f.scalar, va, vb)) {
                             return false;
                         }
@@ -100,23 +95,21 @@ function fieldEquals(f, a, b) {
                 return false;
             }
             for (let i = 0; i < la.size; i++) {
-                if (la.get(i) === lb.get(i)) {
+                const va = la.get(i);
+                const vb = lb.get(i);
+                if (va === vb) {
                     continue;
                 }
                 switch (f.listKind) {
                     case "enum":
                         return false;
                     case "message":
-                        // TODO fix type error
-                        // @ts-expect-error TODO
-                        if (!reflectEquals(la.get(i), lb.get(i))) {
+                        if (!reflectEquals(va, vb)) {
                             return false;
                         }
                         break;
                     case "scalar":
-                        // TODO fix type error
-                        // @ts-expect-error TODO
-                        if (!scalarEquals(f.scalar, la.get(i), lb.get(i))) {
+                        if (!scalarEquals(f.scalar, va, vb)) {
                             return false;
                         }
                         break;

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

@@ -17,7 +17,7 @@ export interface BinaryReadOptions {
 /**
  * Parse serialized binary data.
  */
-export declare function fromBinary<Desc extends DescMessage>(messageDesc: Desc, bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MessageShape<Desc>;
+export declare function fromBinary<Desc extends DescMessage>(schema: Desc, bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MessageShape<Desc>;
 /**
  * Parse from binary data, merging fields.
  *
@@ -27,7 +27,7 @@ export declare function fromBinary<Desc extends DescMessage>(messageDesc: Desc,
  * If a message field is already present, it will be merged with the
  * new data.
  */
-export declare function mergeFromBinary<Desc extends DescMessage>(messageDesc: Desc, target: MessageShape<Desc>, bytes: Uint8Array, options?: Partial<BinaryReadOptions>): void;
+export declare function mergeFromBinary<Desc extends DescMessage>(schema: Desc, target: MessageShape<Desc>, bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MessageShape<Desc>;
 /**
  * @private
  */

package/dist/esm/from-binary.js

@@ -25,8 +25,8 @@ function makeReadOptions(options) {
 /**
  * Parse serialized binary data.
  */
-export function fromBinary(messageDesc, bytes, options) {
-    const msg = reflect(messageDesc);
+export function fromBinary(schema, bytes, options) {
+    const msg = reflect(schema, undefined, false);
     readMessage(msg, new BinaryReader(bytes), makeReadOptions(options), false, bytes.byteLength);
     return msg.message;
 }
@@ -39,8 +39,9 @@ export function fromBinary(messageDesc, bytes, options) {
  * If a message field is already present, it will be merged with the
  * new data.
  */
-export function mergeFromBinary(messageDesc, target, bytes, options) {
-    readMessage(reflect(messageDesc, target), new BinaryReader(bytes), makeReadOptions(options), false, bytes.byteLength);
+export function mergeFromBinary(schema, target, bytes, options) {
+    readMessage(reflect(schema, target, false), new BinaryReader(bytes), makeReadOptions(options), false, bytes.byteLength);
+    return target;
 }
 /**
  * If `delimited` is false, read the length given in `lengthOrDelimitedFieldNo`.
@@ -94,15 +95,16 @@ export function readField(message, reader, field, wireType, options) {
             message.set(field, readMessageField(reader, options, field, message.get(field)));
             break;
         case "list":
-            readListField(message, reader, options, field, wireType);
+            readListField(reader, wireType, message.get(field), options);
             break;
         case "map":
-            readMapEntry(message, field, reader, options);
+            readMapEntry(reader, message.get(field), options);
             break;
     }
 }
 // Read a map field, expecting key field = 1, value field = 2
-function readMapEntry(message, field, reader, options) {
+function readMapEntry(reader, map, options) {
+    const field = map.field();
     let key, val;
     const end = reader.pos + reader.uint32();
     while (reader.pos < end) {
@@ -138,16 +140,17 @@ function readMapEntry(message, field, reader, options) {
                 val = field.enum.values[0].number;
                 break;
             case "message":
-                val = reflect(field.message);
+                val = reflect(field.message, undefined, false);
                 break;
         }
     }
-    message.setMapEntry(field, key, val);
+    map.set(key, val);
 }
-function readListField(message, reader, options, field, wireType) {
+function readListField(reader, wireType, list, options) {
     var _a;
+    const field = list.field();
     if (field.listKind === "message") {
-        message.addListItem(field, readMessageField(reader, options, field));
+        list.add(readMessageField(reader, options, field));
         return;
     }
     const scalarType = (_a = field.scalar) !== null && _a !== void 0 ? _a : ScalarType.INT32;
@@ -155,17 +158,17 @@ function readListField(message, reader, options, field, wireType) {
         scalarType != ScalarType.STRING &&
         scalarType != ScalarType.BYTES;
     if (!packed) {
-        message.addListItem(field, readScalar(reader, scalarType));
+        list.add(readScalar(reader, scalarType));
         return;
     }
     const e = reader.uint32() + reader.pos;
     while (reader.pos < e) {
-        message.addListItem(field, readScalar(reader, scalarType));
+        list.add(readScalar(reader, scalarType));
     }
 }
 function readMessageField(reader, options, field, mergeMessage) {
     const delimited = field.delimitedEncoding;
-    const message = mergeMessage !== null && mergeMessage !== void 0 ? mergeMessage : reflect(field.message);
+    const message = mergeMessage !== null && mergeMessage !== void 0 ? mergeMessage : reflect(field.message, undefined, false);
     readMessage(message, reader, options, delimited, delimited ? field.number : reader.uint32());
     return message;
 }

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

@@ -1,7 +1,7 @@
-import { type DescMessage } from "./descriptors.js";
+import { type DescEnum, type DescMessage } from "./descriptors.js";
 import type { JsonValue } from "./json-value.js";
 import type { Registry } from "./registry.js";
-import type { MessageShape } from "./types.js";
+import type { EnumJsonType, EnumShape, MessageShape } from "./types.js";
 /**
  * Options for parsing JSON data.
  */
@@ -21,7 +21,7 @@ export interface JsonReadOptions {
 /**
  * Parse a message from a JSON string.
  */
-export declare function fromJsonString<Desc extends DescMessage>(messageDesc: Desc, json: string, options?: Partial<JsonReadOptions>): MessageShape<Desc>;
+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.
  *
@@ -31,11 +31,11 @@ export declare function fromJsonString<Desc extends DescMessage>(messageDesc: De
  * If a message field is already present, it will be merged with the
  * new data.
  */
-export declare function mergeFromJsonString<Desc extends DescMessage>(messageDesc: Desc, target: MessageShape<Desc>, json: string, options?: Partial<JsonReadOptions>): void;
+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.
  */
-export declare function fromJson<Desc extends DescMessage>(messageDesc: Desc, json: JsonValue, options?: Partial<JsonReadOptions>): MessageShape<Desc>;
+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.
  *
@@ -45,4 +45,12 @@ export declare function fromJson<Desc extends DescMessage>(messageDesc: Desc, js
  * If a message field is already present, it will be merged with the
  * new data.
  */
-export declare function mergeFromJson<Desc extends DescMessage>(messageDesc: Desc, target: MessageShape<Desc>, json: JsonValue, options?: Partial<JsonReadOptions>): void;
+export declare function mergeFromJson<Desc extends DescMessage>(schema: Desc, target: MessageShape<Desc>, json: JsonValue, options?: Partial<JsonReadOptions>): MessageShape<Desc>;
+/**
+ * Parses an enum value from JSON.
+ */
+export declare function enumFromJson<Desc extends DescEnum>(descEnum: Desc, json: EnumJsonType<Desc>): EnumShape<Desc>;
+/**
+ * Is the given value a JSON enum value?
+ */
+export declare function isEnumJson<Desc extends DescEnum>(descEnum: Desc, value: unknown): value is EnumJsonType<Desc>;

package/dist/esm/from-json.js

@@ -20,7 +20,7 @@ import { FieldError, isFieldError } from "./reflect/error.js";
 import { formatVal } from "./reflect/reflect-check.js";
 import { scalarZeroValue } from "./reflect/scalar.js";
 import { base64Decode } from "./wire/base64-encoding.js";
-import { isWrapperDesc, anyPack, ListValueDesc, NullValue, StructDesc, ValueDesc, } from "./wkt/index.js";
+import { isWrapperDesc, anyPack, ListValueSchema, NullValue, StructSchema, ValueSchema, } from "./wkt/index.js";
 import { createExtensionContainer, setExtension } from "./extensions.js";
 // Default options for parsing JSON.
 const jsonReadDefaults = {
@@ -32,8 +32,8 @@ function makeReadOptions(options) {
 /**
  * Parse a message from a JSON string.
  */
-export function fromJsonString(messageDesc, json, options) {
-    return fromJson(messageDesc, parseJsonString(json, messageDesc.typeName), options);
+export function fromJsonString(schema, json, options) {
+    return fromJson(schema, parseJsonString(json, schema.typeName), options);
 }
 /**
  * Parse a message from a JSON string, merging fields.
@@ -44,14 +44,14 @@ export function fromJsonString(messageDesc, json, options) {
  * If a message field is already present, it will be merged with the
  * new data.
  */
-export function mergeFromJsonString(messageDesc, target, json, options) {
-    mergeFromJson(messageDesc, target, parseJsonString(json, messageDesc.typeName), options);
+export function mergeFromJsonString(schema, target, json, options) {
+    return mergeFromJson(schema, target, parseJsonString(json, schema.typeName), options);
 }
 /**
  * Parse a message from a JSON value.
  */
-export function fromJson(messageDesc, json, options) {
-    const msg = reflect(messageDesc);
+export function fromJson(schema, json, options) {
+    const msg = reflect(schema);
     try {
         readMessage(msg, json, makeReadOptions(options));
     }
@@ -75,9 +75,9 @@ export function fromJson(messageDesc, json, options) {
  * If a message field is already present, it will be merged with the
  * new data.
  */
-export function mergeFromJson(messageDesc, target, json, options) {
+export function mergeFromJson(schema, target, json, options) {
     try {
-        readMessage(reflect(messageDesc, target), json, makeReadOptions(options));
+        readMessage(reflect(schema, target), json, makeReadOptions(options));
     }
     catch (e) {
         if (isFieldError(e)) {
@@ -88,6 +88,23 @@ export function mergeFromJson(messageDesc, target, json, options) {
         }
         throw e;
     }
+    return target;
+}
+/**
+ * Parses an enum value from JSON.
+ */
+export function enumFromJson(descEnum, json) {
+    const val = readEnum(descEnum, json, false, false);
+    if (val === tokenIgnoredUnknownEnum) {
+        throw new Error(`cannot decode ${String(descEnum)} from JSON: ${formatVal(json)}`);
+    }
+    return val;
+}
+/**
+ * Is the given value a JSON enum value?
+ */
+export function isEnumJson(descEnum, value) {
+    return undefined !== descEnum.values.find((v) => v.name === value);
 }
 function readMessage(msg, json, opts) {
     var _a;
@@ -146,17 +163,18 @@ function readField(msg, field, json, opts) {
             readMessageField(msg, field, json, opts);
             break;
         case "list":
-            readListField(msg, field, json, opts);
+            readListField(msg.get(field), json, opts);
             break;
         case "map":
-            readMapField(msg, field, json, opts);
+            readMapField(msg.get(field), json, opts);
             break;
     }
 }
-function readMapField(msg, field, json, opts) {
+function readMapField(map, json, opts) {
     if (json === null) {
         return;
     }
+    const field = map.field();
     if (typeof json != "object" || Array.isArray(json)) {
         throw new FieldError(field, "expected object, got " + formatVal(json));
     }
@@ -164,45 +182,32 @@ function readMapField(msg, field, json, opts) {
         if (jsonMapValue === null) {
             throw new FieldError(field, "map value must not be null");
         }
-        const key = mapKeyFromJson(field.mapKey, jsonMapKey);
+        let value;
         switch (field.mapKind) {
             case "message":
                 const msgValue = reflect(field.message);
                 readMessage(msgValue, jsonMapValue, opts);
-                // TODO fix types
-                // @ts-expect-error TODO
-                const err = msg.setMapEntry(field, key, msgValue);
-                if (err) {
-                    throw err;
-                }
+                value = msgValue;
                 break;
             case "enum":
-                const enumValue = readEnum(field.enum, jsonMapValue, opts.ignoreUnknownFields, true);
-                if (enumValue !== tokenIgnoredUnknownEnum) {
-                    // TODO fix types
-                    // @ts-expect-error TODO
-                    const err = msg.setMapEntry(field, key, enumValue);
-                    if (err) {
-                        throw err;
-                    }
+                value = readEnum(field.enum, jsonMapValue, opts.ignoreUnknownFields, true);
+                if (value === tokenIgnoredUnknownEnum) {
+                    return;
                 }
                 break;
             case "scalar":
-                const err2 = msg.setMapEntry(field, 
-                // TODO fix types
-                // @ts-expect-error TODO
-                key, scalarFromJson(field, jsonMapValue, true));
-                if (err2) {
-                    throw err2;
-                }
+                value = scalarFromJson(field, jsonMapValue, true);
                 break;
         }
+        const key = mapKeyFromJson(field.mapKey, jsonMapKey);
+        map.set(key, value);
     }
 }
-function readListField(msg, field, json, opts) {
+function readListField(list, json, opts) {
     if (json === null) {
         return;
     }
+    const field = list.field();
     if (!Array.isArray(json)) {
         throw new FieldError(field, "expected Array, got " + formatVal(json));
     }
@@ -214,19 +219,16 @@ function readListField(msg, field, json, opts) {
             case "message":
                 const msgValue = reflect(field.message);
                 readMessage(msgValue, jsonItem, opts);
-                msg.addListItem(field, msgValue);
+                list.add(msgValue);
                 break;
             case "enum":
                 const enumValue = readEnum(field.enum, jsonItem, opts.ignoreUnknownFields, true);
                 if (enumValue !== tokenIgnoredUnknownEnum) {
-                    msg.addListItem(field, enumValue);
+                    list.add(enumValue);
                 }
                 break;
             case "scalar":
-                const err = msg.addListItem(field, scalarFromJson(field, jsonItem, true));
-                if (err) {
-                    throw err;
-                }
+                list.add(scalarFromJson(field, jsonItem, true));
                 break;
         }
     }
@@ -255,12 +257,7 @@ function readScalarField(msg, field, json) {
         msg.clear(field);
     }
     else {
-        // TODO fix type error
-        // @ts-expect-error TODO
-        const err = msg.set(field, scalarValue);
-        if (err) {
-            throw err;
-        }
+        msg.set(field, scalarValue);
     }
 }
 const tokenIgnoredUnknownEnum = Symbol();
@@ -460,10 +457,7 @@ function tryWktFromJson(msg, jsonValue, opts) {
                     msg.clear(valueField);
                 }
                 else {
-                    const err = msg.set(valueField, scalarFromJson(valueField, jsonValue, true));
-                    if (err) {
-                        throw err;
-                    }
+                    msg.set(valueField, scalarFromJson(valueField, jsonValue, true));
                 }
                 return true;
             }
@@ -574,7 +568,7 @@ function structFromJson(struct, json) {
         throw new Error(`cannot decode message ${struct.$typeName} from JSON ${formatVal(json)}`);
     }
     for (const [k, v] of Object.entries(json)) {
-        const parsedV = create(ValueDesc);
+        const parsedV = create(ValueSchema);
         valueFromJson(parsedV, v);
         struct.fields[k] = parsedV;
     }
@@ -595,12 +589,12 @@ function valueFromJson(value, json) {
                 value.kind = { case: "nullValue", value: NullValue.NULL_VALUE };
             }
             else if (Array.isArray(json)) {
-                const listValue = create(ListValueDesc);
+                const listValue = create(ListValueSchema);
                 listValueFromJson(listValue, json);
                 value.kind = { case: "listValue", value: listValue };
             }
             else {
-                const struct = create(StructDesc);
+                const struct = create(StructSchema);
                 structFromJson(struct, json);
                 value.kind = { case: "structValue", value: struct };
             }
@@ -615,7 +609,7 @@ function listValueFromJson(listValue, json) {
         throw new Error(`cannot decode message ${listValue.$typeName} from JSON ${formatVal(json)}`);
     }
     for (const e of json) {
-        const value = create(ValueDesc);
+        const value = create(ValueSchema);
         valueFromJson(value, e);
         listValue.values.push(value);
     }

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

@@ -4,4 +4,4 @@ import type { DescMessage } from "./descriptors.js";
  * Determine whether the given `arg` is a message.
  * If `desc` is set, determine whether `arg` is this specific message.
  */
-export declare function isMessage<Desc extends DescMessage>(arg: unknown, desc?: Desc): arg is MessageShape<Desc>;
+export declare function isMessage<Desc extends DescMessage>(arg: unknown, schema?: Desc): arg is MessageShape<Desc>;