@code-yeongyu/senpi 2026.8.19 → 2026.8.20-2

package/node_modules/@bufbuild/protobuf/dist/esm/reflect/message.d.ts

@@ -0,0 +1,49 @@
+import type { DescField, DescMessage } from "../descriptors.js";
+import type { JsonObject, JsonValue } from "../json-value.js";
+import type { Struct } from "../wkt/gen/google/protobuf/struct_pb.js";
+/**
+ * Mapper between the local representation of a message field value
+ * and the message it represents. For most fields, the local value is the
+ * message itself. Types from google/protobuf/wrappers.proto are unwrapped
+ * to the wrapped scalar value when used in a singular field that is not
+ * part of a oneof group, and google.protobuf.Struct is represented with
+ * JsonObject when used in a field, except when used in
+ * google.protobuf.Value.
+ *
+ * @private
+ */
+export interface LocalMessageMapper {
+    /**
+     * Wrap a local value in the message it represents. For undefined - an
+     * unset field - a new message is created. Like the reflect API, wrapping
+     * an existing Struct field value creates a normalized copy, so that
+     * merging does not mutate the previous value in place.
+     */
+    toMessage(local: unknown): Record<string, unknown>;
+    /**
+     * Convert a message to the local representation of the field value.
+     */
+    toLocal(message: Record<string, unknown>): unknown;
+}
+/**
+ * Return the conversions between the local representation of the field
+ * value and the message it represents.
+ *
+ * @private
+ */
+export declare function localMessageMapper(field: DescField & {
+    message: DescMessage;
+}): LocalMessageMapper;
+/**
+ * Convert the JsonValue representation of a google.protobuf.Struct to the
+ * message representation.
+ *
+ * @private
+ */
+export declare function wktStructToReflect(json: JsonValue): Struct;
+/**
+ * Convert a google.protobuf.Struct message to its JsonValue representation.
+ *
+ * @private
+ */
+export declare function wktStructToLocal(val: Struct): JsonObject;

package/node_modules/@bufbuild/protobuf/dist/esm/reflect/message.js

@@ -0,0 +1,152 @@
+// Copyright 2021-2026 Buf Technologies, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+import { create } from "../create.js";
+import { isObject } from "./guard.js";
+import { isWrapperDesc } from "../wkt/wrappers.js";
+// google.protobuf.NullValue.NULL_VALUE;
+const NULL_VALUE = 0;
+/**
+ * Return the conversions between the local representation of the field
+ * value and the message it represents.
+ *
+ * @private
+ */
+export function localMessageMapper(field) {
+    // google.protobuf.Struct fields are stored as JsonObject.
+    if (usesJsonRepresentation(field)) {
+        return {
+            toMessage: (local) => wktStructToReflect(local),
+            toLocal: (message) => wktStructToLocal(message),
+        };
+    }
+    // Singular wrapper fields outside a oneof are unwrapped to the scalar value.
+    if (field.fieldKind == "message" &&
+        !field.oneof &&
+        isWrapperDesc(field.message)) {
+        const wrapperDesc = field.message;
+        const valueLocalName = wrapperDesc.fields[0].localName;
+        return {
+            toMessage: (local) => {
+                const message = create(wrapperDesc);
+                if (local !== undefined) {
+                    message[valueLocalName] = local;
+                }
+                return message;
+            },
+            toLocal: (message) => message[valueLocalName],
+        };
+    }
+    // For all other fields, the local value is the message itself.
+    const childDesc = field.message;
+    return {
+        toMessage: (local) => (local === undefined ? create(childDesc) : local),
+        toLocal: (message) => message,
+    };
+}
+/**
+ * Returns true if values of this field are stored as JsonValue instead of
+ * a message: google.protobuf.Struct is represented with JsonObject when
+ * used in a field, except when used in google.protobuf.Value.
+ */
+function usesJsonRepresentation(field) {
+    return (field.message.typeName == "google.protobuf.Struct" &&
+        field.parent.typeName != "google.protobuf.Value");
+}
+/**
+ * Convert the JsonValue representation of a google.protobuf.Struct to the
+ * message representation.
+ *
+ * @private
+ */
+export function wktStructToReflect(json) {
+    const struct = {
+        $typeName: "google.protobuf.Struct",
+        fields: {},
+    };
+    if (isObject(json)) {
+        for (const k of Object.keys(json)) {
+            struct.fields[k] = wktValueToReflect(json[k]);
+        }
+    }
+    return struct;
+}
+/**
+ * Convert a google.protobuf.Struct message to its JsonValue representation.
+ *
+ * @private
+ */
+export function wktStructToLocal(val) {
+    const json = {};
+    for (const k of Object.keys(val.fields)) {
+        json[k] = wktValueToLocal(val.fields[k]);
+    }
+    return json;
+}
+function wktValueToLocal(val) {
+    switch (val.kind.case) {
+        case "structValue":
+            return wktStructToLocal(val.kind.value);
+        case "listValue":
+            return val.kind.value.values.map(wktValueToLocal);
+        case "nullValue":
+        case undefined:
+            return null;
+        default:
+            return val.kind.value;
+    }
+}
+function wktValueToReflect(json) {
+    const value = {
+        $typeName: "google.protobuf.Value",
+        kind: { case: undefined },
+    };
+    switch (typeof json) {
+        case "number":
+            value.kind = { case: "numberValue", value: json };
+            break;
+        case "string":
+            value.kind = { case: "stringValue", value: json };
+            break;
+        case "boolean":
+            value.kind = { case: "boolValue", value: json };
+            break;
+        case "object":
+            if (json === null) {
+                value.kind = { case: "nullValue", value: NULL_VALUE };
+            }
+            else if (Array.isArray(json)) {
+                const listValue = {
+                    $typeName: "google.protobuf.ListValue",
+                    values: [],
+                };
+                if (Array.isArray(json)) {
+                    for (const e of json) {
+                        listValue.values.push(wktValueToReflect(e));
+                    }
+                }
+                value.kind = {
+                    case: "listValue",
+                    value: listValue,
+                };
+            }
+            else {
+                value.kind = {
+                    case: "structValue",
+                    value: wktStructToReflect(json),
+                };
+            }
+            break;
+    }
+    return value;
+}

package/node_modules/@bufbuild/protobuf/dist/esm/reflect/reflect-check.d.ts

@@ -1,4 +1,4 @@
-import { type DescField } from "../descriptors.js";
+import { type DescEnum, type DescField, type DescMessage, ScalarType } from "../descriptors.js";
 import { FieldError } from "./error.js";
 /**
  * Check whether the given field value is valid for the reflect API.
@@ -16,4 +16,30 @@ export declare function checkListItem(field: DescField & {
 export declare function checkMapEntry(field: DescField & {
     fieldKind: "map";
 }, key: unknown, value: unknown): FieldError | undefined;
+type InvalidScalarValueErr = false | "invalid UTF8" | `${string} out of range`;
+/**
+ * Return the check for values of the given scalar type.
+ *
+ * @private
+ */
+export declare function checkScalarValue(scalar: ScalarType): (value: unknown) => true | InvalidScalarValueErr;
+/**
+ * Format the reason why a value is invalid for a singular field.
+ *
+ * @private
+ */
+export declare function reasonSingular(field: {
+    scalar: ScalarType;
+    message?: undefined;
+    enum?: undefined;
+} | {
+    scalar?: undefined;
+    message: DescMessage;
+    enum?: undefined;
+} | {
+    scalar?: undefined;
+    message?: undefined;
+    enum: DescEnum;
+}, val: unknown, details?: string | false): string;
 export declare function formatVal(val: unknown): string;
+export {};

package/node_modules/@bufbuild/protobuf/dist/esm/reflect/reflect-check.js

@@ -58,7 +58,7 @@ export function checkListItem(field, index, value) {
  * Check whether the given map key and value are valid for the reflect API.
  */
 export function checkMapEntry(field, key, value) {
-    const checkKey = checkScalarValue(key, field.mapKey);
+    const checkKey = checkScalarValue(field.mapKey)(key);
     if (checkKey !== true) {
         return new FieldError(field, `invalid map key: ${reasonSingular({ scalar: field.mapKey }, key, checkKey)}`);
     }
@@ -70,97 +70,119 @@ export function checkMapEntry(field, key, value) {
 }
 function checkSingular(field, value) {
     if (field.scalar !== undefined) {
-        return checkScalarValue(value, field.scalar);
+        return checkScalarValue(field.scalar)(value);
     }
     if (field.enum !== undefined) {
         if (field.enum.open) {
             // Open enums accept unrecognized values, but enum values are always
             // int32 (see https://protobuf.dev/programming-guides/proto3/#enum).
-            return checkScalarValue(value, ScalarType.INT32);
+            return checkScalarValue(ScalarType.INT32)(value);
         }
         return field.enum.values.some((v) => v.number === value);
     }
     return isReflectMessage(value, field.message);
 }
-function checkScalarValue(value, scalar) {
+/**
+ * Return the check for values of the given scalar type.
+ *
+ * @private
+ */
+export function checkScalarValue(scalar) {
     switch (scalar) {
         case ScalarType.DOUBLE:
-            return typeof value == "number";
+            return (value) => typeof value == "number";
         case ScalarType.FLOAT:
-            if (typeof value != "number") {
-                return false;
-            }
-            if (Number.isNaN(value) || !Number.isFinite(value)) {
+            return (value) => {
+                if (typeof value != "number") {
+                    return false;
+                }
+                if (Number.isNaN(value) || !Number.isFinite(value)) {
+                    return true;
+                }
+                if (value > FLOAT32_MAX || value < FLOAT32_MIN) {
+                    return `${value.toFixed()} out of range`;
+                }
                 return true;
-            }
-            if (value > FLOAT32_MAX || value < FLOAT32_MIN) {
-                return `${value.toFixed()} out of range`;
-            }
-            return true;
+            };
         case ScalarType.INT32:
         case ScalarType.SFIXED32:
         case ScalarType.SINT32:
             // signed
-            if (typeof value !== "number" || !Number.isInteger(value)) {
-                return false;
-            }
-            if (value > INT32_MAX || value < INT32_MIN) {
-                return `${value.toFixed()} out of range`;
-            }
-            return true;
+            return (value) => {
+                if (typeof value !== "number" || !Number.isInteger(value)) {
+                    return false;
+                }
+                if (value > INT32_MAX || value < INT32_MIN) {
+                    return `${value.toFixed()} out of range`;
+                }
+                return true;
+            };
         case ScalarType.FIXED32:
         case ScalarType.UINT32:
             // unsigned
-            if (typeof value !== "number" || !Number.isInteger(value)) {
-                return false;
-            }
-            if (value > UINT32_MAX || value < 0) {
-                return `${value.toFixed()} out of range`;
-            }
-            return true;
+            return (value) => {
+                if (typeof value !== "number" || !Number.isInteger(value)) {
+                    return false;
+                }
+                if (value > UINT32_MAX || value < 0) {
+                    return `${value.toFixed()} out of range`;
+                }
+                return true;
+            };
         case ScalarType.BOOL:
-            return typeof value == "boolean";
+            return (value) => typeof value == "boolean";
         case ScalarType.STRING:
-            if (typeof value != "string") {
-                return false;
-            }
-            return getTextEncoding().checkUtf8(value) || "invalid UTF8";
+            return (value) => {
+                if (typeof value != "string") {
+                    return false;
+                }
+                return getTextEncoding().checkUtf8(value) || "invalid UTF8";
+            };
         case ScalarType.BYTES:
-            return value instanceof Uint8Array;
+            return (value) => value instanceof Uint8Array;
         case ScalarType.INT64:
         case ScalarType.SFIXED64:
         case ScalarType.SINT64:
             // signed
-            if (typeof value == "bigint" ||
-                typeof value == "number" ||
-                (typeof value == "string" && value.length > 0)) {
-                try {
-                    protoInt64.parse(value);
-                    return true;
-                }
-                catch (_) {
-                    return `${value} out of range`;
+            return (value) => {
+                if (typeof value == "bigint" ||
+                    typeof value == "number" ||
+                    (typeof value == "string" && value.length > 0)) {
+                    try {
+                        protoInt64.parse(value);
+                        return true;
+                    }
+                    catch (_) {
+                        return `${value} out of range`;
+                    }
                 }
-            }
-            return false;
+                return false;
+            };
         case ScalarType.FIXED64:
         case ScalarType.UINT64:
             // unsigned
-            if (typeof value == "bigint" ||
-                typeof value == "number" ||
-                (typeof value == "string" && value.length > 0)) {
-                try {
-                    protoInt64.uParse(value);
-                    return true;
-                }
-                catch (_) {
-                    return `${value} out of range`;
+            return (value) => {
+                if (typeof value == "bigint" ||
+                    typeof value == "number" ||
+                    (typeof value == "string" && value.length > 0)) {
+                    try {
+                        protoInt64.uParse(value);
+                        return true;
+                    }
+                    catch (_) {
+                        return `${value} out of range`;
+                    }
                 }
-            }
-            return false;
+                return false;
+            };
     }
 }
-function reasonSingular(field, val, details) {
+/**
+ * Format the reason why a value is invalid for a singular field.
+ *
+ * @private
+ */
+export function reasonSingular(field, val, details) {
     details =
         typeof details == "string" ? `: ${details}` : `, got ${formatVal(val)}`;
     if (field.scalar !== undefined) {

package/node_modules/@bufbuild/protobuf/dist/esm/reflect/reflect.js

@@ -20,8 +20,7 @@ import { isWrapper, isWrapperDesc } from "../wkt/wrappers.js";
 import { scalarZeroValue } from "./scalar.js";
 import { protoInt64 } from "../proto-int64.js";
 import { isObject, isReflectList, isReflectMap, isReflectMessage, } from "./guard.js";
-// google.protobuf.NullValue.NULL_VALUE;
-const NULL_VALUE = 0;
+import { wktStructToLocal, wktStructToReflect } from "./message.js";
 /**
  * Create a ReflectMessage.
  */
@@ -463,79 +462,3 @@ function longToLocal(field, value) {
     }
     return value;
 }
-function wktStructToReflect(json) {
-    const struct = {
-        $typeName: "google.protobuf.Struct",
-        fields: {},
-    };
-    if (isObject(json)) {
-        for (const [k, v] of Object.entries(json)) {
-            struct.fields[k] = wktValueToReflect(v);
-        }
-    }
-    return struct;
-}
-function wktStructToLocal(val) {
-    const json = {};
-    for (const [k, v] of Object.entries(val.fields)) {
-        json[k] = wktValueToLocal(v);
-    }
-    return json;
-}
-function wktValueToLocal(val) {
-    switch (val.kind.case) {
-        case "structValue":
-            return wktStructToLocal(val.kind.value);
-        case "listValue":
-            return val.kind.value.values.map(wktValueToLocal);
-        case "nullValue":
-        case undefined:
-            return null;
-        default:
-            return val.kind.value;
-    }
-}
-function wktValueToReflect(json) {
-    const value = {
-        $typeName: "google.protobuf.Value",
-        kind: { case: undefined },
-    };
-    switch (typeof json) {
-        case "number":
-            value.kind = { case: "numberValue", value: json };
-            break;
-        case "string":
-            value.kind = { case: "stringValue", value: json };
-            break;
-        case "boolean":
-            value.kind = { case: "boolValue", value: json };
-            break;
-        case "object":
-            if (json === null) {
-                value.kind = { case: "nullValue", value: NULL_VALUE };
-            }
-            else if (Array.isArray(json)) {
-                const listValue = {
-                    $typeName: "google.protobuf.ListValue",
-                    values: [],
-                };
-                if (Array.isArray(json)) {
-                    for (const e of json) {
-                        listValue.values.push(wktValueToReflect(e));
-                    }
-                }
-                value.kind = {
-                    case: "listValue",
-                    value: listValue,
-                };
-            }
-            else {
-                value.kind = {
-                    case: "structValue",
-                    value: wktStructToReflect(json),
-                };
-            }
-            break;
-    }
-    return value;
-}

package/node_modules/@bufbuild/protobuf/dist/esm/registry.js

@@ -575,6 +575,7 @@ function newField(proto, parentOrFile, reg, oneof, mapEntries) {
         longAsString: false,
         getDefaultValue: undefined,
     };
+    let toStr;
     if (isExtension) {
         // extension field
         const file = parentOrFile.kind == "file" ? parentOrFile : parentOrFile.file;
@@ -586,7 +587,7 @@ function newField(proto, parentOrFile, reg, oneof, mapEntries) {
         field.oneof = undefined;
         field.typeName = typeName;
         field.jsonName = `[${typeName}]`; // option json_name is not allowed on extension fields
-        field.toString = () => `extension ${typeName}`;
+        toStr = () => `extension ${typeName}`;
         const extendee = reg.getMessage(trimLeadingDot(proto.extendee));
         assert(extendee, `invalid FieldDescriptorProto: extendee ${proto.extendee} not found`);
         field.extendee = extendee;
@@ -601,8 +602,16 @@ function newField(proto, parentOrFile, reg, oneof, mapEntries) {
             ? protoCamelCase(proto.name)
             : safeObjectProperty(protoCamelCase(proto.name));
         field.jsonName = proto.jsonName;
-        field.toString = () => `field ${parent.typeName}.${proto.name}`;
-    }
+        toStr = () => `field ${parent.typeName}.${proto.name}`;
+    }
+    // A plain assignment throws where built-in prototypes are frozen. The
+    // attributes match what an assignment produces.
+    Object.defineProperty(field, "toString", {
+        value: toStr,
+        writable: true,
+        enumerable: true,
+        configurable: true,
+    });
     const label = proto.label;
     const type = proto.type;
     const jstype = (_c = proto.options) === null || _c === void 0 ? void 0 : _c.jstype;

package/node_modules/@bufbuild/protobuf/dist/esm/to-binary.d.ts

@@ -19,6 +19,10 @@ export interface BinaryWriteOptions {
 }
 export declare function toBinary<Desc extends DescMessage>(schema: Desc, message: MessageShape<Desc>, options?: Partial<BinaryWriteOptions>): Uint8Array<ArrayBuffer>;
 /**
+ * Write a single field to binary format, if it is set. Used to serialize
+ * extensions: extensions always have explicit presence, so an extension
+ * value that was just set on the container is always written.
+ *
  * @private
  */
 export declare function writeField(writer: BinaryWriter, opts: BinaryWriteOptions, msg: ReflectMessage, field: DescField): void;