@code-yeongyu/senpi 2026.8.20-2 → 2026.8.20

package/node_modules/@bufbuild/protobuf/dist/esm/from-json.js

@@ -14,18 +14,13 @@
 import { ScalarType, } from "./descriptors.js";
 import { protoInt64 } from "./proto-int64.js";
 import { create } from "./create.js";
+import { reflect } from "./reflect/reflect.js";
 import { FieldError, isFieldError } from "./reflect/error.js";
-import { formatVal, reasonSingular, checkScalarValue, } from "./reflect/reflect-check.js";
+import { formatVal } from "./reflect/reflect-check.js";
 import { protoSnakeCase } from "./reflect/names.js";
-import { scalarZeroValue } from "./reflect/scalar.js";
-import { unsafeLocal } from "./reflect/unsafe.js";
-import { localMessageMapper } from "./reflect/message.js";
 import { base64Decode } from "./wire/base64-encoding.js";
 import { hasCustomJsonRepresentation, isWrapperDesc, anyPack, ListValueSchema, NullValue, StructSchema, ValueSchema, } from "./wkt/index.js";
 import { createExtensionContainer, setExtension } from "./extensions.js";
-import { durationSecondsMax, durationSecondsMin, timestampMsMax, timestampMsMin, } from "./wkt/json.js";
-// bootstrap-inject google.protobuf.FeatureSet.FieldPresence.IMPLICIT: const $name = $number;
-const IMPLICIT = 2;
 function makeReadContext(options) {
     return Object.assign(Object.assign({ ignoreUnknownFields: false, recursionLimit: 100 }, options), { depth: 0 });
 }
@@ -59,9 +54,20 @@ export function mergeFromJsonString(schema, target, json, options) {
  * duplicate-key checking.
  */
 export function fromJson(schema, json, options) {
-    const message = create(schema);
-    readMessage(schema, message, json, options);
-    return message;
+    const msg = reflect(schema);
+    try {
+        readMessage(msg, json, makeReadContext(options));
+    }
+    catch (e) {
+        if (isFieldError(e)) {
+            // @ts-expect-error we use the ES2022 error CTOR option "cause" for better stack traces
+            throw new Error(`cannot decode ${e.field()} from JSON: ${e.message}`, {
+                cause: e,
+            });
+        }
+        throw e;
+    }
+    return msg.message;
 }
 /**
  * Parse a message from a JSON value, merging fields into the target.
@@ -76,20 +82,8 @@ export function fromJson(schema, json, options) {
  * for strict checking.
  */
 export function mergeFromJson(schema, target, json, options) {
-    if (target.$typeName !== schema.typeName &&
-        schema.fields.length > 0) {
-        throw new FieldError(schema.fields[0], `cannot use ${schema.fields[0]} with message ${target.$typeName}`, "ForeignFieldError");
-    }
-    readMessage(schema, target, json, options);
-    return target;
-}
-/**
- * Run the compiled decoder for the message, wrapping FieldErrors with the
- * standard error message.
- */
-function readMessage(schema, message, json, options) {
     try {
-        compiledReader(schema)(message, json, makeReadContext(options));
+        readMessage(reflect(schema, target), json, makeReadContext(options));
     }
     catch (e) {
         if (isFieldError(e)) {
@@ -100,14 +94,13 @@ function readMessage(schema, message, json, options) {
         }
         throw e;
     }
+    return target;
 }
 /**
  * Parses an enum value from JSON.
  */
 export function enumFromJson(descEnum, json) {
-    // With ignoreUnknownFields false, the converter never returns the token
-    // for ignored unknown enum values.
-    return compileEnumConverter(descEnum)(json, false);
+    return readEnum(descEnum, json, false);
 }
 /**
  * Is the given value a JSON enum value?
@@ -115,646 +108,315 @@ export function enumFromJson(descEnum, json) {
 export function isEnumJson(descEnum, value) {
     return undefined !== descEnum.values.find((v) => v.name === value);
 }
-const compiledReaders = new WeakMap();
-/**
- * Return the compiled decoder for a message, compiling it on first use.
- */
-function compiledReader(desc) {
-    let compiled = compiledReaders.get(desc);
-    if (compiled === undefined) {
-        compiled = compileMessage(desc);
+const messageJsonFields = new WeakMap();
+function getJsonField(desc, jsonKey) {
+    var _a;
+    if (!messageJsonFields.has(desc)) {
+        const jsonNames = new Map();
+        for (const field of desc.fields) {
+            jsonNames.set(field.name, field).set(field.jsonName, field);
+        }
+        messageJsonFields.set(desc, jsonNames);
     }
-    return compiled;
+    return (_a = messageJsonFields.get(desc)) === null || _a === void 0 ? void 0 : _a.get(jsonKey);
 }
-function compileMessage(desc) {
-    const descString = String(desc);
-    const readWkt = compileWkt(desc);
-    if (readWkt !== undefined) {
-        // All message decoders count against the recursion limit, including
-        // well-known types with a custom JSON representation.
-        const compiled = (message, json, ctx) => {
-            if (++ctx.depth > ctx.recursionLimit) {
-                throw new Error(`cannot decode ${descString} from JSON: maximum recursion depth of ${ctx.recursionLimit} reached`);
-            }
-            readWkt(message, json, ctx);
-            ctx.depth--;
-        };
-        compiledReaders.set(desc, compiled);
-        return compiled;
+function readMessage(msg, json, ctx) {
+    var _a;
+    if (++ctx.depth > ctx.recursionLimit) {
+        throw new Error(`cannot decode ${msg.desc} from JSON: maximum recursion depth of ${ctx.recursionLimit} reached`);
     }
-    const typeName = desc.typeName;
-    // Fields are looked up by their proto name and their JSON name.
-    const fieldsByJsonKey = new Map();
-    const compiled = (message, json, ctx) => {
-        var _a;
-        if (++ctx.depth > ctx.recursionLimit) {
-            throw new Error(`cannot decode ${descString} from JSON: maximum recursion depth of ${ctx.recursionLimit} reached`);
-        }
-        if (json == null || Array.isArray(json) || typeof json != "object") {
-            throw new Error(`cannot decode ${descString} from JSON: ${formatVal(json)}`);
-        }
-        const oneofSeen = new Map();
-        const fieldSeen = new Set();
-        const jsonKeys = Object.keys(json);
-        for (let i = 0; i < jsonKeys.length; i++) {
-            const jsonKey = jsonKeys[i];
-            const jsonValue = json[jsonKey];
-            const entry = fieldsByJsonKey.get(jsonKey);
-            if (entry !== undefined) {
-                const field = entry.field;
-                if (fieldSeen.has(field)) {
-                    // The same field may be set by its proto name and its JSON name, or by
-                    // a duplicate or unicode-escaped key that JSON.parse already collapsed.
-                    // Checked before the null-skip below so that a null entry still counts.
-                    throw new FieldError(field, "set multiple times");
-                }
-                fieldSeen.add(field);
-                if (entry.oneofScalarNullSkip && jsonValue === null) {
-                    continue;
-                }
-                if (entry.oneof) {
-                    const seen = oneofSeen.get(entry.oneof);
-                    if (seen !== undefined) {
-                        throw new FieldError(entry.oneof, `oneof set multiple times by ${seen.name} and ${field.name}`);
-                    }
-                    oneofSeen.set(entry.oneof, field);
-                }
-                entry.read(message, jsonValue, ctx);
+    if (tryWktFromJson(msg, json, ctx)) {
+        ctx.depth--;
+        return;
+    }
+    if (json == null || Array.isArray(json) || typeof json != "object") {
+        throw new Error(`cannot decode ${msg.desc} from JSON: ${formatVal(json)}`);
+    }
+    const oneofSeen = new Map();
+    const fieldSeen = new Set();
+    for (const [jsonKey, jsonValue] of Object.entries(json)) {
+        const field = getJsonField(msg.desc, jsonKey);
+        if (field) {
+            if (fieldSeen.has(field)) {
+                // The same field may be set by its proto name and its JSON name, or by
+                // a duplicate or unicode-escaped key that JSON.parse already collapsed.
+                // Checked before the null-skip below so that a null entry still counts.
+                throw new FieldError(field, "set multiple times");
             }
-            else {
-                const extension = jsonKey.startsWith("[") && jsonKey.endsWith("]")
-                    ? (_a = ctx.registry) === null || _a === void 0 ? void 0 : _a.getExtension(jsonKey.substring(1, jsonKey.length - 1))
-                    : undefined;
-                if ((extension === null || extension === void 0 ? void 0 : extension.extendee.typeName) == typeName) {
-                    const [container, field, get] = createExtensionContainer(extension);
-                    compileFieldReader(field)(container[unsafeLocal], jsonValue, ctx);
-                    setExtension(message, extension, get());
-                }
-                if (extension === undefined && !ctx.ignoreUnknownFields) {
-                    throw new Error(`cannot decode ${descString} from JSON: key "${jsonKey}" is unknown`);
+            fieldSeen.add(field);
+            if (field.oneof && jsonValue === null && field.fieldKind == "scalar") {
+                // see conformance test Required.Proto3.JsonInput.OneofFieldNull{First,Second}
+                continue;
+            }
+            if (field.oneof) {
+                const seen = oneofSeen.get(field.oneof);
+                if (seen !== undefined) {
+                    throw new FieldError(field.oneof, `oneof set multiple times by ${seen.name} and ${field.name}`);
                 }
+                oneofSeen.set(field.oneof, field);
             }
+            readField(msg, field, jsonValue, ctx);
         }
-        ctx.depth--;
-    };
-    // Register before compiling fields, so that recursive message types
-    // resolve to this instance instead of compiling endlessly.
-    compiledReaders.set(desc, compiled);
-    for (const field of desc.fields) {
-        const entry = {
-            read: compileFieldReader(field),
-            field,
-            oneof: field.oneof,
-            oneofScalarNullSkip: field.oneof !== undefined && field.fieldKind == "scalar",
-        };
-        fieldsByJsonKey.set(field.name, entry).set(field.jsonName, entry);
-    }
-    return compiled;
-}
-/**
- * Compile a decoder for a well-known type with a custom JSON representation,
- * or return undefined for other messages. The recursion limit is enforced by
- * the caller.
- */
-function compileWkt(desc) {
-    if (!desc.typeName.startsWith("google.protobuf.")) {
-        return undefined;
-    }
-    switch (desc.typeName) {
-        case "google.protobuf.Any":
-            return (message, json, ctx) => anyFromJson(message, json, ctx);
-        case "google.protobuf.Timestamp":
-            return (message, json) => timestampFromJson(message, json);
-        case "google.protobuf.Duration":
-            return (message, json) => durationFromJson(message, json);
-        case "google.protobuf.FieldMask":
-            return (message, json) => fieldMaskFromJson(message, json);
-        case "google.protobuf.Struct":
-            return (message, json, ctx) => structFromJson(message, json, ctx);
-        case "google.protobuf.Value":
-            return (message, json, ctx) => valueFromJson(message, json, ctx);
-        case "google.protobuf.ListValue":
-            return (message, json, ctx) => listValueFromJson(message, json, ctx);
-        default:
-            if (isWrapperDesc(desc)) {
-                const valueField = desc.fields[0];
-                const localName = valueField.localName;
-                const scalar = valueField.scalar;
-                const longAsString = valueField.longAsString;
-                const readScalar = compileScalarConverter(valueField);
-                return (message, json) => {
-                    if (json === null) {
-                        message[localName] = scalarZeroValue(scalar, longAsString);
-                    }
-                    else {
-                        message[localName] = readScalar(json);
-                    }
-                };
+        else {
+            let extension = undefined;
+            if (jsonKey.startsWith("[") &&
+                jsonKey.endsWith("]") &&
+                // biome-ignore lint/suspicious/noAssignInExpressions: no
+                (extension = (_a = ctx.registry) === null || _a === void 0 ? void 0 : _a.getExtension(jsonKey.substring(1, jsonKey.length - 1))) &&
+                extension.extendee.typeName === msg.desc.typeName) {
+                const [container, field, get] = createExtensionContainer(extension);
+                readField(container, field, jsonValue, ctx);
+                setExtension(msg.message, extension, get());
             }
-            return undefined;
+            if (!extension && !ctx.ignoreUnknownFields) {
+                throw new Error(`cannot decode ${msg.desc} from JSON: key "${jsonKey}" is unknown`);
+            }
+        }
     }
+    ctx.depth--;
 }
-function compileFieldReader(field) {
+function readField(msg, field, json, ctx) {
     switch (field.fieldKind) {
         case "scalar":
-            return compileScalarFieldReader(field);
+            readScalarField(msg, field, json);
+            break;
         case "enum":
-            return compileEnumFieldReader(field);
+            readEnumField(msg, field, json, ctx);
+            break;
         case "message":
-            return compileMessageFieldReader(field);
+            readMessageField(msg, field, json, ctx);
+            break;
         case "list":
-            return compileListFieldReader(field);
+            readListField(msg.get(field), json, ctx);
+            break;
         case "map":
-            return compileMapFieldReader(field);
+            readMapField(msg.get(field), json, ctx);
+            break;
     }
 }
-function compileScalarFieldReader(field) {
-    const readScalar = compileScalarConverter(field);
-    const localName = field.localName;
-    if (field.oneof) {
-        // JSON null for a oneof scalar member is skipped by the message decoder.
-        const oneofLocalName = field.oneof.localName;
-        return (message, json) => {
-            message[oneofLocalName] = {
-                case: localName,
-                value: readScalar(json),
-            };
-        };
+function readListOrMapItem(field, json, ctx) {
+    if (field.scalar && json !== null) {
+        return scalarFromJson(field, json);
     }
-    const clear = compileClear(field);
-    return (message, json) => {
-        if (json === null) {
-            clear(message);
-        }
-        else {
-            message[localName] = readScalar(json);
-        }
-    };
-}
-/**
- * Compile a function that resets the field to unset, mirroring the clear
- * operation of the reflect API for fields that are not part of a oneof.
- */
-function compileClear(field) {
-    const localName = field.localName;
-    if (field.presence != IMPLICIT) {
-        // Fields with explicit presence have properties on the prototype chain
-        // for default / zero values (except for proto3). By deleting their own
-        // property, the field is reset.
-        return (message) => {
-            delete message[localName];
-        };
+    if (field.message && !isResetSentinelNullValue(field, json)) {
+        const msgValue = reflect(field.message);
+        readMessage(msgValue, json, ctx);
+        return msgValue;
     }
-    if (field.fieldKind == "enum") {
-        const zero = field.enum.values[0].number;
-        return (message) => {
-            message[localName] = zero;
-        };
+    if (field.enum && !isResetSentinelNullValue(field, json)) {
+        return readEnum(field.enum, json, ctx.ignoreUnknownFields);
     }
-    const scalar = field.scalar;
-    const longAsString = field.longAsString;
-    return (message) => {
-        message[localName] = scalarZeroValue(scalar, longAsString);
-    };
+    throw new FieldError(field, `${field.fieldKind === "list" ? "list item" : "map value"} must not be null`);
 }
-function compileEnumFieldReader(field) {
-    const readEnumValue = compileEnumConverter(field.enum);
-    const checkEnum = compileEnumCheck(field.enum);
-    const localName = field.localName;
-    // Fields with enum google.protobuf.NullValue permit a Protobuf-serializable
-    // null; for all other enums, JSON null resets the field.
-    const nullResets = field.enum.typeName != "google.protobuf.NullValue";
-    if (field.oneof) {
-        const oneofLocalName = field.oneof.localName;
-        return (message, json, ctx) => {
-            if (json === null && nullResets) {
-                const oneof = message[oneofLocalName];
-                if (oneof.case === localName) {
-                    message[oneofLocalName] = { case: undefined };
-                }
-                return;
-            }
-            const value = readEnumValue(json, ctx.ignoreUnknownFields);
-            if (value === tokenIgnoredUnknownEnum) {
-                return;
-            }
-            const check = checkEnum(value);
-            if (check !== true) {
-                throw new FieldError(field, reasonSingular(field, value, check));
-            }
-            message[oneofLocalName] = { case: localName, value };
-        };
+function readMapField(map, json, ctx) {
+    if (json === null) {
+        return;
     }
-    const clear = compileClear(field);
-    return (message, json, ctx) => {
-        if (json === null && nullResets) {
-            clear(message);
-            return;
-        }
-        const value = readEnumValue(json, ctx.ignoreUnknownFields);
-        if (value === tokenIgnoredUnknownEnum) {
-            return;
+    const field = map.field();
+    if (typeof json != "object" || Array.isArray(json)) {
+        throw new FieldError(field, "expected object, got " + formatVal(json));
+    }
+    const seen = new Set();
+    for (const [jsonMapKey, jsonMapValue] of Object.entries(json)) {
+        const key = mapKeyFromJson(field.mapKey, jsonMapKey);
+        if (seen.has(key)) {
+            throw new FieldError(field, `duplicate map key "${jsonMapKey}"`);
         }
-        const check = checkEnum(value);
-        if (check !== true) {
-            throw new FieldError(field, reasonSingular(field, value, check));
+        seen.add(key);
+        const value = readListOrMapItem(field, jsonMapValue, ctx);
+        if (value !== tokenIgnoredUnknownEnum) {
+            map.set(key, value);
         }
-        message[localName] = value;
-    };
+    }
 }
-function compileMessageFieldReader(field) {
-    const localName = field.localName;
-    const { toMessage, toLocal } = localMessageMapper(field);
-    const readChild = compiledReader(field.message);
-    // Fields with message google.protobuf.Value permit a Protobuf-serializable
-    // null; for all other messages, JSON null resets the field.
-    const nullResets = field.message.typeName != "google.protobuf.Value";
-    if (field.oneof) {
-        const oneofLocalName = field.oneof.localName;
-        return (message, json, ctx) => {
-            const oneof = message[oneofLocalName];
-            if (json === null && nullResets) {
-                if (oneof.case === localName) {
-                    message[oneofLocalName] = { case: undefined };
-                }
-                return;
-            }
-            const child = toMessage(oneof.case === localName ? oneof.value : undefined);
-            readChild(child, json, ctx);
-            message[oneofLocalName] = { case: localName, value: toLocal(child) };
-        };
+function readListField(list, json, ctx) {
+    if (json === null) {
+        return;
     }
-    return (message, json, ctx) => {
-        if (json === null && nullResets) {
-            delete message[localName];
-            return;
+    const field = list.field();
+    if (!Array.isArray(json)) {
+        throw new FieldError(field, "expected Array, got " + formatVal(json));
+    }
+    for (const jsonItem of json) {
+        const value = readListOrMapItem(field, jsonItem, ctx);
+        if (value !== tokenIgnoredUnknownEnum) {
+            list.add(value);
         }
-        const child = toMessage(message[localName]);
-        readChild(child, json, ctx);
-        message[localName] = toLocal(child);
-    };
+    }
 }
-function compileListFieldReader(field) {
-    const localName = field.localName;
-    const readItem = compileListItemReader(field);
-    return (message, json, ctx) => {
-        if (json === null) {
-            return;
-        }
-        if (!Array.isArray(json)) {
-            throw new FieldError(field, "expected Array, got " + formatVal(json));
-        }
-        const items = message[localName];
-        for (let i = 0; i < json.length; i++) {
-            const value = readItem(json[i], ctx, items.length);
-            if (value !== tokenIgnoredUnknownEnum) {
-                items.push(value);
-            }
-        }
-    };
+function readMessageField(msg, field, json, ctx) {
+    if (isResetSentinelNullValue(field, json)) {
+        msg.clear(field);
+        return;
+    }
+    const msgValue = msg.isSet(field) ? msg.get(field) : reflect(field.message);
+    readMessage(msgValue, json, ctx);
+    msg.set(field, msgValue);
 }
-/**
- * Compile a decoder for a list item. The index is only used in errors, and
- * accounts for previously merged items.
- */
-function compileListItemReader(field) {
-    switch (field.listKind) {
-        case "scalar": {
-            const parseScalar = compileScalarParse(field);
-            const checkValue = checkScalarValue(field.scalar);
-            const toLocal = compileScalarToLocal(field);
-            return (json, ctx, index) => {
-                if (json === null) {
-                    throw new FieldError(field, "list item must not be null");
-                }
-                const value = parseScalar(json);
-                const check = checkValue(value);
-                if (check !== true) {
-                    throw new FieldError(field, `list item #${index + 1}: ${reasonSingular(field, value, check)}`);
-                }
-                return toLocal(value);
-            };
-        }
-        case "enum": {
-            const readEnumValue = compileEnumConverter(field.enum);
-            const checkEnum = compileEnumCheck(field.enum);
-            const nullResets = field.enum.typeName != "google.protobuf.NullValue";
-            return (json, ctx, index) => {
-                if (json === null && nullResets) {
-                    throw new FieldError(field, "list item must not be null");
-                }
-                const value = readEnumValue(json, ctx.ignoreUnknownFields);
-                if (value === tokenIgnoredUnknownEnum) {
-                    return value;
-                }
-                const check = checkEnum(value);
-                if (check !== true) {
-                    throw new FieldError(field, `list item #${index + 1}: ${reasonSingular(field, value, check)}`);
-                }
-                return value;
-            };
-        }
-        case "message": {
-            const { toMessage, toLocal } = localMessageMapper(field);
-            const readChild = compiledReader(field.message);
-            const nullResets = field.message.typeName != "google.protobuf.Value";
-            return (json, ctx) => {
-                if (json === null && nullResets) {
-                    throw new FieldError(field, "list item must not be null");
-                }
-                const child = toMessage(undefined);
-                readChild(child, json, ctx);
-                return toLocal(child);
-            };
-        }
+function readEnumField(msg, field, json, ctx) {
+    if (isResetSentinelNullValue(field, json)) {
+        msg.clear(field);
+        return;
+    }
+    const enumValue = readEnum(field.enum, json, ctx.ignoreUnknownFields);
+    if (enumValue !== tokenIgnoredUnknownEnum) {
+        msg.set(field, enumValue);
     }
 }
-function compileMapFieldReader(field) {
-    const localName = field.localName;
-    const mapKey = field.mapKey;
-    const parseMapKey = compileMapKeyParse(mapKey);
-    const checkMapKey = checkScalarValue(mapKey);
-    let parseValue;
-    // Additional validation for scalar and enum values, matching the checks
-    // of the reflect API. Message values need no validation.
-    let checkValue;
-    let toLocalValue = (value) => value;
-    // Fields with google.protobuf.Value or google.protobuf.NullValue values
-    // permit a Protobuf-serializable null.
-    let nullResets = true;
-    switch (field.mapKind) {
-        case "scalar": {
-            parseValue = compileScalarParse(field);
-            checkValue = checkScalarValue(field.scalar);
-            toLocalValue = compileScalarToLocal(field);
-            break;
-        }
-        case "enum": {
-            const readEnumValue = compileEnumConverter(field.enum);
-            parseValue = (json, ctx) => readEnumValue(json, ctx.ignoreUnknownFields);
-            checkValue = compileEnumCheck(field.enum);
-            nullResets = field.enum.typeName != "google.protobuf.NullValue";
-            break;
-        }
-        case "message": {
-            const { toMessage, toLocal } = localMessageMapper(field);
-            const readChild = compiledReader(field.message);
-            nullResets = field.message.typeName != "google.protobuf.Value";
-            parseValue = (json, ctx) => {
-                const child = toMessage(undefined);
-                readChild(child, json, ctx);
-                return toLocal(child);
-            };
-            break;
-        }
+function readScalarField(msg, field, json) {
+    if (json === null) {
+        msg.clear(field);
+    }
+    else {
+        msg.set(field, scalarFromJson(field, json));
     }
-    return (message, json, ctx) => {
-        if (json === null) {
-            return;
-        }
-        if (typeof json != "object" || Array.isArray(json)) {
-            throw new FieldError(field, "expected object, got " + formatVal(json));
-        }
-        const record = message[localName];
-        const seen = new Set();
-        const jsonMapKeys = Object.keys(json);
-        for (let i = 0; i < jsonMapKeys.length; i++) {
-            const jsonMapKey = jsonMapKeys[i];
-            const jsonMapValue = json[jsonMapKey];
-            const key = parseMapKey(jsonMapKey);
-            if (seen.has(key)) {
-                throw new FieldError(field, `duplicate map key "${jsonMapKey}"`);
-            }
-            seen.add(key);
-            if (jsonMapValue === null && nullResets) {
-                throw new FieldError(field, "map value must not be null");
-            }
-            const value = parseValue(jsonMapValue, ctx);
-            if (value === tokenIgnoredUnknownEnum) {
-                continue;
-            }
-            const checkKey = checkMapKey(key);
-            if (checkKey !== true) {
-                throw new FieldError(field, `invalid map key: ${reasonSingular({ scalar: mapKey }, key, checkKey)}`);
-            }
-            if (checkValue !== undefined) {
-                const check = checkValue(value);
-                if (check !== true) {
-                    throw new FieldError(field, `map entry ${formatVal(key)}: ${reasonSingular(field, value, check)}`);
-                }
-            }
-            // Object property keys are always strings or symbols. Assigning with a
-            // boolean, number, or bigint key implicitly converts it to a string.
-            record[key] = toLocalValue(value);
-        }
-    };
 }
-const tokenIgnoredUnknownEnum = Symbol();
 /**
- * Compile a converter from a JSON value to an enum value. JSON null returns
- * the enum's first value. With ignoreUnknownFields false, unknown string
- * values raise an error; with true, they return tokenIgnoredUnknownEnum.
- * The value is not checked against the enum's values, see compileEnumCheck.
+ * Indicates whether a value is a sentinel for reseting a field.
+ *
+ * For this to be true, the value must be a JSON null and the field must not
+ * permit a present, Protobuf-serializable null.
+ *
+ * Only message google.protobuf.Value and enum google.protobuf.NullValue fields
+ * permit Protobuf-serializable nulls.
+ *
+ * Note that field-resetting sentinel nulls are not permitted in lists and maps.
  */
-function compileEnumConverter(desc) {
-    const zero = desc.values[0].number;
-    const values = desc.values;
-    return (json, ignoreUnknownFields) => {
-        if (json === null) {
-            return zero;
-        }
-        switch (typeof json) {
-            case "number":
-                if (Number.isInteger(json)) {
-                    return json;
-                }
-                break;
-            case "string": {
-                const value = values.find((ev) => ev.name === json);
-                if (value !== undefined) {
-                    return value.number;
-                }
-                if (ignoreUnknownFields) {
-                    return tokenIgnoredUnknownEnum;
-                }
-                break;
-            }
-        }
-        throw new Error(`cannot decode ${desc} from JSON: ${formatVal(json)}`);
-    };
+function isResetSentinelNullValue(field, json) {
+    var _a, _b;
+    return (json === null &&
+        ((_a = field.message) === null || _a === void 0 ? void 0 : _a.typeName) != "google.protobuf.Value" &&
+        ((_b = field.enum) === null || _b === void 0 ? void 0 : _b.typeName) != "google.protobuf.NullValue");
 }
-/**
- * Compile the check that the reflect API performs for enum values: open
- * enums accept any int32 value, closed enums accept only declared values.
- */
-function compileEnumCheck(desc) {
-    if (desc.open) {
-        return checkScalarValue(ScalarType.INT32);
+const tokenIgnoredUnknownEnum = Symbol();
+function readEnum(desc, json, ignoreUnknownFields) {
+    if (json === null) {
+        return desc.values[0].number;
     }
-    const values = desc.values;
-    return (value) => values.some((v) => v.number === value);
-}
-/**
- * Compile a converter from a JSON value to the local representation of a
- * scalar, fusing JSON parsing, the validation of the reflect API, and the
- * conversion to the local 64-bit integer representation.
- */
-function compileScalarConverter(field) {
-    const parseScalar = compileScalarParse(field);
-    const checkValue = checkScalarValue(field.scalar);
-    const toLocal = compileScalarToLocal(field);
-    return (json) => {
-        const value = parseScalar(json);
-        const check = checkValue(value);
-        if (check !== true) {
-            throw new FieldError(field, reasonSingular(field, value, check));
-        }
-        return toLocal(value);
-    };
+    switch (typeof json) {
+        case "number":
+            if (Number.isInteger(json)) {
+                return json;
+            }
+            break;
+        case "string":
+            const value = desc.values.find((ev) => ev.name === json);
+            if (value !== undefined) {
+                return value.number;
+            }
+            if (ignoreUnknownFields) {
+                return tokenIgnoredUnknownEnum;
+            }
+            break;
+    }
+    throw new Error(`cannot decode ${desc} from JSON: ${formatVal(json)}`);
 }
 /**
- * Compile the JSON-specific parsing step for a scalar value: the special
- * string values of float and double, string-encoded numbers, and base64
- * bytes. Returns the input unchanged if the JSON value cannot be converted;
- * the validation step raises an error for it.
+ * Try to parse a JSON value to a scalar value for the reflect API.
+ *
+ * Returns the input if the JSON value cannot be converted. Raises a FieldError
+ * if conversion would be ambiguous.
  */
-function compileScalarParse(field) {
+function scalarFromJson(field, json) {
+    // int64, sfixed64, sint64, fixed64, uint64: Reflect supports string and number.
+    // string, bool: Supported by reflect.
     switch (field.scalar) {
         // float, double: JSON value will be a number or one of the special string values "NaN", "Infinity", and "-Infinity".
         // Either numbers or strings are accepted. Exponent notation is also accepted.
         case ScalarType.DOUBLE:
         case ScalarType.FLOAT:
-            return (json) => {
-                if (json === "NaN")
-                    return NaN;
-                if (json === "Infinity")
-                    return Number.POSITIVE_INFINITY;
-                if (json === "-Infinity")
-                    return Number.NEGATIVE_INFINITY;
-                if (typeof json == "number") {
-                    if (Number.isNaN(json)) {
-                        // NaN must be encoded with string constants
-                        throw new FieldError(field, "unexpected NaN number");
-                    }
-                    if (!Number.isFinite(json)) {
-                        // Infinity must be encoded with string constants
-                        throw new FieldError(field, "unexpected infinite number");
-                    }
-                    return json;
+            if (json === "NaN")
+                return NaN;
+            if (json === "Infinity")
+                return Number.POSITIVE_INFINITY;
+            if (json === "-Infinity")
+                return Number.NEGATIVE_INFINITY;
+            if (typeof json == "number") {
+                if (Number.isNaN(json)) {
+                    // NaN must be encoded with string constants
+                    throw new FieldError(field, "unexpected NaN number");
                 }
-                if (typeof json == "string") {
-                    if (json === "") {
-                        // empty string is not a number
-                        return json;
-                    }
-                    if (json.trim().length !== json.length) {
-                        // extra whitespace
-                        return json;
-                    }
-                    const float = Number(json);
-                    if (!Number.isFinite(float)) {
-                        // Infinity and NaN must be encoded with string constants
-                        return json;
-                    }
-                    return float;
+                if (!Number.isFinite(json)) {
+                    // Infinity must be encoded with string constants
+                    throw new FieldError(field, "unexpected infinite number");
                 }
-                return json;
-            };
+                break;
+            }
+            if (typeof json == "string") {
+                if (json === "") {
+                    // empty string is not a number
+                    break;
+                }
+                if (json.trim().length !== json.length) {
+                    // extra whitespace
+                    break;
+                }
+                const float = Number(json);
+                if (!Number.isFinite(float)) {
+                    // Infinity and NaN must be encoded with string constants
+                    break;
+                }
+                return float;
+            }
+            break;
         // int32, fixed32, uint32: JSON value will be a decimal number. Either numbers or strings are accepted.
         case ScalarType.INT32:
         case ScalarType.FIXED32:
         case ScalarType.SFIXED32:
         case ScalarType.SINT32:
         case ScalarType.UINT32:
-            return int32FromJson;
+            return int32FromJson(json);
         // bytes: JSON value will be the data encoded as a string using standard base64 encoding with paddings.
         // Either standard or URL-safe base64 encoding with/without paddings are accepted.
         case ScalarType.BYTES:
-            return (json) => {
-                if (typeof json == "string") {
-                    if (json === "") {
-                        return new Uint8Array(0);
-                    }
-                    try {
-                        return base64Decode(json);
-                    }
-                    catch (e) {
-                        const message = e instanceof Error ? e.message : String(e);
-                        throw new FieldError(field, message);
-                    }
+            if (typeof json == "string") {
+                if (json === "") {
+                    return new Uint8Array(0);
+                }
+                try {
+                    return base64Decode(json);
+                }
+                catch (e) {
+                    const message = e instanceof Error ? e.message : String(e);
+                    throw new FieldError(field, message);
                 }
-                return json;
-            };
-        // int64, sfixed64, sint64, fixed64, uint64: The validation step accepts
-        // string and number. string, bool: no conversion.
-        default:
-            return (json) => json;
-    }
-}
-/**
- * Compile the conversion of a validated scalar value to its local
- * representation: 64-bit integers become bigint, or string with the
- * longAsString option.
- */
-function compileScalarToLocal(field) {
-    const longAsString = field.fieldKind !== "map" && field.longAsString;
-    switch (field.scalar) {
-        case ScalarType.INT64:
-        case ScalarType.SFIXED64:
-        case ScalarType.SINT64:
-            if (longAsString) {
-                return (value) => String(value);
-            }
-            return (value) => typeof value == "string" || typeof value == "number"
-                ? protoInt64.parse(value)
-                : value;
-        case ScalarType.FIXED64:
-        case ScalarType.UINT64:
-            if (longAsString) {
-                return (value) => String(value);
             }
-            return (value) => typeof value == "string" || typeof value == "number"
-                ? protoInt64.uParse(value)
-                : value;
-        default:
-            return (value) => value;
+            break;
     }
+    return json;
 }
 /**
- * Return a parser from a JSON value to a map key for the given key type.
- * Canonicalizes 64-bit integers given as string, so that "01" and "1" are
- * one key, and duplicates can raise an error.
- * The parser returns the input if the JSON value cannot be converted.
+ * Try to parse a JSON value to a map key for the reflect API.
+ * Canonicalizes 64-bit integers given as string, so that "01 and "1" are one
+ * key, and duplicates can raise an error.
+ * Returns the input if the JSON value cannot be converted.
  */
-function compileMapKeyParse(type) {
+function mapKeyFromJson(type, jsonString) {
     switch (type) {
         case ScalarType.BOOL:
-            return (jsonString) => {
-                switch (jsonString) {
-                    case "true":
-                        return true;
-                    case "false":
-                        return false;
-                }
-                return jsonString;
-            };
+            switch (jsonString) {
+                case "true":
+                    return true;
+                case "false":
+                    return false;
+            }
+            return jsonString;
         case ScalarType.INT32:
         case ScalarType.FIXED32:
         case ScalarType.UINT32:
         case ScalarType.SFIXED32:
         case ScalarType.SINT32:
-            return int32FromJson;
+            return int32FromJson(jsonString);
         case ScalarType.INT64:
         case ScalarType.SINT64:
         case ScalarType.SFIXED64:
         case ScalarType.UINT64:
         case ScalarType.FIXED64:
-            return (jsonString) => /^-?0+$/.test(jsonString)
+            return /^-?0+$/.test(jsonString)
                 ? "0"
                 : jsonString.replace(/^(-?)0+(?=\d)/, "$1");
         default:
-            // ScalarType.STRING
-            return (jsonString) => jsonString;
+            return jsonString;
     }
 }
 /**
@@ -874,6 +536,46 @@ function checkDuplicateKeys(jsonString, typeName) {
         }
     }
 }
+function tryWktFromJson(msg, jsonValue, ctx) {
+    if (!msg.desc.typeName.startsWith("google.protobuf.")) {
+        return false;
+    }
+    switch (msg.desc.typeName) {
+        case "google.protobuf.Any":
+            anyFromJson(msg.message, jsonValue, ctx);
+            return true;
+        case "google.protobuf.Timestamp":
+            timestampFromJson(msg.message, jsonValue);
+            return true;
+        case "google.protobuf.Duration":
+            durationFromJson(msg.message, jsonValue);
+            return true;
+        case "google.protobuf.FieldMask":
+            fieldMaskFromJson(msg.message, jsonValue);
+            return true;
+        case "google.protobuf.Struct":
+            structFromJson(msg.message, jsonValue, ctx);
+            return true;
+        case "google.protobuf.Value":
+            valueFromJson(msg.message, jsonValue, ctx);
+            return true;
+        case "google.protobuf.ListValue":
+            listValueFromJson(msg.message, jsonValue, ctx);
+            return true;
+        default:
+            if (isWrapperDesc(msg.desc)) {
+                const valueField = msg.desc.fields[0];
+                if (jsonValue === null) {
+                    msg.clear(valueField);
+                }
+                else {
+                    msg.set(valueField, scalarFromJson(valueField, jsonValue));
+                }
+                return true;
+            }
+            return false;
+    }
+}
 function anyFromJson(any, json, ctx) {
     var _a;
     if (json === null || Array.isArray(json) || typeof json != "object") {
@@ -896,18 +598,19 @@ function anyFromJson(any, json, ctx) {
     if (!desc) {
         throw new Error(`cannot decode message ${any.$typeName} from JSON: ${typeUrl} is not in the type registry`);
     }
-    const message = create(desc);
+    const msg = reflect(desc);
     if (hasCustomJsonRepresentation(desc) &&
         Object.prototype.hasOwnProperty.call(json, "value")) {
-        compiledReader(desc)(message, json.value, ctx);
+        const value = json.value;
+        readMessage(msg, value, ctx);
     }
     else {
         const copy = Object.assign({}, json);
         // biome-ignore lint/performance/noDelete: <explanation>
         delete copy["@type"];
-        compiledReader(desc)(message, copy, ctx);
+        readMessage(msg, copy, ctx);
     }
-    anyPack(desc, message, any);
+    anyPack(msg.desc, msg.message, any);
 }
 function timestampFromJson(timestamp, json) {
     if (typeof json !== "string") {
@@ -923,7 +626,8 @@ function timestampFromJson(timestamp, json) {
     if (Number.isNaN(ms)) {
         throw new Error(`cannot decode message ${timestamp.$typeName} from JSON: invalid RFC 3339 string`);
     }
-    if (ms < timestampMsMin || ms > timestampMsMax) {
+    if (ms < Date.parse("0001-01-01T00:00:00Z") ||
+        ms > Date.parse("9999-12-31T23:59:59Z")) {
         throw new Error(`cannot decode message ${timestamp.$typeName} from JSON: must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive`);
     }
     timestamp.seconds = protoInt64.parse(ms / 1000);
@@ -943,7 +647,7 @@ function durationFromJson(duration, json) {
         throw new Error(`cannot decode message ${duration.$typeName} from JSON: ${formatVal(json)}`);
     }
     const longSeconds = Number(match[1]);
-    if (longSeconds > durationSecondsMax || longSeconds < durationSecondsMin) {
+    if (longSeconds > 315576000000 || longSeconds < -315576000000) {
         throw new Error(`cannot decode message ${duration.$typeName} from JSON: ${formatVal(json)}`);
     }
     duration.seconds = protoInt64.parse(longSeconds);
@@ -974,12 +678,10 @@ function structFromJson(struct, json, ctx) {
     if (typeof json != "object" || json == null || Array.isArray(json)) {
         throw new Error(`cannot decode message ${struct.$typeName} from JSON ${formatVal(json)}`);
     }
-    const keys = Object.keys(json);
-    for (let i = 0; i < keys.length; i++) {
-        const key = keys[i];
-        const parsedValue = create(ValueSchema);
-        valueFromJson(parsedValue, json[key], ctx);
-        struct.fields[key] = parsedValue;
+    for (const [k, v] of Object.entries(json)) {
+        const parsedV = create(ValueSchema);
+        valueFromJson(parsedV, v, ctx);
+        struct.fields[k] = parsedV;
     }
 }
 function valueFromJson(value, json, ctx) {
@@ -1021,9 +723,9 @@ function listValueFromJson(listValue, json, ctx) {
     if (!Array.isArray(json)) {
         throw new Error(`cannot decode message ${listValue.$typeName} from JSON ${formatVal(json)}`);
     }
-    for (let i = 0; i < json.length; i++) {
+    for (const e of json) {
         const value = create(ValueSchema);
-        valueFromJson(value, json[i], ctx);
+        valueFromJson(value, e, ctx);
         listValue.values.push(value);
     }
 }