@code-yeongyu/senpi 2026.8.19 → 2026.8.20-2

package/node_modules/@bufbuild/protobuf/dist/commonjs/wire/binary-encoding.js

@@ -80,34 +80,55 @@ exports.INT32_MAX = 0x7fffffff;
  */
 exports.INT32_MIN = -0x80000000;
 class BinaryWriter {
-    constructor(encodeUtf8 = (0, text_encoding_js_1.getTextEncoding)().encodeUtf8) {
-        this.encodeUtf8 = encodeUtf8;
+    constructor(encodeUtf8) {
         /**
-         * Previous fork states.
+         * Previous fork positions (the write position at the time
+         * `fork()` was called).
          */
-        this.stack = [];
-        this.chunks = [];
-        this.buf = [];
+        this.stackPos = [];
+        this.encodeUtf8Into = encodeUtf8
+            ? (0, text_encoding_js_1.emulateEncodeInto)(encodeUtf8)
+            : (0, text_encoding_js_1.getTextEncoding)().encodeUtf8Into;
+        this.buffer = EMPTY_BUFFER;
+        this.viewCache = EMPTY_VIEW;
+        this.pos = 0;
+    }
+    ensureCapacity(size) {
+        const required = this.pos + size;
+        if (required > this.buffer.length) {
+            let newLen = this.buffer.length || INITIAL_SIZE;
+            while (newLen < required)
+                newLen *= 2;
+            const newBuf = new Uint8Array(newLen);
+            if (this.pos > 0)
+                newBuf.set(this.buffer);
+            this.buffer = newBuf;
+        }
+    }
+    /**
+     * The DataView over `buffer`, rebuilt only if the buffer has grown since it
+     * was last used.
+     */
+    view() {
+        const bytes = this.buffer;
+        const view = this.viewCache;
+        // Since ensureCapacity() only ever replaces the buffer with a strictly larger one,
+        // equal lengths mean the view is still current. This is faster than comparing
+        // buffers directly.
+        if (view.byteLength === bytes.byteLength)
+            return view;
+        const newView = new DataView(bytes.buffer);
+        this.viewCache = newView;
+        return newView;
     }
     /**
      * Return all bytes written and reset this writer.
      */
     finish() {
-        if (this.buf.length) {
-            this.chunks.push(new Uint8Array(this.buf)); // flush the buffer
-            this.buf = [];
-        }
-        let len = 0;
-        for (let i = 0; i < this.chunks.length; i++)
-            len += this.chunks[i].length;
-        let bytes = new Uint8Array(len);
-        let offset = 0;
-        for (let i = 0; i < this.chunks.length; i++) {
-            bytes.set(this.chunks[i], offset);
-            offset += this.chunks[i].length;
-        }
-        this.chunks = [];
-        return bytes;
+        const result = this.buffer.slice(0, this.pos);
+        this.pos = 0;
+        this.stackPos = [];
+        return result;
     }
     /**
      * Start a new fork for length-delimited data like a message
@@ -116,9 +137,11 @@ class BinaryWriter {
      * Must be joined later with `join()`.
      */
     fork() {
-        this.stack.push({ chunks: this.chunks, buf: this.buf });
-        this.chunks = [];
-        this.buf = [];
+        this.stackPos.push(this.pos);
+        // Reserve room for the length prefix. Payloads under 128 bytes, fairly
+        // common, will need no copy in join().
+        this.ensureCapacity(DEFAULT_LEN_PREFIX_SIZE);
+        this.buffer[this.pos++] = 0;
         return this;
     }
     /**
@@ -126,17 +149,24 @@ class BinaryWriter {
      * return to the previous state.
      */
     join() {
-        // get chunk of fork
-        let chunk = this.finish();
-        // restore previous state
-        let prev = this.stack.pop();
-        if (!prev)
+        const forkPos = this.stackPos.pop();
+        if (forkPos === undefined)
             throw new Error("invalid state, fork stack empty");
-        this.chunks = prev.chunks;
-        this.buf = prev.buf;
-        // write length of chunk as varint
-        this.uint32(chunk.byteLength);
-        return this.raw(chunk);
+        // fork() presumed the payload would fit the prefix it reserved. If it
+        // doesn't, we need to shift the bytes we just wrote.
+        const len = this.pos - forkPos - DEFAULT_LEN_PREFIX_SIZE;
+        const lenPrefixSize = varint32Size(len);
+        if (lenPrefixSize > DEFAULT_LEN_PREFIX_SIZE) {
+            // Widening pushes the payload past the end of the buffer, so grow first:
+            // copyWithin clamps to the buffer instead of throwing, so a short buffer
+            // would silently drop the tail of the payload.
+            this.ensureCapacity(lenPrefixSize - DEFAULT_LEN_PREFIX_SIZE);
+            this.buffer.copyWithin(forkPos + lenPrefixSize, forkPos + DEFAULT_LEN_PREFIX_SIZE, this.pos);
+        }
+        this.pos = forkPos;
+        this.uint32(len);
+        this.pos += len;
+        return this;
     }
     /**
      * Writes a tag (field number and wire type).
@@ -152,11 +182,9 @@ class BinaryWriter {
      * Write a chunk of raw bytes.
      */
     raw(chunk) {
-        if (this.buf.length) {
-            this.chunks.push(new Uint8Array(this.buf));
-            this.buf = [];
-        }
-        this.chunks.push(chunk);
+        this.ensureCapacity(chunk.length);
+        this.buffer.set(chunk, this.pos);
+        this.pos += chunk.length;
         return this;
     }
     /**
@@ -164,12 +192,18 @@ class BinaryWriter {
      */
     uint32(value) {
         assertUInt32(value);
-        // write value as varint 32, inlined for speed
+        // uint32 varints are at most 5 bytes; reserve once and avoid per-byte
+        // capacity checks.
+        this.ensureCapacity(5);
+        if (value < 0x80) {
+            this.buffer[this.pos++] = value;
+            return this;
+        }
         while (value > 0x7f) {
-            this.buf.push((value & 0x7f) | 0x80);
-            value = value >>> 7;
+            this.buffer[this.pos++] = (value & 0x7f) | 0x80;
+            value >>>= 7;
         }
-        this.buf.push(value);
+        this.buffer[this.pos++] = value;
         return this;
     }
     /**
@@ -177,101 +211,158 @@ class BinaryWriter {
      */
     int32(value) {
         assertInt32(value);
-        (0, varint_js_1.varint32write)(value, this.buf);
+        if (value >= 0) {
+            return this.uint32(value);
+        }
+        // Negative: sign-extend to 64 bits, encodes to 10 bytes.
+        this.ensureCapacity(10);
+        for (let i = 0; i < 9; i++) {
+            this.buffer[this.pos++] = (value & 0x7f) | 0x80;
+            value >>= 7;
+        }
+        this.buffer[this.pos++] = 1;
         return this;
     }
     /**
      * Write a `bool` value, a varint.
      */
     bool(value) {
-        this.buf.push(value ? 1 : 0);
+        this.ensureCapacity(1);
+        this.buffer[this.pos++] = value ? 1 : 0;
         return this;
     }
     /**
      * Write a `bytes` value, length-delimited arbitrary data.
      */
     bytes(value) {
-        this.uint32(value.byteLength); // write length of chunk as varint
+        this.uint32(value.byteLength);
         return this.raw(value);
     }
     /**
      * Write a `string` value, length-delimited data converted to UTF-8 text.
      */
     string(value) {
-        let chunk = this.encodeUtf8(value);
-        this.uint32(chunk.byteLength); // write length of chunk as varint
-        return this.raw(chunk);
+        // TextEncoder.encode() coerces its argument to string, but encodeInto()
+        // rejects non-strings.
+        if (typeof value !== "string") {
+            value = String(value);
+        }
+        const len = value.length;
+        // Fast path for ASCII.
+        if (len <= ASCII_MAX_LENGTH) {
+            this.ensureCapacity(len + 1);
+            const ascii = this.buffer;
+            let pos = this.pos;
+            ascii[pos++] = len;
+            let i = 0;
+            for (; i < len; i++) {
+                const code = value.charCodeAt(i);
+                if (code > 0x7f)
+                    break;
+                ascii[pos++] = code;
+            }
+            if (i == len) {
+                this.pos = pos;
+                return this;
+            }
+        }
+        // encodeUtf8Into needs the full-length buffer upfront. The length prefix
+        // can be upto 5 bytes, and a UTF-16 code unit takes at most 3 UTF-8 bytes.
+        this.ensureCapacity(len * 3 + 5);
+        // The length prefix goes first, but the byte length is only known after
+        // encoding. We guess the final varint size here (assuming most text is
+        // ASCII) and then encode.
+        const lenPrefixSizeGuess = varint32Size(len);
+        const buf = this.buffer;
+        const start = this.pos;
+        const { written } = this.encodeUtf8Into(value, buf.subarray(start + lenPrefixSizeGuess));
+        // If our guess was incorrect, we need to shift the bytes we just wrote.
+        const lenPrefixSize = varint32Size(written);
+        if (lenPrefixSize != lenPrefixSizeGuess) {
+            buf.copyWithin(start + lenPrefixSize, start + lenPrefixSizeGuess, start + lenPrefixSizeGuess + written);
+        }
+        // Write the lenPrefix and advance the pos.
+        this.uint32(written);
+        this.pos += written;
+        return this;
     }
     /**
      * Write a `float` value, 32-bit floating point number.
      */
     float(value) {
         assertFloat32(value);
-        let chunk = new Uint8Array(4);
-        new DataView(chunk.buffer).setFloat32(0, value, true);
-        return this.raw(chunk);
+        this.ensureCapacity(4);
+        this.view().setFloat32(this.pos, value, true);
+        this.pos += 4;
+        return this;
     }
     /**
      * Write a `double` value, a 64-bit floating point number.
      */
     double(value) {
-        let chunk = new Uint8Array(8);
-        new DataView(chunk.buffer).setFloat64(0, value, true);
-        return this.raw(chunk);
+        this.ensureCapacity(8);
+        this.view().setFloat64(this.pos, value, true);
+        this.pos += 8;
+        return this;
     }
     /**
      * Write a `fixed32` value, an unsigned, fixed-length 32-bit integer.
      */
     fixed32(value) {
         assertUInt32(value);
-        let chunk = new Uint8Array(4);
-        new DataView(chunk.buffer).setUint32(0, value, true);
-        return this.raw(chunk);
+        this.ensureCapacity(4);
+        this.view().setUint32(this.pos, value, true);
+        this.pos += 4;
+        return this;
     }
     /**
      * Write a `sfixed32` value, a signed, fixed-length 32-bit integer.
      */
     sfixed32(value) {
         assertInt32(value);
-        let chunk = new Uint8Array(4);
-        new DataView(chunk.buffer).setInt32(0, value, true);
-        return this.raw(chunk);
+        this.ensureCapacity(4);
+        this.view().setInt32(this.pos, value, true);
+        this.pos += 4;
+        return this;
     }
     /**
      * Write a `sint32` value, a signed, zigzag-encoded 32-bit varint.
      */
     sint32(value) {
         assertInt32(value);
-        // zigzag encode
-        value = ((value << 1) ^ (value >> 31)) >>> 0;
-        (0, varint_js_1.varint32write)(value, this.buf);
-        return this;
+        // zigzag encode then emit as uint32 varint
+        return this.uint32(((value << 1) ^ (value >> 31)) >>> 0);
     }
     /**
      * Write a `sfixed64` value, a signed, fixed-length 64-bit integer.
      */
     sfixed64(value) {
-        let chunk = new Uint8Array(8), view = new DataView(chunk.buffer), tc = proto_int64_js_1.protoInt64.enc(value);
-        view.setInt32(0, tc.lo, true);
-        view.setInt32(4, tc.hi, true);
-        return this.raw(chunk);
+        const tc = proto_int64_js_1.protoInt64.enc(value);
+        this.ensureCapacity(8);
+        const view = this.view();
+        view.setInt32(this.pos, tc.lo, true);
+        view.setInt32(this.pos + 4, tc.hi, true);
+        this.pos += 8;
+        return this;
     }
     /**
      * Write a `fixed64` value, an unsigned, fixed-length 64 bit integer.
      */
     fixed64(value) {
-        let chunk = new Uint8Array(8), view = new DataView(chunk.buffer), tc = proto_int64_js_1.protoInt64.uEnc(value);
-        view.setInt32(0, tc.lo, true);
-        view.setInt32(4, tc.hi, true);
-        return this.raw(chunk);
+        const tc = proto_int64_js_1.protoInt64.uEnc(value);
+        this.ensureCapacity(8);
+        const view = this.view();
+        view.setInt32(this.pos, tc.lo, true);
+        view.setInt32(this.pos + 4, tc.hi, true);
+        this.pos += 8;
+        return this;
     }
     /**
      * Write a `int64` value, a signed 64-bit varint.
      */
     int64(value) {
-        let tc = proto_int64_js_1.protoInt64.enc(value);
-        (0, varint_js_1.varint64write)(tc.lo, tc.hi, this.buf);
-        return this;
+        const tc = proto_int64_js_1.protoInt64.enc(value);
+        return this.writeVarint64(tc.lo, tc.hi);
     }
     /**
      * Write a `sint64` value, a signed, zig-zag-encoded 64-bit varint.
@@ -280,22 +371,103 @@ class BinaryWriter {
         const tc = proto_int64_js_1.protoInt64.enc(value), 
         // zigzag encode
         sign = tc.hi >> 31, lo = (tc.lo << 1) ^ sign, hi = ((tc.hi << 1) | (tc.lo >>> 31)) ^ sign;
-        (0, varint_js_1.varint64write)(lo, hi, this.buf);
-        return this;
+        return this.writeVarint64(lo, hi);
     }
     /**
      * Write a `uint64` value, an unsigned 64-bit varint.
      */
     uint64(value) {
         const tc = proto_int64_js_1.protoInt64.uEnc(value);
-        (0, varint_js_1.varint64write)(tc.lo, tc.hi, this.buf);
+        return this.writeVarint64(tc.lo, tc.hi);
+    }
+    /**
+     * Write a 64-bit varint directly into the buffer. Accepts the value as
+     * split low/high 32-bit words.
+     *
+     * Ported from varint64write() to avoid the intermediate number[] buffer.
+     * See https://github.com/protocolbuffers/protobuf/blob/8a71927d74a4ce34efe2d8769fda198f52d20d12/js/experimental/runtime/kernel/writer.js#L344
+     */
+    writeVarint64(lo, hi) {
+        // Worst case: 10 bytes.
+        this.ensureCapacity(10);
+        const buf = this.buffer;
+        let pos = this.pos;
+        for (let i = 0; i < 28; i = i + 7) {
+            const shift = lo >>> i;
+            const hasNext = !(shift >>> 7 == 0 && hi == 0);
+            buf[pos++] = (hasNext ? shift | 0x80 : shift) & 0xff;
+            if (!hasNext) {
+                this.pos = pos;
+                return this;
+            }
+        }
+        const splitBits = ((lo >>> 28) & 0x0f) | ((hi & 0x07) << 4);
+        const hasMoreBits = !(hi >> 3 == 0);
+        buf[pos++] = (hasMoreBits ? splitBits | 0x80 : splitBits) & 0xff;
+        if (!hasMoreBits) {
+            this.pos = pos;
+            return this;
+        }
+        for (let i = 3; i < 31; i = i + 7) {
+            const shift = hi >>> i;
+            const hasNext = !(shift >>> 7 == 0);
+            buf[pos++] = (hasNext ? shift | 0x80 : shift) & 0xff;
+            if (!hasNext) {
+                this.pos = pos;
+                return this;
+            }
+        }
+        buf[pos++] = (hi >>> 31) & 0x01;
+        this.pos = pos;
         return this;
     }
 }
 exports.BinaryWriter = BinaryWriter;
+/**
+ * Capacity of the buffer allocated by the first write..
+ */
+const INITIAL_SIZE = 128;
+/**
+ * Bytes `fork()` reserves for the length prefix, betting that the payload will
+ * be under 128 bytes. `join()` fills them in, and widens them if the bet was
+ * wrong.
+ */
+const DEFAULT_LEN_PREFIX_SIZE = 1;
+/**
+ * Shared empty buffer used as the initial value before the first write.
+ * Avoids allocating and zeroing `INITIAL_SIZE` bytes per BinaryWriter when a
+ * writer is only used for a tiny message (or not used at all).
+ */
+const EMPTY_BUFFER = new Uint8Array(0);
+/**
+ * Shared empty view, paired with `EMPTY_BUFFER`. Never written to: any
+ * fixed-width write first grows the buffer, which replaces this view.
+ */
+const EMPTY_VIEW = new DataView(EMPTY_BUFFER.buffer);
+/**
+ * Longest string on the ASCII fast paths. Must stay below 0x80, so
+ * that the writer's length prefix always fits a single varint byte.
+ */
+const ASCII_MAX_LENGTH = 32;
+/**
+ * Number of bytes needed to encode `value` as an unsigned 32-bit varint.
+ */
+function varint32Size(value) {
+    if (value < 0x80)
+        return 1;
+    if (value < 0x4000)
+        return 2;
+    if (value < 0x200000)
+        return 3;
+    if (value < 0x10000000)
+        return 4;
+    return 5;
+}
 class BinaryReader {
     constructor(buf, decodeUtf8 = (0, text_encoding_js_1.getTextEncoding)().decodeUtf8) {
         this.decodeUtf8 = decodeUtf8;
+        this.varint64Lo = 0;
+        this.varint64Hi = 0;
         this.varint64 = varint_js_1.varint64read; // dirty cast for `this`
         /**
          * Read a `uint32` field, an unsigned 32 bit varint.
@@ -396,19 +568,23 @@ class BinaryReader {
      * Read a `int64` field, a signed 64-bit varint.
      */
     int64() {
-        return proto_int64_js_1.protoInt64.dec(...this.varint64());
+        this.varint64();
+        return proto_int64_js_1.protoInt64.dec(this.varint64Lo, this.varint64Hi);
     }
     /**
      * Read a `uint64` field, an unsigned 64-bit varint.
      */
     uint64() {
-        return proto_int64_js_1.protoInt64.uDec(...this.varint64());
+        this.varint64();
+        return proto_int64_js_1.protoInt64.uDec(this.varint64Lo, this.varint64Hi);
     }
     /**
      * Read a `sint64` field, a signed, zig-zag-encoded 64-bit varint.
      */
     sint64() {
-        let [lo, hi] = this.varint64();
+        this.varint64();
+        let lo = this.varint64Lo;
+        let hi = this.varint64Hi;
         // decode zig zag
         let s = -(lo & 1);
         lo = ((lo >>> 1) | ((hi & 1) << 31)) ^ s;
@@ -419,8 +595,14 @@ class BinaryReader {
      * Read a `bool` field, a variant.
      */
     bool() {
-        let [lo, hi] = this.varint64();
-        return lo !== 0 || hi !== 0;
+        // Fast path: most bools are 0x0 or 0x1.
+        const b = this.buf[this.pos];
+        if (b < 0x80) {
+            this.pos++;
+            return b !== 0;
+        }
+        this.varint64();
+        return this.varint64Lo !== 0 || this.varint64Hi !== 0;
     }
     /**
      * Read a `fixed32` field, an unsigned, fixed-length 32-bit integer.
@@ -476,7 +658,21 @@ class BinaryReader {
      * `strict` is true, throw on invalid UTF-8 instead of substituting U+FFFD.
      */
     string(strict) {
-        return this.decodeUtf8(this.bytes(), strict);
+        const bytes = this.bytes();
+        const len = bytes.length;
+        // Fast path for ASCII.
+        if (len <= ASCII_MAX_LENGTH) {
+            const codes = new Array(len);
+            for (let i = 0; i < len; i++) {
+                const byte = bytes[i];
+                if (byte > 0x7f) {
+                    return this.decodeUtf8(bytes, strict);
+                }
+                codes[i] = byte;
+            }
+            return String.fromCharCode.apply(String, codes);
+        }
+        return this.decodeUtf8(bytes, strict);
     }
 }
 exports.BinaryReader = BinaryReader;

package/node_modules/@bufbuild/protobuf/dist/commonjs/wire/index.d.ts

@@ -1,5 +1,5 @@
 export * from "./binary-encoding.js";
 export * from "./base64-encoding.js";
-export * from "./text-encoding.js";
+export { getTextEncoding, configureTextEncoding } from "./text-encoding.js";
 export * from "./text-format.js";
 export * from "./size-delimited.js";

package/node_modules/@bufbuild/protobuf/dist/commonjs/wire/index.js

@@ -27,8 +27,11 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureTextEncoding = exports.getTextEncoding = void 0;
 __exportStar(require("./binary-encoding.js"), exports);
 __exportStar(require("./base64-encoding.js"), exports);
-__exportStar(require("./text-encoding.js"), exports);
+var text_encoding_js_1 = require("./text-encoding.js");
+Object.defineProperty(exports, "getTextEncoding", { enumerable: true, get: function () { return text_encoding_js_1.getTextEncoding; } });
+Object.defineProperty(exports, "configureTextEncoding", { enumerable: true, get: function () { return text_encoding_js_1.configureTextEncoding; } });
 __exportStar(require("./text-format.js"), exports);
 __exportStar(require("./size-delimited.js"), exports);

package/node_modules/@bufbuild/protobuf/dist/commonjs/wire/text-encoding.d.ts

@@ -7,6 +7,12 @@ interface TextEncoding {
      * Encode UTF-8 text to binary.
      */
     encodeUtf8: (text: string) => Uint8Array<ArrayBuffer>;
+    /**
+     * Encode UTF-8 text to a Uint8Array. The destination must be large enough.
+     */
+    encodeUtf8Into: (text: string, dest: Uint8Array) => {
+        written: number;
+    };
     /**
      * Decode UTF-8 text from binary. If `strict` is true, throw on invalid byte
      * sequences instead of silently substituting U+FFFD. Implementations that
@@ -14,15 +20,26 @@ interface TextEncoding {
      */
     decodeUtf8: (bytes: Uint8Array, strict?: boolean) => string;
 }
+type TextEncodingConfig = Omit<TextEncoding, "encodeUtf8Into"> & Partial<Pick<TextEncoding, "encodeUtf8Into">>;
 /**
  * Protobuf-ES requires the Text Encoding API to convert UTF-8 from and to
  * binary. This WHATWG API is widely available, but it is not part of the
  * ECMAScript standard. On runtimes where it is not available, use this
  * function to provide your own implementation.
  *
+ * Providing `encodeUtf8Into` is optional for backwards compatibility. If it
+ * is omitted, we emulate it with a wrapper that calls `encodeUtf8`.
+ *
  * Note that the Text Encoding API does not provide a way to validate UTF-8.
- * Our implementation falls back to use encodeURIComponent().
+ * Our implementation uses String.prototype.isWellFormed, and falls back
+ * to use encodeURIComponent().
  */
-export declare function configureTextEncoding(textEncoding: TextEncoding): void;
+export declare function configureTextEncoding(textEncoding: TextEncodingConfig): void;
 export declare function getTextEncoding(): TextEncoding;
+/**
+ * Simplistic polyfill for encodeUtf8Into.
+ *
+ * @private
+ */
+export declare function emulateEncodeInto(encodeUtf8: (str: string) => Uint8Array): TextEncoding["encodeUtf8Into"];
 export {};