@xuzhiyang/syncvar 1.1.1

package/dist/syncvar.js

@@ -0,0 +1,2944 @@
+/*! Waterbear v1.1.1 (2026-02-09T11:56:01.356Z)
+该SDK提供一套基于 WebSocket 的变量同步、锁、RPC 与事件订阅能力，帮助前端快速搭建协同编辑、状态共享与后台任务管理场景。
+主页: https://varserver.popx.com
+*/
+
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+    typeof define === 'function' && define.amd ? define(['exports'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.WaterBear = {}));
+})(this, (function (exports) { 'use strict';
+
+    // 版本信息模块
+    class VersionInfo {
+        static Version = "1.1.1";  // 由构建时注入
+        static BuildTime = "2026-02-09T11:56:01.356Z";
+        static printInfo() {
+            globalThis.console.group('%c📦 Waterbear Info', 'color: #35495e; font-size: 14px;');
+            // 只在开发环境显示调试信息
+            {
+                globalThis.console.log('%c 🚀 当前为开发模式, 生产环境请使用 syncvar.min.js', 'color: #FF9800;');
+                globalThis.console.log('%c 🛠️ 该SDK提供一套基于 WebSocket 的变量同步、锁、RPC 与事件订阅能力，帮助前端快速搭建协同编辑、状态共享与后台任务管理场景。', 'color: #FF9800;');
+                globalThis.console.log(`%cDemo: https://varserver.popx.com/waterbear/syncvar.html`, 'color: #FF9800;');
+                globalThis.console.log(`%cDoc: https://varserver.popx.com/waterbear/api.md`, 'color: #FF9800;');
+                globalThis.console.log(`Build: ${new Date(VersionInfo.BuildTime).toLocaleString()}`);
+            }
+            globalThis.console.log(`%cVersion: v${VersionInfo.Version}`, 'color: #41b883;');
+            globalThis.console.groupEnd();
+        }
+    }
+
+    VersionInfo.printInfo();
+
+    function utf8Count(str) {
+        const strLength = str.length;
+        let byteLength = 0;
+        let pos = 0;
+        while (pos < strLength) {
+            let value = str.charCodeAt(pos++);
+            if ((value & 0xffffff80) === 0) {
+                // 1-byte
+                byteLength++;
+                continue;
+            }
+            else if ((value & 0xfffff800) === 0) {
+                // 2-bytes
+                byteLength += 2;
+            }
+            else {
+                // handle surrogate pair
+                if (value >= 0xd800 && value <= 0xdbff) {
+                    // high surrogate
+                    if (pos < strLength) {
+                        const extra = str.charCodeAt(pos);
+                        if ((extra & 0xfc00) === 0xdc00) {
+                            ++pos;
+                            value = ((value & 0x3ff) << 10) + (extra & 0x3ff) + 0x10000;
+                        }
+                    }
+                }
+                if ((value & 0xffff0000) === 0) {
+                    // 3-byte
+                    byteLength += 3;
+                }
+                else {
+                    // 4-byte
+                    byteLength += 4;
+                }
+            }
+        }
+        return byteLength;
+    }
+    function utf8EncodeJs(str, output, outputOffset) {
+        const strLength = str.length;
+        let offset = outputOffset;
+        let pos = 0;
+        while (pos < strLength) {
+            let value = str.charCodeAt(pos++);
+            if ((value & 0xffffff80) === 0) {
+                // 1-byte
+                output[offset++] = value;
+                continue;
+            }
+            else if ((value & 0xfffff800) === 0) {
+                // 2-bytes
+                output[offset++] = ((value >> 6) & 0x1f) | 0xc0;
+            }
+            else {
+                // handle surrogate pair
+                if (value >= 0xd800 && value <= 0xdbff) {
+                    // high surrogate
+                    if (pos < strLength) {
+                        const extra = str.charCodeAt(pos);
+                        if ((extra & 0xfc00) === 0xdc00) {
+                            ++pos;
+                            value = ((value & 0x3ff) << 10) + (extra & 0x3ff) + 0x10000;
+                        }
+                    }
+                }
+                if ((value & 0xffff0000) === 0) {
+                    // 3-byte
+                    output[offset++] = ((value >> 12) & 0x0f) | 0xe0;
+                    output[offset++] = ((value >> 6) & 0x3f) | 0x80;
+                }
+                else {
+                    // 4-byte
+                    output[offset++] = ((value >> 18) & 0x07) | 0xf0;
+                    output[offset++] = ((value >> 12) & 0x3f) | 0x80;
+                    output[offset++] = ((value >> 6) & 0x3f) | 0x80;
+                }
+            }
+            output[offset++] = (value & 0x3f) | 0x80;
+        }
+    }
+    // TextEncoder and TextDecoder are standardized in whatwg encoding:
+    // https://encoding.spec.whatwg.org/
+    // and available in all the modern browsers:
+    // https://caniuse.com/textencoder
+    // They are available in Node.js since v12 LTS as well:
+    // https://nodejs.org/api/globals.html#textencoder
+    const sharedTextEncoder = new TextEncoder();
+    // This threshold should be determined by benchmarking, which might vary in engines and input data.
+    // Run `npx ts-node benchmark/encode-string.ts` for details.
+    const TEXT_ENCODER_THRESHOLD = 50;
+    function utf8EncodeTE(str, output, outputOffset) {
+        sharedTextEncoder.encodeInto(str, output.subarray(outputOffset));
+    }
+    function utf8Encode(str, output, outputOffset) {
+        if (str.length > TEXT_ENCODER_THRESHOLD) {
+            utf8EncodeTE(str, output, outputOffset);
+        }
+        else {
+            utf8EncodeJs(str, output, outputOffset);
+        }
+    }
+    const CHUNK_SIZE = 4096;
+    function utf8DecodeJs(bytes, inputOffset, byteLength) {
+        let offset = inputOffset;
+        const end = offset + byteLength;
+        const units = [];
+        let result = "";
+        while (offset < end) {
+            const byte1 = bytes[offset++];
+            if ((byte1 & 0x80) === 0) {
+                // 1 byte
+                units.push(byte1);
+            }
+            else if ((byte1 & 0xe0) === 0xc0) {
+                // 2 bytes
+                const byte2 = bytes[offset++] & 0x3f;
+                units.push(((byte1 & 0x1f) << 6) | byte2);
+            }
+            else if ((byte1 & 0xf0) === 0xe0) {
+                // 3 bytes
+                const byte2 = bytes[offset++] & 0x3f;
+                const byte3 = bytes[offset++] & 0x3f;
+                units.push(((byte1 & 0x1f) << 12) | (byte2 << 6) | byte3);
+            }
+            else if ((byte1 & 0xf8) === 0xf0) {
+                // 4 bytes
+                const byte2 = bytes[offset++] & 0x3f;
+                const byte3 = bytes[offset++] & 0x3f;
+                const byte4 = bytes[offset++] & 0x3f;
+                let unit = ((byte1 & 0x07) << 0x12) | (byte2 << 0x0c) | (byte3 << 0x06) | byte4;
+                if (unit > 0xffff) {
+                    unit -= 0x10000;
+                    units.push(((unit >>> 10) & 0x3ff) | 0xd800);
+                    unit = 0xdc00 | (unit & 0x3ff);
+                }
+                units.push(unit);
+            }
+            else {
+                units.push(byte1);
+            }
+            if (units.length >= CHUNK_SIZE) {
+                result += String.fromCharCode(...units);
+                units.length = 0;
+            }
+        }
+        if (units.length > 0) {
+            result += String.fromCharCode(...units);
+        }
+        return result;
+    }
+    const sharedTextDecoder = new TextDecoder();
+    // This threshold should be determined by benchmarking, which might vary in engines and input data.
+    // Run `npx ts-node benchmark/decode-string.ts` for details.
+    const TEXT_DECODER_THRESHOLD = 200;
+    function utf8DecodeTD(bytes, inputOffset, byteLength) {
+        const stringBytes = bytes.subarray(inputOffset, inputOffset + byteLength);
+        return sharedTextDecoder.decode(stringBytes);
+    }
+    function utf8Decode(bytes, inputOffset, byteLength) {
+        if (byteLength > TEXT_DECODER_THRESHOLD) {
+            return utf8DecodeTD(bytes, inputOffset, byteLength);
+        }
+        else {
+            return utf8DecodeJs(bytes, inputOffset, byteLength);
+        }
+    }
+
+    /**
+     * ExtData is used to handle Extension Types that are not registered to ExtensionCodec.
+     */
+    class ExtData {
+        type;
+        data;
+        constructor(type, data) {
+            this.type = type;
+            this.data = data;
+        }
+    }
+
+    class DecodeError extends Error {
+        constructor(message) {
+            super(message);
+            // fix the prototype chain in a cross-platform way
+            const proto = Object.create(DecodeError.prototype);
+            Object.setPrototypeOf(this, proto);
+            Object.defineProperty(this, "name", {
+                configurable: true,
+                enumerable: false,
+                value: DecodeError.name,
+            });
+        }
+    }
+
+    // Integer Utility
+    const UINT32_MAX = 4294967295;
+    // DataView extension to handle int64 / uint64,
+    // where the actual range is 53-bits integer (a.k.a. safe integer)
+    function setUint64(view, offset, value) {
+        const high = value / 4294967296;
+        const low = value; // high bits are truncated by DataView
+        view.setUint32(offset, high);
+        view.setUint32(offset + 4, low);
+    }
+    function setInt64(view, offset, value) {
+        const high = Math.floor(value / 4294967296);
+        const low = value; // high bits are truncated by DataView
+        view.setUint32(offset, high);
+        view.setUint32(offset + 4, low);
+    }
+    function getInt64(view, offset) {
+        const high = view.getInt32(offset);
+        const low = view.getUint32(offset + 4);
+        return high * 4294967296 + low;
+    }
+    function getUint64(view, offset) {
+        const high = view.getUint32(offset);
+        const low = view.getUint32(offset + 4);
+        return high * 4294967296 + low;
+    }
+
+    // https://github.com/msgpack/msgpack/blob/master/spec.md#timestamp-extension-type
+    const EXT_TIMESTAMP = -1;
+    const TIMESTAMP32_MAX_SEC = 0x100000000 - 1; // 32-bit unsigned int
+    const TIMESTAMP64_MAX_SEC = 0x400000000 - 1; // 34-bit unsigned int
+    function encodeTimeSpecToTimestamp({ sec, nsec }) {
+        if (sec >= 0 && nsec >= 0 && sec <= TIMESTAMP64_MAX_SEC) {
+            // Here sec >= 0 && nsec >= 0
+            if (nsec === 0 && sec <= TIMESTAMP32_MAX_SEC) {
+                // timestamp 32 = { sec32 (unsigned) }
+                const rv = new Uint8Array(4);
+                const view = new DataView(rv.buffer);
+                view.setUint32(0, sec);
+                return rv;
+            }
+            else {
+                // timestamp 64 = { nsec30 (unsigned), sec34 (unsigned) }
+                const secHigh = sec / 0x100000000;
+                const secLow = sec & 0xffffffff;
+                const rv = new Uint8Array(8);
+                const view = new DataView(rv.buffer);
+                // nsec30 | secHigh2
+                view.setUint32(0, (nsec << 2) | (secHigh & 0x3));
+                // secLow32
+                view.setUint32(4, secLow);
+                return rv;
+            }
+        }
+        else {
+            // timestamp 96 = { nsec32 (unsigned), sec64 (signed) }
+            const rv = new Uint8Array(12);
+            const view = new DataView(rv.buffer);
+            view.setUint32(0, nsec);
+            setInt64(view, 4, sec);
+            return rv;
+        }
+    }
+    function encodeDateToTimeSpec(date) {
+        const msec = date.getTime();
+        const sec = Math.floor(msec / 1e3);
+        const nsec = (msec - sec * 1e3) * 1e6;
+        // Normalizes { sec, nsec } to ensure nsec is unsigned.
+        const nsecInSec = Math.floor(nsec / 1e9);
+        return {
+            sec: sec + nsecInSec,
+            nsec: nsec - nsecInSec * 1e9,
+        };
+    }
+    function encodeTimestampExtension(object) {
+        if (object instanceof Date) {
+            const timeSpec = encodeDateToTimeSpec(object);
+            return encodeTimeSpecToTimestamp(timeSpec);
+        }
+        else {
+            return null;
+        }
+    }
+    function decodeTimestampToTimeSpec(data) {
+        const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+        // data may be 32, 64, or 96 bits
+        switch (data.byteLength) {
+            case 4: {
+                // timestamp 32 = { sec32 }
+                const sec = view.getUint32(0);
+                const nsec = 0;
+                return { sec, nsec };
+            }
+            case 8: {
+                // timestamp 64 = { nsec30, sec34 }
+                const nsec30AndSecHigh2 = view.getUint32(0);
+                const secLow32 = view.getUint32(4);
+                const sec = (nsec30AndSecHigh2 & 0x3) * 0x100000000 + secLow32;
+                const nsec = nsec30AndSecHigh2 >>> 2;
+                return { sec, nsec };
+            }
+            case 12: {
+                // timestamp 96 = { nsec32 (unsigned), sec64 (signed) }
+                const sec = getInt64(view, 4);
+                const nsec = view.getUint32(0);
+                return { sec, nsec };
+            }
+            default:
+                throw new DecodeError(`Unrecognized data size for timestamp (expected 4, 8, or 12): ${data.length}`);
+        }
+    }
+    function decodeTimestampExtension(data) {
+        const timeSpec = decodeTimestampToTimeSpec(data);
+        return new Date(timeSpec.sec * 1e3 + timeSpec.nsec / 1e6);
+    }
+    const timestampExtension = {
+        type: EXT_TIMESTAMP,
+        encode: encodeTimestampExtension,
+        decode: decodeTimestampExtension,
+    };
+
+    // ExtensionCodec to handle MessagePack extensions
+    class ExtensionCodec {
+        static defaultCodec = new ExtensionCodec();
+        // ensures ExtensionCodecType<X> matches ExtensionCodec<X>
+        // this will make type errors a lot more clear
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        __brand;
+        // built-in extensions
+        builtInEncoders = [];
+        builtInDecoders = [];
+        // custom extensions
+        encoders = [];
+        decoders = [];
+        constructor() {
+            this.register(timestampExtension);
+        }
+        register({ type, encode, decode, }) {
+            if (type >= 0) {
+                // custom extensions
+                this.encoders[type] = encode;
+                this.decoders[type] = decode;
+            }
+            else {
+                // built-in extensions
+                const index = -1 - type;
+                this.builtInEncoders[index] = encode;
+                this.builtInDecoders[index] = decode;
+            }
+        }
+        tryToEncode(object, context) {
+            // built-in extensions
+            for (let i = 0; i < this.builtInEncoders.length; i++) {
+                const encodeExt = this.builtInEncoders[i];
+                if (encodeExt != null) {
+                    const data = encodeExt(object, context);
+                    if (data != null) {
+                        const type = -1 - i;
+                        return new ExtData(type, data);
+                    }
+                }
+            }
+            // custom extensions
+            for (let i = 0; i < this.encoders.length; i++) {
+                const encodeExt = this.encoders[i];
+                if (encodeExt != null) {
+                    const data = encodeExt(object, context);
+                    if (data != null) {
+                        const type = i;
+                        return new ExtData(type, data);
+                    }
+                }
+            }
+            if (object instanceof ExtData) {
+                // to keep ExtData as is
+                return object;
+            }
+            return null;
+        }
+        decode(data, type, context) {
+            const decodeExt = type < 0 ? this.builtInDecoders[-1 - type] : this.decoders[type];
+            if (decodeExt) {
+                return decodeExt(data, type, context);
+            }
+            else {
+                // decode() does not fail, returns ExtData instead.
+                return new ExtData(type, data);
+            }
+        }
+    }
+
+    function isArrayBufferLike(buffer) {
+        return (buffer instanceof ArrayBuffer || (typeof SharedArrayBuffer !== "undefined" && buffer instanceof SharedArrayBuffer));
+    }
+    function ensureUint8Array(buffer) {
+        if (buffer instanceof Uint8Array) {
+            return buffer;
+        }
+        else if (ArrayBuffer.isView(buffer)) {
+            return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+        }
+        else if (isArrayBufferLike(buffer)) {
+            return new Uint8Array(buffer);
+        }
+        else {
+            // ArrayLike<number>
+            return Uint8Array.from(buffer);
+        }
+    }
+
+    const DEFAULT_MAX_DEPTH = 100;
+    const DEFAULT_INITIAL_BUFFER_SIZE = 2048;
+    class Encoder {
+        extensionCodec;
+        context;
+        useBigInt64;
+        maxDepth;
+        initialBufferSize;
+        sortKeys;
+        forceFloat32;
+        ignoreUndefined;
+        forceIntegerToFloat;
+        pos;
+        view;
+        bytes;
+        entered = false;
+        constructor(options) {
+            this.extensionCodec = options?.extensionCodec ?? ExtensionCodec.defaultCodec;
+            this.context = options?.context; // needs a type assertion because EncoderOptions has no context property when ContextType is undefined
+            this.useBigInt64 = options?.useBigInt64 ?? false;
+            this.maxDepth = options?.maxDepth ?? DEFAULT_MAX_DEPTH;
+            this.initialBufferSize = options?.initialBufferSize ?? DEFAULT_INITIAL_BUFFER_SIZE;
+            this.sortKeys = options?.sortKeys ?? false;
+            this.forceFloat32 = options?.forceFloat32 ?? false;
+            this.ignoreUndefined = options?.ignoreUndefined ?? false;
+            this.forceIntegerToFloat = options?.forceIntegerToFloat ?? false;
+            this.pos = 0;
+            this.view = new DataView(new ArrayBuffer(this.initialBufferSize));
+            this.bytes = new Uint8Array(this.view.buffer);
+        }
+        clone() {
+            // Because of slightly special argument `context`,
+            // type assertion is needed.
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+            return new Encoder({
+                extensionCodec: this.extensionCodec,
+                context: this.context,
+                useBigInt64: this.useBigInt64,
+                maxDepth: this.maxDepth,
+                initialBufferSize: this.initialBufferSize,
+                sortKeys: this.sortKeys,
+                forceFloat32: this.forceFloat32,
+                ignoreUndefined: this.ignoreUndefined,
+                forceIntegerToFloat: this.forceIntegerToFloat,
+            });
+        }
+        reinitializeState() {
+            this.pos = 0;
+        }
+        /**
+         * This is almost equivalent to {@link Encoder#encode}, but it returns an reference of the encoder's internal buffer and thus much faster than {@link Encoder#encode}.
+         *
+         * @returns Encodes the object and returns a shared reference the encoder's internal buffer.
+         */
+        encodeSharedRef(object) {
+            if (this.entered) {
+                const instance = this.clone();
+                return instance.encodeSharedRef(object);
+            }
+            try {
+                this.entered = true;
+                this.reinitializeState();
+                this.doEncode(object, 1);
+                return this.bytes.subarray(0, this.pos);
+            }
+            finally {
+                this.entered = false;
+            }
+        }
+        /**
+         * @returns Encodes the object and returns a copy of the encoder's internal buffer.
+         */
+        encode(object) {
+            if (this.entered) {
+                const instance = this.clone();
+                return instance.encode(object);
+            }
+            try {
+                this.entered = true;
+                this.reinitializeState();
+                this.doEncode(object, 1);
+                return this.bytes.slice(0, this.pos);
+            }
+            finally {
+                this.entered = false;
+            }
+        }
+        doEncode(object, depth) {
+            if (depth > this.maxDepth) {
+                throw new Error(`Too deep objects in depth ${depth}`);
+            }
+            if (object == null) {
+                this.encodeNil();
+            }
+            else if (typeof object === "boolean") {
+                this.encodeBoolean(object);
+            }
+            else if (typeof object === "number") {
+                if (!this.forceIntegerToFloat) {
+                    this.encodeNumber(object);
+                }
+                else {
+                    this.encodeNumberAsFloat(object);
+                }
+            }
+            else if (typeof object === "string") {
+                this.encodeString(object);
+            }
+            else if (this.useBigInt64 && typeof object === "bigint") {
+                this.encodeBigInt64(object);
+            }
+            else {
+                this.encodeObject(object, depth);
+            }
+        }
+        ensureBufferSizeToWrite(sizeToWrite) {
+            const requiredSize = this.pos + sizeToWrite;
+            if (this.view.byteLength < requiredSize) {
+                this.resizeBuffer(requiredSize * 2);
+            }
+        }
+        resizeBuffer(newSize) {
+            const newBuffer = new ArrayBuffer(newSize);
+            const newBytes = new Uint8Array(newBuffer);
+            const newView = new DataView(newBuffer);
+            newBytes.set(this.bytes);
+            this.view = newView;
+            this.bytes = newBytes;
+        }
+        encodeNil() {
+            this.writeU8(0xc0);
+        }
+        encodeBoolean(object) {
+            if (object === false) {
+                this.writeU8(0xc2);
+            }
+            else {
+                this.writeU8(0xc3);
+            }
+        }
+        encodeNumber(object) {
+            if (!this.forceIntegerToFloat && Number.isSafeInteger(object)) {
+                if (object >= 0) {
+                    if (object < 0x80) {
+                        // positive fixint
+                        this.writeU8(object);
+                    }
+                    else if (object < 0x100) {
+                        // uint 8
+                        this.writeU8(0xcc);
+                        this.writeU8(object);
+                    }
+                    else if (object < 0x10000) {
+                        // uint 16
+                        this.writeU8(0xcd);
+                        this.writeU16(object);
+                    }
+                    else if (object < 0x100000000) {
+                        // uint 32
+                        this.writeU8(0xce);
+                        this.writeU32(object);
+                    }
+                    else if (!this.useBigInt64) {
+                        // uint 64
+                        this.writeU8(0xcf);
+                        this.writeU64(object);
+                    }
+                    else {
+                        this.encodeNumberAsFloat(object);
+                    }
+                }
+                else {
+                    if (object >= -32) {
+                        // negative fixint
+                        this.writeU8(0xe0 | (object + 0x20));
+                    }
+                    else if (object >= -128) {
+                        // int 8
+                        this.writeU8(0xd0);
+                        this.writeI8(object);
+                    }
+                    else if (object >= -32768) {
+                        // int 16
+                        this.writeU8(0xd1);
+                        this.writeI16(object);
+                    }
+                    else if (object >= -2147483648) {
+                        // int 32
+                        this.writeU8(0xd2);
+                        this.writeI32(object);
+                    }
+                    else if (!this.useBigInt64) {
+                        // int 64
+                        this.writeU8(0xd3);
+                        this.writeI64(object);
+                    }
+                    else {
+                        this.encodeNumberAsFloat(object);
+                    }
+                }
+            }
+            else {
+                this.encodeNumberAsFloat(object);
+            }
+        }
+        encodeNumberAsFloat(object) {
+            if (this.forceFloat32) {
+                // float 32
+                this.writeU8(0xca);
+                this.writeF32(object);
+            }
+            else {
+                // float 64
+                this.writeU8(0xcb);
+                this.writeF64(object);
+            }
+        }
+        encodeBigInt64(object) {
+            if (object >= BigInt(0)) {
+                // uint 64
+                this.writeU8(0xcf);
+                this.writeBigUint64(object);
+            }
+            else {
+                // int 64
+                this.writeU8(0xd3);
+                this.writeBigInt64(object);
+            }
+        }
+        writeStringHeader(byteLength) {
+            if (byteLength < 32) {
+                // fixstr
+                this.writeU8(0xa0 + byteLength);
+            }
+            else if (byteLength < 0x100) {
+                // str 8
+                this.writeU8(0xd9);
+                this.writeU8(byteLength);
+            }
+            else if (byteLength < 0x10000) {
+                // str 16
+                this.writeU8(0xda);
+                this.writeU16(byteLength);
+            }
+            else if (byteLength < 0x100000000) {
+                // str 32
+                this.writeU8(0xdb);
+                this.writeU32(byteLength);
+            }
+            else {
+                throw new Error(`Too long string: ${byteLength} bytes in UTF-8`);
+            }
+        }
+        encodeString(object) {
+            const maxHeaderSize = 1 + 4;
+            const byteLength = utf8Count(object);
+            this.ensureBufferSizeToWrite(maxHeaderSize + byteLength);
+            this.writeStringHeader(byteLength);
+            utf8Encode(object, this.bytes, this.pos);
+            this.pos += byteLength;
+        }
+        encodeObject(object, depth) {
+            // try to encode objects with custom codec first of non-primitives
+            const ext = this.extensionCodec.tryToEncode(object, this.context);
+            if (ext != null) {
+                this.encodeExtension(ext);
+            }
+            else if (Array.isArray(object)) {
+                this.encodeArray(object, depth);
+            }
+            else if (ArrayBuffer.isView(object)) {
+                this.encodeBinary(object);
+            }
+            else if (typeof object === "object") {
+                this.encodeMap(object, depth);
+            }
+            else {
+                // symbol, function and other special object come here unless extensionCodec handles them.
+                throw new Error(`Unrecognized object: ${Object.prototype.toString.apply(object)}`);
+            }
+        }
+        encodeBinary(object) {
+            const size = object.byteLength;
+            if (size < 0x100) {
+                // bin 8
+                this.writeU8(0xc4);
+                this.writeU8(size);
+            }
+            else if (size < 0x10000) {
+                // bin 16
+                this.writeU8(0xc5);
+                this.writeU16(size);
+            }
+            else if (size < 0x100000000) {
+                // bin 32
+                this.writeU8(0xc6);
+                this.writeU32(size);
+            }
+            else {
+                throw new Error(`Too large binary: ${size}`);
+            }
+            const bytes = ensureUint8Array(object);
+            this.writeU8a(bytes);
+        }
+        encodeArray(object, depth) {
+            const size = object.length;
+            if (size < 16) {
+                // fixarray
+                this.writeU8(0x90 + size);
+            }
+            else if (size < 0x10000) {
+                // array 16
+                this.writeU8(0xdc);
+                this.writeU16(size);
+            }
+            else if (size < 0x100000000) {
+                // array 32
+                this.writeU8(0xdd);
+                this.writeU32(size);
+            }
+            else {
+                throw new Error(`Too large array: ${size}`);
+            }
+            for (const item of object) {
+                this.doEncode(item, depth + 1);
+            }
+        }
+        countWithoutUndefined(object, keys) {
+            let count = 0;
+            for (const key of keys) {
+                if (object[key] !== undefined) {
+                    count++;
+                }
+            }
+            return count;
+        }
+        encodeMap(object, depth) {
+            const keys = Object.keys(object);
+            if (this.sortKeys) {
+                keys.sort();
+            }
+            const size = this.ignoreUndefined ? this.countWithoutUndefined(object, keys) : keys.length;
+            if (size < 16) {
+                // fixmap
+                this.writeU8(0x80 + size);
+            }
+            else if (size < 0x10000) {
+                // map 16
+                this.writeU8(0xde);
+                this.writeU16(size);
+            }
+            else if (size < 0x100000000) {
+                // map 32
+                this.writeU8(0xdf);
+                this.writeU32(size);
+            }
+            else {
+                throw new Error(`Too large map object: ${size}`);
+            }
+            for (const key of keys) {
+                const value = object[key];
+                if (!(this.ignoreUndefined && value === undefined)) {
+                    this.encodeString(key);
+                    this.doEncode(value, depth + 1);
+                }
+            }
+        }
+        encodeExtension(ext) {
+            if (typeof ext.data === "function") {
+                const data = ext.data(this.pos + 6);
+                const size = data.length;
+                if (size >= 0x100000000) {
+                    throw new Error(`Too large extension object: ${size}`);
+                }
+                this.writeU8(0xc9);
+                this.writeU32(size);
+                this.writeI8(ext.type);
+                this.writeU8a(data);
+                return;
+            }
+            const size = ext.data.length;
+            if (size === 1) {
+                // fixext 1
+                this.writeU8(0xd4);
+            }
+            else if (size === 2) {
+                // fixext 2
+                this.writeU8(0xd5);
+            }
+            else if (size === 4) {
+                // fixext 4
+                this.writeU8(0xd6);
+            }
+            else if (size === 8) {
+                // fixext 8
+                this.writeU8(0xd7);
+            }
+            else if (size === 16) {
+                // fixext 16
+                this.writeU8(0xd8);
+            }
+            else if (size < 0x100) {
+                // ext 8
+                this.writeU8(0xc7);
+                this.writeU8(size);
+            }
+            else if (size < 0x10000) {
+                // ext 16
+                this.writeU8(0xc8);
+                this.writeU16(size);
+            }
+            else if (size < 0x100000000) {
+                // ext 32
+                this.writeU8(0xc9);
+                this.writeU32(size);
+            }
+            else {
+                throw new Error(`Too large extension object: ${size}`);
+            }
+            this.writeI8(ext.type);
+            this.writeU8a(ext.data);
+        }
+        writeU8(value) {
+            this.ensureBufferSizeToWrite(1);
+            this.view.setUint8(this.pos, value);
+            this.pos++;
+        }
+        writeU8a(values) {
+            const size = values.length;
+            this.ensureBufferSizeToWrite(size);
+            this.bytes.set(values, this.pos);
+            this.pos += size;
+        }
+        writeI8(value) {
+            this.ensureBufferSizeToWrite(1);
+            this.view.setInt8(this.pos, value);
+            this.pos++;
+        }
+        writeU16(value) {
+            this.ensureBufferSizeToWrite(2);
+            this.view.setUint16(this.pos, value);
+            this.pos += 2;
+        }
+        writeI16(value) {
+            this.ensureBufferSizeToWrite(2);
+            this.view.setInt16(this.pos, value);
+            this.pos += 2;
+        }
+        writeU32(value) {
+            this.ensureBufferSizeToWrite(4);
+            this.view.setUint32(this.pos, value);
+            this.pos += 4;
+        }
+        writeI32(value) {
+            this.ensureBufferSizeToWrite(4);
+            this.view.setInt32(this.pos, value);
+            this.pos += 4;
+        }
+        writeF32(value) {
+            this.ensureBufferSizeToWrite(4);
+            this.view.setFloat32(this.pos, value);
+            this.pos += 4;
+        }
+        writeF64(value) {
+            this.ensureBufferSizeToWrite(8);
+            this.view.setFloat64(this.pos, value);
+            this.pos += 8;
+        }
+        writeU64(value) {
+            this.ensureBufferSizeToWrite(8);
+            setUint64(this.view, this.pos, value);
+            this.pos += 8;
+        }
+        writeI64(value) {
+            this.ensureBufferSizeToWrite(8);
+            setInt64(this.view, this.pos, value);
+            this.pos += 8;
+        }
+        writeBigUint64(value) {
+            this.ensureBufferSizeToWrite(8);
+            this.view.setBigUint64(this.pos, value);
+            this.pos += 8;
+        }
+        writeBigInt64(value) {
+            this.ensureBufferSizeToWrite(8);
+            this.view.setBigInt64(this.pos, value);
+            this.pos += 8;
+        }
+    }
+
+    /**
+     * It encodes `value` in the MessagePack format and
+     * returns a byte buffer.
+     *
+     * The returned buffer is a slice of a larger `ArrayBuffer`, so you have to use its `#byteOffset` and `#byteLength` in order to convert it to another typed arrays including NodeJS `Buffer`.
+     */
+    function encode(value, options) {
+        const encoder = new Encoder(options);
+        return encoder.encodeSharedRef(value);
+    }
+
+    function prettyByte(byte) {
+        return `${byte < 0 ? "-" : ""}0x${Math.abs(byte).toString(16).padStart(2, "0")}`;
+    }
+
+    const DEFAULT_MAX_KEY_LENGTH = 16;
+    const DEFAULT_MAX_LENGTH_PER_KEY = 16;
+    class CachedKeyDecoder {
+        hit = 0;
+        miss = 0;
+        caches;
+        maxKeyLength;
+        maxLengthPerKey;
+        constructor(maxKeyLength = DEFAULT_MAX_KEY_LENGTH, maxLengthPerKey = DEFAULT_MAX_LENGTH_PER_KEY) {
+            this.maxKeyLength = maxKeyLength;
+            this.maxLengthPerKey = maxLengthPerKey;
+            // avoid `new Array(N)`, which makes a sparse array,
+            // because a sparse array is typically slower than a non-sparse array.
+            this.caches = [];
+            for (let i = 0; i < this.maxKeyLength; i++) {
+                this.caches.push([]);
+            }
+        }
+        canBeCached(byteLength) {
+            return byteLength > 0 && byteLength <= this.maxKeyLength;
+        }
+        find(bytes, inputOffset, byteLength) {
+            const records = this.caches[byteLength - 1];
+            FIND_CHUNK: for (const record of records) {
+                const recordBytes = record.bytes;
+                for (let j = 0; j < byteLength; j++) {
+                    if (recordBytes[j] !== bytes[inputOffset + j]) {
+                        continue FIND_CHUNK;
+                    }
+                }
+                return record.str;
+            }
+            return null;
+        }
+        store(bytes, value) {
+            const records = this.caches[bytes.length - 1];
+            const record = { bytes, str: value };
+            if (records.length >= this.maxLengthPerKey) {
+                // `records` are full!
+                // Set `record` to an arbitrary position.
+                records[(Math.random() * records.length) | 0] = record;
+            }
+            else {
+                records.push(record);
+            }
+        }
+        decode(bytes, inputOffset, byteLength) {
+            const cachedValue = this.find(bytes, inputOffset, byteLength);
+            if (cachedValue != null) {
+                this.hit++;
+                return cachedValue;
+            }
+            this.miss++;
+            const str = utf8DecodeJs(bytes, inputOffset, byteLength);
+            // Ensure to copy a slice of bytes because the bytes may be a NodeJS Buffer and Buffer#slice() returns a reference to its internal ArrayBuffer.
+            const slicedCopyOfBytes = Uint8Array.prototype.slice.call(bytes, inputOffset, inputOffset + byteLength);
+            this.store(slicedCopyOfBytes, str);
+            return str;
+        }
+    }
+
+    const STATE_ARRAY = "array";
+    const STATE_MAP_KEY = "map_key";
+    const STATE_MAP_VALUE = "map_value";
+    const mapKeyConverter = (key) => {
+        if (typeof key === "string" || typeof key === "number") {
+            return key;
+        }
+        throw new DecodeError("The type of key must be string or number but " + typeof key);
+    };
+    class StackPool {
+        stack = [];
+        stackHeadPosition = -1;
+        get length() {
+            return this.stackHeadPosition + 1;
+        }
+        top() {
+            return this.stack[this.stackHeadPosition];
+        }
+        pushArrayState(size) {
+            const state = this.getUninitializedStateFromPool();
+            state.type = STATE_ARRAY;
+            state.position = 0;
+            state.size = size;
+            state.array = new Array(size);
+        }
+        pushMapState(size) {
+            const state = this.getUninitializedStateFromPool();
+            state.type = STATE_MAP_KEY;
+            state.readCount = 0;
+            state.size = size;
+            state.map = {};
+        }
+        getUninitializedStateFromPool() {
+            this.stackHeadPosition++;
+            if (this.stackHeadPosition === this.stack.length) {
+                const partialState = {
+                    type: undefined,
+                    size: 0,
+                    array: undefined,
+                    position: 0,
+                    readCount: 0,
+                    map: undefined,
+                    key: null,
+                };
+                this.stack.push(partialState);
+            }
+            return this.stack[this.stackHeadPosition];
+        }
+        release(state) {
+            const topStackState = this.stack[this.stackHeadPosition];
+            if (topStackState !== state) {
+                throw new Error("Invalid stack state. Released state is not on top of the stack.");
+            }
+            if (state.type === STATE_ARRAY) {
+                const partialState = state;
+                partialState.size = 0;
+                partialState.array = undefined;
+                partialState.position = 0;
+                partialState.type = undefined;
+            }
+            if (state.type === STATE_MAP_KEY || state.type === STATE_MAP_VALUE) {
+                const partialState = state;
+                partialState.size = 0;
+                partialState.map = undefined;
+                partialState.readCount = 0;
+                partialState.type = undefined;
+            }
+            this.stackHeadPosition--;
+        }
+        reset() {
+            this.stack.length = 0;
+            this.stackHeadPosition = -1;
+        }
+    }
+    const HEAD_BYTE_REQUIRED = -1;
+    const EMPTY_VIEW = new DataView(new ArrayBuffer(0));
+    const EMPTY_BYTES = new Uint8Array(EMPTY_VIEW.buffer);
+    try {
+        // IE11: The spec says it should throw RangeError,
+        // IE11: but in IE11 it throws TypeError.
+        EMPTY_VIEW.getInt8(0);
+    }
+    catch (e) {
+        if (!(e instanceof RangeError)) {
+            throw new Error("This module is not supported in the current JavaScript engine because DataView does not throw RangeError on out-of-bounds access");
+        }
+    }
+    const MORE_DATA = new RangeError("Insufficient data");
+    const sharedCachedKeyDecoder = new CachedKeyDecoder();
+    class Decoder {
+        extensionCodec;
+        context;
+        useBigInt64;
+        rawStrings;
+        maxStrLength;
+        maxBinLength;
+        maxArrayLength;
+        maxMapLength;
+        maxExtLength;
+        keyDecoder;
+        mapKeyConverter;
+        totalPos = 0;
+        pos = 0;
+        view = EMPTY_VIEW;
+        bytes = EMPTY_BYTES;
+        headByte = HEAD_BYTE_REQUIRED;
+        stack = new StackPool();
+        entered = false;
+        constructor(options) {
+            this.extensionCodec = options?.extensionCodec ?? ExtensionCodec.defaultCodec;
+            this.context = options?.context; // needs a type assertion because EncoderOptions has no context property when ContextType is undefined
+            this.useBigInt64 = options?.useBigInt64 ?? false;
+            this.rawStrings = options?.rawStrings ?? false;
+            this.maxStrLength = options?.maxStrLength ?? UINT32_MAX;
+            this.maxBinLength = options?.maxBinLength ?? UINT32_MAX;
+            this.maxArrayLength = options?.maxArrayLength ?? UINT32_MAX;
+            this.maxMapLength = options?.maxMapLength ?? UINT32_MAX;
+            this.maxExtLength = options?.maxExtLength ?? UINT32_MAX;
+            this.keyDecoder = options?.keyDecoder !== undefined ? options.keyDecoder : sharedCachedKeyDecoder;
+            this.mapKeyConverter = options?.mapKeyConverter ?? mapKeyConverter;
+        }
+        clone() {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+            return new Decoder({
+                extensionCodec: this.extensionCodec,
+                context: this.context,
+                useBigInt64: this.useBigInt64,
+                rawStrings: this.rawStrings,
+                maxStrLength: this.maxStrLength,
+                maxBinLength: this.maxBinLength,
+                maxArrayLength: this.maxArrayLength,
+                maxMapLength: this.maxMapLength,
+                maxExtLength: this.maxExtLength,
+                keyDecoder: this.keyDecoder,
+            });
+        }
+        reinitializeState() {
+            this.totalPos = 0;
+            this.headByte = HEAD_BYTE_REQUIRED;
+            this.stack.reset();
+            // view, bytes, and pos will be re-initialized in setBuffer()
+        }
+        setBuffer(buffer) {
+            const bytes = ensureUint8Array(buffer);
+            this.bytes = bytes;
+            this.view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+            this.pos = 0;
+        }
+        appendBuffer(buffer) {
+            if (this.headByte === HEAD_BYTE_REQUIRED && !this.hasRemaining(1)) {
+                this.setBuffer(buffer);
+            }
+            else {
+                const remainingData = this.bytes.subarray(this.pos);
+                const newData = ensureUint8Array(buffer);
+                // concat remainingData + newData
+                const newBuffer = new Uint8Array(remainingData.length + newData.length);
+                newBuffer.set(remainingData);
+                newBuffer.set(newData, remainingData.length);
+                this.setBuffer(newBuffer);
+            }
+        }
+        hasRemaining(size) {
+            return this.view.byteLength - this.pos >= size;
+        }
+        createExtraByteError(posToShow) {
+            const { view, pos } = this;
+            return new RangeError(`Extra ${view.byteLength - pos} of ${view.byteLength} byte(s) found at buffer[${posToShow}]`);
+        }
+        /**
+         * @throws {@link DecodeError}
+         * @throws {@link RangeError}
+         */
+        decode(buffer) {
+            if (this.entered) {
+                const instance = this.clone();
+                return instance.decode(buffer);
+            }
+            try {
+                this.entered = true;
+                this.reinitializeState();
+                this.setBuffer(buffer);
+                const object = this.doDecodeSync();
+                if (this.hasRemaining(1)) {
+                    throw this.createExtraByteError(this.pos);
+                }
+                return object;
+            }
+            finally {
+                this.entered = false;
+            }
+        }
+        *decodeMulti(buffer) {
+            if (this.entered) {
+                const instance = this.clone();
+                yield* instance.decodeMulti(buffer);
+                return;
+            }
+            try {
+                this.entered = true;
+                this.reinitializeState();
+                this.setBuffer(buffer);
+                while (this.hasRemaining(1)) {
+                    yield this.doDecodeSync();
+                }
+            }
+            finally {
+                this.entered = false;
+            }
+        }
+        async decodeAsync(stream) {
+            if (this.entered) {
+                const instance = this.clone();
+                return instance.decodeAsync(stream);
+            }
+            try {
+                this.entered = true;
+                let decoded = false;
+                let object;
+                for await (const buffer of stream) {
+                    if (decoded) {
+                        this.entered = false;
+                        throw this.createExtraByteError(this.totalPos);
+                    }
+                    this.appendBuffer(buffer);
+                    try {
+                        object = this.doDecodeSync();
+                        decoded = true;
+                    }
+                    catch (e) {
+                        if (!(e instanceof RangeError)) {
+                            throw e; // rethrow
+                        }
+                        // fallthrough
+                    }
+                    this.totalPos += this.pos;
+                }
+                if (decoded) {
+                    if (this.hasRemaining(1)) {
+                        throw this.createExtraByteError(this.totalPos);
+                    }
+                    return object;
+                }
+                const { headByte, pos, totalPos } = this;
+                throw new RangeError(`Insufficient data in parsing ${prettyByte(headByte)} at ${totalPos} (${pos} in the current buffer)`);
+            }
+            finally {
+                this.entered = false;
+            }
+        }
+        decodeArrayStream(stream) {
+            return this.decodeMultiAsync(stream, true);
+        }
+        decodeStream(stream) {
+            return this.decodeMultiAsync(stream, false);
+        }
+        async *decodeMultiAsync(stream, isArray) {
+            if (this.entered) {
+                const instance = this.clone();
+                yield* instance.decodeMultiAsync(stream, isArray);
+                return;
+            }
+            try {
+                this.entered = true;
+                let isArrayHeaderRequired = isArray;
+                let arrayItemsLeft = -1;
+                for await (const buffer of stream) {
+                    if (isArray && arrayItemsLeft === 0) {
+                        throw this.createExtraByteError(this.totalPos);
+                    }
+                    this.appendBuffer(buffer);
+                    if (isArrayHeaderRequired) {
+                        arrayItemsLeft = this.readArraySize();
+                        isArrayHeaderRequired = false;
+                        this.complete();
+                    }
+                    try {
+                        while (true) {
+                            yield this.doDecodeSync();
+                            if (--arrayItemsLeft === 0) {
+                                break;
+                            }
+                        }
+                    }
+                    catch (e) {
+                        if (!(e instanceof RangeError)) {
+                            throw e; // rethrow
+                        }
+                        // fallthrough
+                    }
+                    this.totalPos += this.pos;
+                }
+            }
+            finally {
+                this.entered = false;
+            }
+        }
+        doDecodeSync() {
+            DECODE: while (true) {
+                const headByte = this.readHeadByte();
+                let object;
+                if (headByte >= 0xe0) {
+                    // negative fixint (111x xxxx) 0xe0 - 0xff
+                    object = headByte - 0x100;
+                }
+                else if (headByte < 0xc0) {
+                    if (headByte < 0x80) {
+                        // positive fixint (0xxx xxxx) 0x00 - 0x7f
+                        object = headByte;
+                    }
+                    else if (headByte < 0x90) {
+                        // fixmap (1000 xxxx) 0x80 - 0x8f
+                        const size = headByte - 0x80;
+                        if (size !== 0) {
+                            this.pushMapState(size);
+                            this.complete();
+                            continue DECODE;
+                        }
+                        else {
+                            object = {};
+                        }
+                    }
+                    else if (headByte < 0xa0) {
+                        // fixarray (1001 xxxx) 0x90 - 0x9f
+                        const size = headByte - 0x90;
+                        if (size !== 0) {
+                            this.pushArrayState(size);
+                            this.complete();
+                            continue DECODE;
+                        }
+                        else {
+                            object = [];
+                        }
+                    }
+                    else {
+                        // fixstr (101x xxxx) 0xa0 - 0xbf
+                        const byteLength = headByte - 0xa0;
+                        object = this.decodeString(byteLength, 0);
+                    }
+                }
+                else if (headByte === 0xc0) {
+                    // nil
+                    object = null;
+                }
+                else if (headByte === 0xc2) {
+                    // false
+                    object = false;
+                }
+                else if (headByte === 0xc3) {
+                    // true
+                    object = true;
+                }
+                else if (headByte === 0xca) {
+                    // float 32
+                    object = this.readF32();
+                }
+                else if (headByte === 0xcb) {
+                    // float 64
+                    object = this.readF64();
+                }
+                else if (headByte === 0xcc) {
+                    // uint 8
+                    object = this.readU8();
+                }
+                else if (headByte === 0xcd) {
+                    // uint 16
+                    object = this.readU16();
+                }
+                else if (headByte === 0xce) {
+                    // uint 32
+                    object = this.readU32();
+                }
+                else if (headByte === 0xcf) {
+                    // uint 64
+                    if (this.useBigInt64) {
+                        object = this.readU64AsBigInt();
+                    }
+                    else {
+                        object = this.readU64();
+                    }
+                }
+                else if (headByte === 0xd0) {
+                    // int 8
+                    object = this.readI8();
+                }
+                else if (headByte === 0xd1) {
+                    // int 16
+                    object = this.readI16();
+                }
+                else if (headByte === 0xd2) {
+                    // int 32
+                    object = this.readI32();
+                }
+                else if (headByte === 0xd3) {
+                    // int 64
+                    if (this.useBigInt64) {
+                        object = this.readI64AsBigInt();
+                    }
+                    else {
+                        object = this.readI64();
+                    }
+                }
+                else if (headByte === 0xd9) {
+                    // str 8
+                    const byteLength = this.lookU8();
+                    object = this.decodeString(byteLength, 1);
+                }
+                else if (headByte === 0xda) {
+                    // str 16
+                    const byteLength = this.lookU16();
+                    object = this.decodeString(byteLength, 2);
+                }
+                else if (headByte === 0xdb) {
+                    // str 32
+                    const byteLength = this.lookU32();
+                    object = this.decodeString(byteLength, 4);
+                }
+                else if (headByte === 0xdc) {
+                    // array 16
+                    const size = this.readU16();
+                    if (size !== 0) {
+                        this.pushArrayState(size);
+                        this.complete();
+                        continue DECODE;
+                    }
+                    else {
+                        object = [];
+                    }
+                }
+                else if (headByte === 0xdd) {
+                    // array 32
+                    const size = this.readU32();
+                    if (size !== 0) {
+                        this.pushArrayState(size);
+                        this.complete();
+                        continue DECODE;
+                    }
+                    else {
+                        object = [];
+                    }
+                }
+                else if (headByte === 0xde) {
+                    // map 16
+                    const size = this.readU16();
+                    if (size !== 0) {
+                        this.pushMapState(size);
+                        this.complete();
+                        continue DECODE;
+                    }
+                    else {
+                        object = {};
+                    }
+                }
+                else if (headByte === 0xdf) {
+                    // map 32
+                    const size = this.readU32();
+                    if (size !== 0) {
+                        this.pushMapState(size);
+                        this.complete();
+                        continue DECODE;
+                    }
+                    else {
+                        object = {};
+                    }
+                }
+                else if (headByte === 0xc4) {
+                    // bin 8
+                    const size = this.lookU8();
+                    object = this.decodeBinary(size, 1);
+                }
+                else if (headByte === 0xc5) {
+                    // bin 16
+                    const size = this.lookU16();
+                    object = this.decodeBinary(size, 2);
+                }
+                else if (headByte === 0xc6) {
+                    // bin 32
+                    const size = this.lookU32();
+                    object = this.decodeBinary(size, 4);
+                }
+                else if (headByte === 0xd4) {
+                    // fixext 1
+                    object = this.decodeExtension(1, 0);
+                }
+                else if (headByte === 0xd5) {
+                    // fixext 2
+                    object = this.decodeExtension(2, 0);
+                }
+                else if (headByte === 0xd6) {
+                    // fixext 4
+                    object = this.decodeExtension(4, 0);
+                }
+                else if (headByte === 0xd7) {
+                    // fixext 8
+                    object = this.decodeExtension(8, 0);
+                }
+                else if (headByte === 0xd8) {
+                    // fixext 16
+                    object = this.decodeExtension(16, 0);
+                }
+                else if (headByte === 0xc7) {
+                    // ext 8
+                    const size = this.lookU8();
+                    object = this.decodeExtension(size, 1);
+                }
+                else if (headByte === 0xc8) {
+                    // ext 16
+                    const size = this.lookU16();
+                    object = this.decodeExtension(size, 2);
+                }
+                else if (headByte === 0xc9) {
+                    // ext 32
+                    const size = this.lookU32();
+                    object = this.decodeExtension(size, 4);
+                }
+                else {
+                    throw new DecodeError(`Unrecognized type byte: ${prettyByte(headByte)}`);
+                }
+                this.complete();
+                const stack = this.stack;
+                while (stack.length > 0) {
+                    // arrays and maps
+                    const state = stack.top();
+                    if (state.type === STATE_ARRAY) {
+                        state.array[state.position] = object;
+                        state.position++;
+                        if (state.position === state.size) {
+                            object = state.array;
+                            stack.release(state);
+                        }
+                        else {
+                            continue DECODE;
+                        }
+                    }
+                    else if (state.type === STATE_MAP_KEY) {
+                        if (object === "__proto__") {
+                            throw new DecodeError("The key __proto__ is not allowed");
+                        }
+                        state.key = this.mapKeyConverter(object);
+                        state.type = STATE_MAP_VALUE;
+                        continue DECODE;
+                    }
+                    else {
+                        // it must be `state.type === State.MAP_VALUE` here
+                        state.map[state.key] = object;
+                        state.readCount++;
+                        if (state.readCount === state.size) {
+                            object = state.map;
+                            stack.release(state);
+                        }
+                        else {
+                            state.key = null;
+                            state.type = STATE_MAP_KEY;
+                            continue DECODE;
+                        }
+                    }
+                }
+                return object;
+            }
+        }
+        readHeadByte() {
+            if (this.headByte === HEAD_BYTE_REQUIRED) {
+                this.headByte = this.readU8();
+                // console.log("headByte", prettyByte(this.headByte));
+            }
+            return this.headByte;
+        }
+        complete() {
+            this.headByte = HEAD_BYTE_REQUIRED;
+        }
+        readArraySize() {
+            const headByte = this.readHeadByte();
+            switch (headByte) {
+                case 0xdc:
+                    return this.readU16();
+                case 0xdd:
+                    return this.readU32();
+                default: {
+                    if (headByte < 0xa0) {
+                        return headByte - 0x90;
+                    }
+                    else {
+                        throw new DecodeError(`Unrecognized array type byte: ${prettyByte(headByte)}`);
+                    }
+                }
+            }
+        }
+        pushMapState(size) {
+            if (size > this.maxMapLength) {
+                throw new DecodeError(`Max length exceeded: map length (${size}) > maxMapLengthLength (${this.maxMapLength})`);
+            }
+            this.stack.pushMapState(size);
+        }
+        pushArrayState(size) {
+            if (size > this.maxArrayLength) {
+                throw new DecodeError(`Max length exceeded: array length (${size}) > maxArrayLength (${this.maxArrayLength})`);
+            }
+            this.stack.pushArrayState(size);
+        }
+        decodeString(byteLength, headerOffset) {
+            if (!this.rawStrings || this.stateIsMapKey()) {
+                return this.decodeUtf8String(byteLength, headerOffset);
+            }
+            return this.decodeBinary(byteLength, headerOffset);
+        }
+        /**
+         * @throws {@link RangeError}
+         */
+        decodeUtf8String(byteLength, headerOffset) {
+            if (byteLength > this.maxStrLength) {
+                throw new DecodeError(`Max length exceeded: UTF-8 byte length (${byteLength}) > maxStrLength (${this.maxStrLength})`);
+            }
+            if (this.bytes.byteLength < this.pos + headerOffset + byteLength) {
+                throw MORE_DATA;
+            }
+            const offset = this.pos + headerOffset;
+            let object;
+            if (this.stateIsMapKey() && this.keyDecoder?.canBeCached(byteLength)) {
+                object = this.keyDecoder.decode(this.bytes, offset, byteLength);
+            }
+            else {
+                object = utf8Decode(this.bytes, offset, byteLength);
+            }
+            this.pos += headerOffset + byteLength;
+            return object;
+        }
+        stateIsMapKey() {
+            if (this.stack.length > 0) {
+                const state = this.stack.top();
+                return state.type === STATE_MAP_KEY;
+            }
+            return false;
+        }
+        /**
+         * @throws {@link RangeError}
+         */
+        decodeBinary(byteLength, headOffset) {
+            if (byteLength > this.maxBinLength) {
+                throw new DecodeError(`Max length exceeded: bin length (${byteLength}) > maxBinLength (${this.maxBinLength})`);
+            }
+            if (!this.hasRemaining(byteLength + headOffset)) {
+                throw MORE_DATA;
+            }
+            const offset = this.pos + headOffset;
+            const object = this.bytes.subarray(offset, offset + byteLength);
+            this.pos += headOffset + byteLength;
+            return object;
+        }
+        decodeExtension(size, headOffset) {
+            if (size > this.maxExtLength) {
+                throw new DecodeError(`Max length exceeded: ext length (${size}) > maxExtLength (${this.maxExtLength})`);
+            }
+            const extType = this.view.getInt8(this.pos + headOffset);
+            const data = this.decodeBinary(size, headOffset + 1 /* extType */);
+            return this.extensionCodec.decode(data, extType, this.context);
+        }
+        lookU8() {
+            return this.view.getUint8(this.pos);
+        }
+        lookU16() {
+            return this.view.getUint16(this.pos);
+        }
+        lookU32() {
+            return this.view.getUint32(this.pos);
+        }
+        readU8() {
+            const value = this.view.getUint8(this.pos);
+            this.pos++;
+            return value;
+        }
+        readI8() {
+            const value = this.view.getInt8(this.pos);
+            this.pos++;
+            return value;
+        }
+        readU16() {
+            const value = this.view.getUint16(this.pos);
+            this.pos += 2;
+            return value;
+        }
+        readI16() {
+            const value = this.view.getInt16(this.pos);
+            this.pos += 2;
+            return value;
+        }
+        readU32() {
+            const value = this.view.getUint32(this.pos);
+            this.pos += 4;
+            return value;
+        }
+        readI32() {
+            const value = this.view.getInt32(this.pos);
+            this.pos += 4;
+            return value;
+        }
+        readU64() {
+            const value = getUint64(this.view, this.pos);
+            this.pos += 8;
+            return value;
+        }
+        readI64() {
+            const value = getInt64(this.view, this.pos);
+            this.pos += 8;
+            return value;
+        }
+        readU64AsBigInt() {
+            const value = this.view.getBigUint64(this.pos);
+            this.pos += 8;
+            return value;
+        }
+        readI64AsBigInt() {
+            const value = this.view.getBigInt64(this.pos);
+            this.pos += 8;
+            return value;
+        }
+        readF32() {
+            const value = this.view.getFloat32(this.pos);
+            this.pos += 4;
+            return value;
+        }
+        readF64() {
+            const value = this.view.getFloat64(this.pos);
+            this.pos += 8;
+            return value;
+        }
+    }
+
+    /**
+     * It decodes a single MessagePack object in a buffer.
+     *
+     * This is a synchronous decoding function.
+     * See other variants for asynchronous decoding: {@link decodeAsync}, {@link decodeMultiStream}, or {@link decodeArrayStream}.
+     *
+     * @throws {@link RangeError} if the buffer is incomplete, including the case where the buffer is empty.
+     * @throws {@link DecodeError} if the buffer contains invalid data.
+     */
+    function decode(buffer, options) {
+        const decoder = new Decoder(options);
+        return decoder.decode(buffer);
+    }
+
+    const NetPackFormat = Object.freeze({
+        JsonString: 0,
+        MessagePack: 1,
+    });
+
+    /**
+     * 递归设置嵌套对象属性
+     * @param {Object} obj - 目标对象
+     * @param {Array} path - 属性路径
+     * @param {string} type - 操作类型，可选值：'set'、'del'、'SET'、'DEL'
+     * @param {*} value - 属性值
+     * @returns {boolean} - 是否成功设置属性
+     */
+    function setNestedProperty(obj, path, type, value) {
+        if (!obj) throw new Error('obj is empty');
+        if (!path?.length) throw new Error('path is empty');
+        const TypeTable = { s: 'set', d: 'del', S: 'SET', D: 'DEL' };
+        type = TypeTable[type] || type;
+        // 递归函数，用于根据数组路径访问属性
+        function _accessNestedProp(curObj, curPath) {
+            const key = curPath.shift();
+            if (curPath.length === 0) {
+                switch (type) {
+                    case 'set':
+                    case 'SET':
+                        curObj[key] = value;
+                        break;
+                    case 'del':
+                        delete curObj[key];
+                        break;
+                    case 'DEL':
+                        curObj.splice(Number(key), 1);
+                        break;
+                    default:
+                        throw new Error(`Invalid type: ${type}`);
+                }
+                return true;
+            } else {
+                if (!curObj[key]) {
+                    const isArray = type === 'SET' || type === 'DEL';
+                    if (curPath.length === 1 && isArray) {
+                        curObj[key] = [];
+                    } else {
+                        curObj[key] = {};
+                    }
+                }
+                return _accessNestedProp(curObj[key], curPath);
+            }
+        }
+        return _accessNestedProp(obj, path.slice());
+    }
+
+    async function fetchPost(url, data) {
+        const res = await fetch(url, {
+            method: 'POST',
+            body: JSON.stringify(data),
+            headers: { 'Content-Type': 'application/json' },
+        });
+        const result = await res.json();
+        if (result.err) throw new Error(result.err);
+        return result;
+    }
+
+    const DefaultHost$1 = 'wss://varserver.popx.com/ws/syncvar';
+
+    /**
+     * 创建可复用的 VarServer WebSocket 客户端，负责认证、消息分发、错误与断线处理。
+     * 包含排队发送、认证期间超时、重连策略以及对绑定 server 实例的事件转发。
+     * 支持 JSON 和 MessagePack 两种数据传输格式，默认使用 MessagePack 以获得更高传输效率。
+     *
+     * @param {(string|Object)} arg1 - 第一个参数，可以是 host 字符串或配置对象
+     * @param {Object} [arg2] - 第二个参数，配置对象（当 arg1 为 host 字符串时使用）
+     * @param {string} [arg2.host] - WebSocket 服务器地址，可选。
+     * @param {string} [arg2.namespace=''] - 命名空间，用于隔离不同应用的数据
+     * @param {string} [arg2.guid] - 客户端唯一标识符，用于认证
+     * @param {number} [arg2.packFormat=NetPackFormat.MessagePack] - 数据传输格式，默认 MessagePack
+     * @param {function} [arg2.onopen] - 连接建立时的回调函数，签名: (ws, event) => void
+     * @param {function} [arg2.onclose] - 连接关闭时的回调函数，签名: (event) => void
+     * @param {function} [arg2.onerror] - 错误处理回调函数，签名: (err) => void，默认: console.error
+     * @param {number} [arg2.timeout=5000] - 连接超时时间（毫秒），默认: 5000ms
+     * @param {number} [arg2.maxReconnectCount=100] - 最大重连次数，默认: 100
+     * @returns {Promise<WebSocket>} - 返回 WebSocket 实例的 Promise，包含扩展方法 sendMsg 和 bind
+     */
+    async function WebSocketClient(...args) {
+        let host, params;
+        if (typeof arguments[0] === 'string') {
+            host = arguments[0];
+            params = arguments[1];
+        } else {
+            params = arguments[0];
+            params?.host && (host = params.host);
+        }
+        host = host || DefaultHost$1;
+        const { namespace = '',
+            guid, onopen, onclose,
+            onerror = (err) => console.error('WebSocket error:', err?.message || err),
+            packFormat = NetPackFormat.MessagePack,
+            timeout = 5000,
+            maxReconnectCount = 100 } = params || {};
+        // 记录所有绑定的 server，连接建立后统一分发消息与状态变更
+        const servers = new Set();
+        console.log(`Create WebSocket: ${host}`);
+        let retryConnectCount = 0;
+        let hasHandledError = false;
+
+        // 抖动指数退避：避免短时间内多次重连导致的资源浪费
+        function reconnect() {
+            const base = 1000;
+            const exp = Math.min(base * 2 ** retryConnectCount, 30000);
+            // 抖动：在 50% - 100% * exp 范围内随机
+            const delay = Math.min(Math.floor(exp * (0.5 + Math.random() * 0.5)), 30000);
+            retryConnectCount++;
+            console.log(`Retry connect: ${host}, delay=${(delay / 1000).toFixed(1)}s, count=${retryConnectCount}`);
+            setTimeout(() => {
+                connect().catch(err => console.error('WebSocket 重连失败:', err?.message || err));
+            }, delay);
+        }
+
+        // connect 返回 Promise，便于统一处理 onopen/close/error 的异步顺序
+        async function connect() {
+            return new Promise((resolve, reject) => {
+                hasHandledError = false;
+                const params = new URLSearchParams({ namespace });
+                let ws = new WebSocket(`${host}?${params}`);
+                ws.binaryType = 'arraybuffer';
+                ws._authed = false;
+                // 发送队列：连接就绪前缓存 outbound 消息，认证完成后统一 flush
+                ws._sendQueue = [];
+                ws.sendMsg = (msg, { format = packFormat } = {}) => {
+                    if (ws.readyState !== WebSocket.OPEN) {
+                        ws._sendQueue.push(msg);
+                        console.warn('WebSocket is not ready, queued message. Queue size:', ws._sendQueue.length);
+                        return;
+                    }
+                    try {
+                        if (format === NetPackFormat.MessagePack) {
+                            ws.send(encode(msg), { binary: true });
+                        } else {
+                            ws.send(JSON.stringify(msg));
+                        }
+                    } catch (err) {
+                        onerror?.(err);
+                    }
+                };
+
+                let timeoutId = null;
+                // 如果在约定时间内没有收到服务端的登录回应，则视为超时
+                timeoutId = setTimeout(() => {
+                    if (!ws._authed && ws.readyState === WebSocket.CONNECTING) {
+                        ws.close();
+                        const timeoutError = new Error('WebSocket connection timeout');
+                        onerror?.(timeoutError);
+                        reject(timeoutError);
+                        hasHandledError = true;
+                    }
+                }, timeout);
+
+                // 发起登录请求 - 登录消息总是使用JSON格式确保兼容
+                function login() {
+                    const $login = { namespace, guid, packFormat };
+                    // 登录消息使用JSON格式，服务端会处理格式选择
+                    ws.send(JSON.stringify({ $login }));
+                }
+
+                // 处理服务端登录结果
+                function onLogin({ id, error }) {
+                    ws.id = id;
+                    ws._authed = true;
+                    clearTimeout(timeoutId);
+                    if (error) {
+                        reject(error);
+                        hasHandledError = true;
+                        return;
+                    }
+                    if (retryConnectCount > 0) {
+                        servers.forEach(server => server.bind(ws));
+                        retryConnectCount = 0;
+                    }
+                    // 认证通过后，flush 掉之前排队的消息
+                    if (ws._sendQueue && ws._sendQueue.length) {
+                        const queued = ws._sendQueue.splice(0);
+                        queued.forEach(m => ws.sendMsg(m));
+                    }
+                    console.log(`Client connected ${host}`, id);
+                    resolve(ws);
+                }
+
+                // 连接成功：触发外部回调并启动认证流程
+                ws.onopen = (event) => {
+                    console.log("WebSocket connected!");
+                    onopen?.(ws, event);
+                    login();
+                };
+
+                // 消息接收：统一做 JSON 解析、格式校验、分发逻辑
+                ws.onmessage = async (event) => {
+                    try {
+                        const { data } = event;
+                        let msg;
+                        if (typeof data === 'string') {
+                            msg = JSON.parse(data);
+                        } else {
+                            let buffer;
+                            if (data instanceof Blob) {
+                                buffer = await data.arrayBuffer();
+                            } else {
+                                buffer = data;
+                            }
+                            if (packFormat === NetPackFormat.MessagePack) {
+                                msg = decode(buffer);
+                            } else {
+                                throw new Error('不支持的消息格式');
+                            }
+                        }
+                        // 严谨的类型检查
+                        if (!msg || typeof msg !== 'object') {
+                            throw new Error(`Invalid message format: ${data}`);
+                        }
+                        if (msg.$error) throw new Error(msg.$error.err || '未描述的错误');
+                        if (msg.$login) return onLogin(msg.$login);
+                        servers.forEach(server => server.onMessage?.(msg));
+                    } catch (err) {
+                        onerror?.(err);
+                    }
+                };
+
+                // WebSocket 报错：如果尚未认证完成，则需要 reject
+                ws.onerror = (event) => {
+                    if (hasHandledError) return;
+                    clearTimeout(timeoutId);
+                    const err = event instanceof Error ? event : new Error(event?.message || 'WebSocket error');
+                    onerror?.(err);
+                    if (!ws._authed) {
+                        reject(err);
+                        hasHandledError = true;
+                    }
+                };
+
+                // 连接关闭：清理状态、通知 server，并尝试重连或彻底销毁
+                ws.onclose = (event) => {
+                    console.error(`Connection closed: code=${event.code}, reason=${event.reason}, clean=${event.wasClean}`);
+                    clearTimeout(timeoutId);
+                    onclose?.(event);
+                    servers.forEach(server => server.close?.(event));
+                    if (retryConnectCount < maxReconnectCount) {
+                        reconnect();
+                    } else {
+                        servers.forEach(server => server.destroy?.(event));
+                        servers.clear();
+                    }
+                };
+
+                ws.bind = (server) => {
+                    if (servers.has(server)) return server;
+                    servers.add(server);
+                    return server.bind(ws);
+                };
+            });
+        }
+
+        return connect();
+    }
+
+    const DEFAULT_PROMISE_TIMEOUT = 10000;
+
+    class PromiseMgr {
+        constructor() {
+            this._promises = new Map();
+            this._latestPromiseId = 0;
+        }
+
+        call(cb, { timeout = DEFAULT_PROMISE_TIMEOUT, data } = {}) {
+            if (!cb) throw new Error('未指定回调函数');
+            return new Promise((resolve, reject) => {
+                const pid = ++this._latestPromiseId;
+                const timeoutId = setTimeout(() => {
+                    this._promises.delete(pid);
+                    reject(new Error(`Promise等待超时`));
+                }, timeout);
+                this._promises.set(pid, { resolve, reject, timeoutId, data });
+                cb(pid);
+            });
+        }
+
+        process(pid, { result, error }) {
+            const promise = this._promises.get(pid);
+            if (!promise) {
+                console.error(`Promise process unexpected. pid:${pid}`);
+                return false;
+            }
+            clearTimeout(promise.timeoutId);
+            this._promises.delete(pid);
+            const { resolve, reject } = promise;
+            error ? reject(new Error(error)) : resolve(result);
+            return !error;
+        }
+
+        getData(pid) {
+            const promise = this._promises.get(pid);
+            return promise?.data;
+        }
+
+    }
+
+    const mgr = new PromiseMgr();
+
+    /**
+     * SyncVar - 客户端变量同步工具
+     *
+     * 说明：此文件同时支持两种接收更新的方式：
+     *  - 基于 WebSocket 的双向同步（默认，用于 sync/lock/set 等交互）
+     */
+    class SyncVar {
+        /**
+         * SyncVar - 客户端变量同步工具
+         *
+         * 支持：
+         *  - 基于 WebSocket 的双向同步（默认，用于 sync/lock/set 等交互）
+         *
+         * @param {Object} options
+         * @param {number} options.delay - 变更打包延迟（ms）
+         */
+        constructor({ delay = 50 } = {}) {
+            this._watchs = new Map();
+            this._waitUpdated = new Set();
+            this._delay = delay;
+            this._destroyed = false;
+            this._needUpdateVars = new Map();
+            this._updateVarTimer = null;
+            this._bindFuncs = new Map();
+        }
+        get ws() { return this._ws }
+        get id() { return this._ws?.id }
+        /**
+         * 绑定并初始化与 WebSocket 的连接。
+         * 会在绑定时同步当前已注册的变量与已注册的 RPC 函数到服务器。
+         * @param {WebSocket|Object} ws - 支持具有 `send` 或 `sendMsg` 的连接对象
+         * @returns {Promise<SyncVar>} 返回自身实例以便链式调用
+         */
+        async bind(ws) {
+            if (this._ws === ws) return this;
+            if (!ws?.bind) throw new Error('请绑定WebSocketClient创建的连接实例');
+            console.log('SyncVar bind', ws.id);
+            this._ws = ws;
+            ws.bind(this);
+            // 同步所有已注册的变量
+            if (this._watchs.size) {
+                const names = Array.from(this._watchs.keys());
+                await mgr.call((pid) => {
+                    this._sendMsg({ SyncVar: { $sync: { pid, names } } });
+                }, { data: { names } });
+            }
+            // 同步所有已注册的函数
+            if (this._bindFuncs.size) {
+                await mgr.call((pid) => {
+                    const names = Array.from(this._bindFuncs.keys());
+                    this._sendMsg({ SyncVar: { $bind: { pid, names } } });
+                });
+            }
+            return this;
+        }
+        /**
+         * 关闭本地 WebSocket 引用（不向服务器发送通知）
+         */
+        close() { this._ws = null; }
+
+        /**
+         * 销毁 SyncVar 实例，取消所有挂起的 Promise 并清理内部状态。
+         * 调用后实例将不可再用。
+         */
+        destroy() {
+            // 清理所有待处理的Promise，防止内存泄漏
+            if (this._destroyed) return;
+            this._destroyed = true;
+            const error = new Error('SyncVar已销毁');
+            this._waitUpdated.forEach(({ reject }) => reject(error));
+            this._watchs.clear();
+            this._waitUpdated.clear();
+            this._ws = null;
+        }
+
+        /**
+         * 等待最近一次写入（$set）的服务器回执。
+         * 返回一个 Promise，在服务端回执时 resolve，或在出错/超时时 reject。
+         * 用法：await syncVar.waitUpdated();
+         */
+        async waitUpdated() {
+            if (this._destroyed) throw new Error('SyncVar已销毁，无法执行锁定');
+            return new Promise((resolve, reject) => this._waitUpdated.add({ resolve, reject }));
+        }
+
+        // 绑定RPC函数
+        /**
+         * 将本地函数注册为可被服务端调用的 RPC 函数。
+         * 要求传入的函数必须有名称（不能为匿名函数）。
+         * @param {Function} func
+         * @returns {Promise<void>}
+         */
+        async rpcBind(func) {
+            if (typeof func !== 'function') throw new Error('rpcBind 回调必须是函数');
+            const name = func.name;
+            if (!name) throw new Error('rpcBind 回调必须指定名称，不能使用匿名函数');
+            if (this._bindFuncs.has(name)) throw new Error(`已存在同名函数: ${name}`);
+            this._bindFuncs.set(name, func);
+            return mgr.call((pid) => {
+                this._sendMsg({ SyncVar: { $bind: { pid, names: [name] } } });
+            });
+        }
+
+        /**
+         * 调用远端已绑定的 RPC 函数
+         * @param {string} name - 函数名
+         * @param {any} args - 传递给远端函数的参数（任意类型）
+         * @returns {Promise<any>} 返回远端函数的执行结果或抛出错误
+         */
+        async rpcCall(name, args) {
+            if (!name) throw new Error('rpcCall 参数错误：name 不能为空');
+            return mgr.call((pid) => {
+                this._sendMsg({ SyncVar: { $call: { pid, name, args } } });
+            });
+        }
+
+        onMessage(msg) {
+            const { SyncVar } = msg;
+            if (!SyncVar) return;
+            try {
+                const { $sync, $set, $update, $lock,
+                    $bind, $call, $callRet } = SyncVar;
+                $sync && this._onSync($sync);
+                $set && this._onSet($set);
+                $update && this._onUpdate($update);
+                $lock && this._onLock($lock);
+                $bind && this._onBind($bind);
+                $call && this._onCall($call);
+                $callRet && this._onCallRet($callRet);
+            } catch (e) {
+                console.error('SyncVar.onMessage error:', SyncVar, e.message);
+            }
+        }
+
+
+        static _clone(val) {
+            if (typeof globalThis.structuredClone === 'function') return globalThis.structuredClone(val);
+            try {
+                return JSON.parse(JSON.stringify(val));
+            } catch (e) {
+                console.error('无法克隆对象', val, e.message || e);
+                return val;
+            }
+        }
+
+        static _getDataKeys(obj) { return Object.keys(obj).filter(k => typeof obj[k] !== 'function'); }
+
+        static _shallowDataEqual(a, b) {
+            if (Object.is(a, b)) return true;
+            if (!a || !b) return false;
+            const keysA = SyncVar._getDataKeys(a);
+            const keysB = SyncVar._getDataKeys(b);
+            if (keysA.length !== keysB.length) return false;
+            else if (keysA.length === 0) return a === b;
+            return keysA.every(k => a[k] === b[k]);
+        }
+
+        static _copyData(oldObj, newObj) {
+            if (SyncVar._shallowDataEqual(oldObj, newObj)) return false;
+            const keysToDelete = SyncVar._getDataKeys(oldObj);
+            for (const key of keysToDelete) delete oldObj[key];
+            Object.assign(oldObj, newObj);
+            return true;
+        }
+
+        static _createBatchNotifier(onFlush) {
+            // 将多次变更在微任务内合并，再一次性触发 onFlush，降低发送频率
+            let queue = [];
+            let scheduled = false;
+            function flush() {
+                if (queue.length === 0) return;
+                const changes = queue;
+                queue = [];
+                onFlush(changes);
+            }
+            function schedule() {
+                if (scheduled) return;
+                scheduled = true;
+                Promise.resolve().then(() => {
+                    scheduled = false;
+                    flush();
+                });
+            }
+            return {
+                push(change) {
+                    queue.push(change);
+                    schedule();
+                },
+                flush,
+            };
+        }
+
+        /**
+         * 同步变量并返回 proxy 对象。
+         *
+         * 用法示例：
+         *   // 单个变量
+         *   const position = await syncVar.sync('position');
+         *   // 多个变量
+         *   const { position, user } = await syncVar.sync(['position','user']);
+         *
+         * 可选参数 `params.reset` 在第一次 sync 时用于本地初始化变量值：
+         *   await syncVar.sync(['user'], { reset: { user: { name: '张三' } } });
+         *
+         * 返回：resolve 时返回已存在或新建的 proxy（单个或对象映射）。
+         * 错误场景：未连接 WebSocket、names 为空、超时或服务端返回错误会 reject。
+         */
+        async sync(names, params) {
+            if (this._destroyed) throw new Error('SyncVar已销毁，无法执行同步');
+            if (typeof names === 'string') names = [names];
+            if (!names?.length) throw new Error('names不能为空');
+            if (!this._ws || this._ws.readyState !== WebSocket.OPEN) {
+                throw new Error('WebSocket未连接');
+            }
+            const needSyncNames = names.filter(name => !this._watchs.has(name));
+            // 处理 reset 值
+            const { reset } = params || {};
+            reset && names.forEach(name => {
+                const value = reset[name];
+                if (value !== undefined) this[name] = value;
+            });
+            if (!needSyncNames.length) {
+                const result = {};
+                names.forEach(name => {
+                    const watch = this._watchs.get(name);
+                    if (!watch) throw new Error('变量异常:' + name);
+                    result[name] = watch.proxy;
+                });
+                return result;
+            }
+            return mgr.call((pid) => {
+                this._sendMsg({ SyncVar: { $sync: { pid, names: needSyncNames, ...params } } });
+            }, { data: { names } });
+        }
+
+        _onSync({ datas, pid, error }) {
+            datas?.forEach(({ name, value }) => {
+                let watch = this._watchs.get(name);
+                if (!watch) {
+                    watch = this._observe(name, value);
+                    this._watchs.set(name, watch);
+                } else {
+                    watch.setValue(value);
+                }
+            });
+            const data = mgr.getData(pid);
+            const result = {};
+            data?.names?.forEach(name => {
+                const watch = this._watchs.get(name);
+                if (!watch) throw new Error('同步变量异常:' + name);
+                result[name] = watch.proxy;
+            });
+            mgr.process(pid, { result, error });
+        }
+
+        _onSet({ error, lockeds }) {
+            lockeds?.forEach(({ name, value }) => {
+                const watch = this._watchs.get(name);
+                if (!watch) {
+                    console.error('变量异常:' + name);
+                    return;
+                }
+                watch.setValue(value);
+            });
+            this._waitUpdated.forEach(({ resolve, reject }) => {
+                if (error) {
+                    reject(`数据写入失败：` + error);
+                } else {
+                    resolve();
+                }
+            });
+            this._waitUpdated.clear();
+        }
+
+        _onLock({ name, value, promiseIds, error }) {
+            //console.log('locked:', this._ws.id, !error);
+            const watch = this._watchs.get(name);
+            if (watch) {
+                watch.setValue(value);
+                watch.setLocked();
+            }
+            let resolved = false;
+            promiseIds?.forEach(pid => {
+                let result;
+                if (watch) {
+                    result = watch.proxy;
+                } else {
+                    error = error || ('找不到变量:' + name);
+                }
+                if (mgr.process(pid, { result, error })) {
+                    resolved = true;
+                }
+            });
+            // 没人处理这个lock则通知服务器unlock
+            if (!resolved) {
+                watch?.unlock();
+                this._sendMsg({ SyncVar: { $unlock: { name } } });
+            }
+        }
+
+        _onUpdate({ vars }) {
+            vars?.forEach(({ name, value, changes }) => {
+                //console.log('$update', this._ws.id, name, diff);
+                const watch = this._watchs.get(name);
+                if (!watch) return console.error('找不到变量:' + name);
+                if (changes) {
+                    watch.setDiffs(changes);
+                } else {
+                    watch.setValue(value);
+                }
+            });
+        }
+
+        _onBind({ pid, error }) { mgr.process(pid, { error }); }
+
+        async _onCall({ pid, name, args }) {
+            try {
+                const func = this._bindFuncs.get(name);
+                if (!func) throw new Error(`函数不存在: ${name}`);
+                const result = await func(args);
+                this._sendMsg({ SyncVar: { $callRet: { pid, name, result } } });
+            } catch (e) {
+                this._sendMsg({ SyncVar: { $callRet: { pid, error: e.message || e } } });
+                console.error(e);
+            }
+        }
+
+        _onCallRet({ pid, result, error }) { mgr.process(pid, { result, error }); }
+
+
+        _packUpdateVar(name, changes) {
+            if (!this._needUpdateVars.has(name)) {
+                this._needUpdateVars.set(name, []);
+            }
+            const oldChanges = this._needUpdateVars.get(name);
+            changes.forEach(change => {
+                const { type, path } = change;
+                // 删除重叠的旧变更
+                for (let index = oldChanges.length - 1; index >= 0; index--) {
+                    const { path: oldPath } = oldChanges[index];
+                    if (!path.every((p, i) => oldPath[i] === p)) continue;
+                    oldChanges.splice(index, 1);
+                }
+                oldChanges.push(change);
+            });
+            if (this._updateVarTimer) return;
+            this._updateVarTimer = setTimeout(() => {
+                this._updateVarTimer = null;
+                //
+                if (!this._needUpdateVars.size) return;
+                const diffs = [];
+                this._needUpdateVars.forEach((changes, name) => {
+                    if (!changes.length) return;
+                    const watch = this._watchs.get(name);
+                    if (!watch) return console.error('找不到变量:' + name);
+
+                    // 压缩 changes 格式
+                    const TypeTable = { set: 's', del: 'd', SET: 'S', DEL: 'D' };
+                    const compressedChanges = changes.map(({ type, path, val }) =>
+                        ({ t: TypeTable[type], p: path, v: val }));
+                    // 比较 JSON 序列化后的大小，选择更小的发送方式
+                    const changesSize = JSON.stringify(compressedChanges).length;
+                    const fullValueSize = JSON.stringify(watch.value).length;
+
+                    if (changesSize >= fullValueSize) {
+                        const saved = changesSize - fullValueSize;
+                        console.log(`[SyncVar优化] 变量 "${name}" 使用完整值发送 (changes: ${changesSize}B → value: ${fullValueSize}B, 节省 ${saved}B)`);
+                        diffs.push({ name, value: watch.value });
+                    } else {
+                        console.log(`[SyncVar优化] 变量 "${name}" 使用差异发送 (changes: ${changesSize}B, value: ${fullValueSize}B)`);
+                        diffs.push({ name, changes: compressedChanges });
+                    }
+                    watch.unlock();
+                });
+                if (!diffs.length) return;
+                // 通知服务器
+                const $set = { diffs };
+                this._waitUpdated.size > 0 && ($set.receipt = true);
+                this._sendMsg({ SyncVar: { $set } });
+                //console.log('update var:', diffs);
+                this._needUpdateVars.clear();
+            }, this._delay);
+        }
+
+        _observe(name, value) {
+            const that = this;
+            const proxyCache = new WeakMap();
+            let locked = false;
+            let watchCB;
+            const notifier = SyncVar._createBatchNotifier((changes) => {
+                this._packUpdateVar(name, changes);
+            });
+            function _createProxy(obj, path = []) {
+                if (typeof obj !== 'object' || obj === null) return obj;
+                if (proxyCache.has(obj)) return proxyCache.get(obj);
+                const proxy = new Proxy(obj, {
+                    get(target, key, receiver) {
+                        const val = Reflect.get(target, key, receiver);
+                        // 解决 Set 和 Map 的方法
+                        const _isCollection = (obj) => obj instanceof Set || obj instanceof Map;
+                        if (typeof val === 'function' && _isCollection(target)) {
+                            return val.bind(target);
+                        }
+                        return _createProxy(val, path.concat(key));
+                    },
+                    set(target, key, val, receiver) {
+                        const old = target[key];
+                        if (SyncVar._shallowDataEqual(old, val)) return true;
+                        notifier.push({
+                            type: Array.isArray(target) ? 'SET' : 'set',
+                            path: path.concat(key),
+                            val: SyncVar._clone(val),
+                        });
+                        return Reflect.set(target, key, val, receiver);
+                    },
+                    deleteProperty(target, key) {
+                        notifier.push({ type: Array.isArray(target) ? 'DEL' : 'del', path: path.concat(key) });
+                        return Reflect.deleteProperty(target, key);
+                    }
+                });
+                proxyCache.set(obj, proxy);
+                return proxy;
+            }
+            const proxy = _createProxy(value);
+            /**
+             * 请求对该变量的独占锁（写入保护）。
+             *
+             * 示例：
+             *   await syncVar.sync('user');
+             *   const proxy = (await syncVar.sync('user')).position || (await syncVar.sync('user'));
+             *   const p = await proxy.lock({ timeout: 5000 });
+             *
+             * 返回：resolve 为 `proxy`（代表锁已被授予），reject 表示超时或服务端错误。
+             */
+            Object.defineProperty(proxy, 'lock', {
+                value: async ({ timeout } = {}) => {
+                    if (that._destroyed) throw new Error('SyncVar已销毁，无法执行锁定');
+                    if (locked) return proxy;   // 已被自己锁住，则立马返回成功
+                    return mgr.call((promiseId) => {
+                        that._sendMsg({ SyncVar: { $lock: { promiseId, name } } });
+                    }, { timeout });
+                }
+            });
+            /**
+             * 释放当前变量的锁（若持有）。
+             * 用法示例：await proxy.unlock();
+             */
+            Object.defineProperty(proxy, 'unlock', {
+                value: async () => {
+                    if (that._destroyed) throw new Error('SyncVar已销毁，无法执行锁定');
+                    if (!locked) return;
+                    locked = false;
+                    try {
+                        that._sendMsg({ SyncVar: { $unlock: { name } } });
+                    } catch (err) {
+                        console.error('unlock notify failed:', err && err.message ? err.message : err);
+                    }
+                }
+            });
+            /**
+             * 注册变量变化回调：`cb(value, name)`。
+             * 当接收到服务端的 `$update` 或 `$lock` 时会触发。
+             * 示例：proxy.watch((value, name) => { console.log('updated', name, value); });
+             */
+            Object.defineProperty(proxy, 'watch', {
+                value: (cb) => {
+                    if (typeof cb !== 'function') throw new Error('watch 回调必须是函数');
+                    watchCB = cb;
+                }
+            });
+            Object.defineProperty(this, name, {
+                enumerable: true,
+                configurable: true,
+                get() { return proxy },
+                set(val) { SyncVar._copyData(proxy, val); }
+            });
+            return {
+                proxy,
+                value,
+                setLocked() { locked = true; },
+                unlock() { locked = false; },
+                setValue(val) {
+                    SyncVar._copyData(value, val);
+                    try {
+                        watchCB?.(value, name);
+                    } catch (err) {
+                        console.error(`watch 回调执行失败 (${name}):`, err);
+                    }
+                },
+                setDiffs(diffs) {
+                    diffs.forEach(({ t: type, p: path, v: val }) =>
+                        setNestedProperty(value, path, type, val)
+                    );
+                    try {
+                        watchCB?.(value, name);
+                    } catch (err) {
+                        console.error(`watch 回调执行失败 (${name}):`, err);
+                    }
+                },
+            };
+        }
+
+        _sendMsg(msg) {
+            try {
+                if (!this._ws || this._ws.readyState !== WebSocket.OPEN) {
+                    throw new Error('WebSocket未连接');
+                }
+                if (typeof this._ws.sendMsg === 'function') {
+                    this._ws.sendMsg(msg);
+                } else if (typeof this._ws.send === 'function') {
+                    this._ws.send(JSON.stringify(msg));
+                } else {
+                    console.error('_sendMsg: ws has no send/sendMsg method');
+                }
+            } catch (e) {
+                console.error('_sendMsg failed:', e && e.message ? e.message : e);
+            }
+        }
+    }
+
+    /**
+     * Worker 负责通过 websocket 与后端的 worker manager 交换指令并管理请求的生命周期。
+     */
+    class Worker {
+        /**
+         * @param {Object} options
+         * @param {Function} options.onlog 接收子进程日志事件。
+         * @param {Function} options.onerror 接收子进程错误堆栈。
+         * @param {Function} options.onexit 接收子进程退出事件。
+         */
+        constructor({ onlog, onerror, onexit } = {}) {
+            console.warn('Worker init', { version: '2025-12-24' });
+            this._onlog = onlog;
+            this._onerror = onerror;
+            this._onexit = onexit;
+        }
+
+        /**
+         * 为当前 Worker 实例绑定一个 websocket 连接，用于发送/接收命令。
+         */
+        async bind(ws) {
+            if (this._ws === ws) return this;
+            if (!ws?.bind) throw new Error('请绑定WebSocketClient创建的连接实例');
+            console.log('Worker bind', ws.id);
+            this._ws = ws;
+            ws.bind(this);
+            return this;
+        }
+
+        /**
+         * 处理 websocket 推送的 Worker 消息，分发到不同的回调或 promise。
+         */
+        onMessage(msg) {
+            const { Worker } = msg;
+            if (!Worker) return;
+            try {
+                const { $run, $kill, $attach, $lists,
+                    $log, $error, $exit } = Worker;
+                $run && this._onPromise($run);
+                $kill && this._onPromise($kill);
+                $attach && this._onPromise($attach);
+                $lists && this._onPromise($lists);
+                $log && this._onlog?.(...$log);
+                $error && this._onerror?.($error);
+                $exit && this._onexit?.($exit);
+            } catch (e) {
+                console.error('Worker.onMessage error:', Worker, e.message);
+            }
+        }
+
+        _onPromise({ pid, error, ...other }) { mgr.process(pid, { error, result: { ...other } }); }
+
+        /**
+         * 请求后端执行指定脚本。
+         */
+        async run({ code, name, workerData }) {
+            return mgr.call((pid) => {
+                this._ws.sendMsg({ Worker: { $run: { pid, code, name, workerData } } });
+            });
+        }
+
+        /**
+         * 请求终止指定名称的 worker。
+         */
+        async kill({ name }) {
+            return mgr.call((pid) => {
+                this._ws.sendMsg({ Worker: { $kill: { pid, name } } });
+            });
+        }
+
+        /**
+         * 关联到一个已存在的 worker，用于接收日志与事件。
+         */
+        async attach({ name }) {
+            return mgr.call((pid) => {
+                this._ws.sendMsg({ Worker: { $attach: { pid, name } } });
+            });
+        }
+
+        /**
+         * 获取当前所有的 worker 列表。
+         */
+        async lists() {
+            return mgr.call((pid) => {
+                this._ws.sendMsg({ Worker: { $lists: { pid } } });
+            });
+        }
+    }
+
+    const DefaultHost = 'https://varserver.popx.com';
+    const INITIAL_RECONNECT_DELAY = 1000;
+    const MAX_RECONNECT_DELAY = 30000;
+
+    /**
+     * 简化并安全地使用 SSE 订阅变量更新的辅助类。
+     *
+     * 示例：
+     *   const sse = new SSE();
+     *   await sse.watch({ vars: { myVar: (update) => { ... } }, events: { myEvent: () => { ... } } });
+     */
+    class SSE {
+        constructor({ host = DefaultHost, namespace = '', onError = null } = {}) {
+            this._host = host;
+            this._namespace = namespace;
+            // 保存当前接收到的数据快照，按变量名索引
+            this._data = new Map();
+            // 存放按变量名注册的回调
+            this._cbFuncs = new Map();
+            // 错误回调：默认打印到控制台
+            this._onError = onError || ((err) => console.error('SSE error:', err && err.message ? err.message : err));
+            this._sse = null;
+            this._eventListeners = [];
+            this._watchConfig = null;
+            this._reconnectDelay = INITIAL_RECONNECT_DELAY;
+            this._reconnectTimer = null;
+            this._closing = false;
+            this._connectPromise = null;
+        }
+
+        // 通过 HTTP POST 将事件发送到服务器
+        static emit(event, data, { host = DefaultHost, namespace = '' } = {}) {
+            const params = new URLSearchParams();
+            if (namespace) params.append('namespace', namespace);
+            const url = `${host}/api/emit?${params.toString()}`;
+            return fetchPost(url, { event, data });
+        }
+
+        async _getEventSource() {
+            // 检查是否在浏览器环境
+            const isBrowser = typeof window !== 'undefined' &&
+                typeof document !== 'undefined';
+            if (isBrowser) {
+                // 浏览器环境
+                if (!window.EventSource) {
+                    throw new Error('EventSource is not supported in this browser');
+                }
+                return window.EventSource;
+            } else {
+                // Node.js 环境
+                try {
+                    // 动态导入
+                    const module = await import('eventsource');
+                    const { EventSource } = module.default || module;
+                    return EventSource;
+                } catch (error) {
+                    throw new Error('Failed to import eventsource module. Make sure it is installed: npm install eventsource');
+                }
+            }
+        }
+
+        async _connect() {
+            if (!this._watchConfig) throw new Error('vars 和 events 不能同时为空');
+            if (this._connectPromise) return this._connectPromise;
+            const EventSource = await this._getEventSource();
+            if (this._sse && this._sse.readyState === EventSource.OPEN) return this;
+            const { varNames, eventNames } = this._watchConfig;
+            const params = new URLSearchParams();
+            if (this._namespace) params.append('namespace', this._namespace);
+            if (varNames.length) params.append('vars', varNames);
+            if (eventNames.length) params.append('events', eventNames);
+            const url = `${this._host}/sse/syncvar?${params.toString()}`;
+            const sse = new EventSource(url);
+            this._sse = sse;
+            this._closing = false;
+            this._attachSyncHandler(sse);
+            this._attachEventListeners(sse);
+            console.log('SSE 连接中...');
+            this._connectPromise = new Promise((resolve, reject) => {
+                let settled = false;
+                const handleOpen = () => {
+                    if (settled) return;
+                    settled = true;
+                    this._reconnectDelay = INITIAL_RECONNECT_DELAY;
+                    this._clearReconnectTimer();
+                    this._connectPromise = null;
+                    console.log('SSE 已连接');
+                    resolve(this);
+                };
+                const handleError = () => {
+                    const err = new Error('SSE 连接错误');
+                    this._onError(err);
+                    if (!settled) {
+                        settled = true;
+                        this._connectPromise = null;
+                        reject(err);
+                        return
+                    }
+                    if (this._closing) return;
+                    this._connectPromise = null;
+                    this._scheduleReconnect();
+                };
+                sse.onopen = handleOpen;
+                sse.onerror = handleError;
+                sse.onmessage = ({ data }) => this._onError(new Error('sseWatch 未处理消息: ' + data));
+            });
+            return this._connectPromise
+        }
+
+        _attachSyncHandler(sse) {
+            sse.addEventListener('$sync', (evt) => {
+                try {
+                    const parsed = JSON.parse(evt.data || '{}');
+                    const { name, value, changes } = parsed || {};
+                    if (!name) throw new Error('名字为空: ' + evt.data);
+                    let current = this._data.get(name);
+                    if (changes) {
+                        if (!current || typeof current !== 'object') throw new Error('数据为空或不可变更: ' + evt.data);
+                        changes.forEach(({ t: type, p: path, v: val }) => setNestedProperty(current, path, type, val));
+                    } else if (value !== undefined) {
+                        current = value;
+                        this._data.set(name, current);
+                    } else {
+                        throw new Error('值为空: ' + evt.data);
+                    }
+                    const namedCb = this._cbFuncs.get(name);
+                    if (namedCb) {
+                        try { namedCb({ name, value: current }); } catch (err) { this._onError(err); }
+                    } else {
+                        const allCb = this._cbFuncs.get('$all');
+                        if (allCb) {
+                            try { allCb({ name, value: current }); } catch (err) { this._onError(err); }
+                        } else {
+                            throw new Error('SSE 未处理消息: ' + evt.data);
+                        }
+                    }
+                } catch (err) {
+                    this._onError(err);
+                }
+            });
+        }
+
+        _attachEventListeners(sse) {
+            if (!this._eventListeners.length) return
+            for (const { name, fn } of this._eventListeners) {
+                sse.addEventListener(name, fn);
+            }
+        }
+
+        _scheduleReconnect() {
+            if (this._closing || this._reconnectTimer) return
+            this._reconnectTimer = setTimeout(async () => {
+                this._reconnectTimer = null;
+                try {
+                    this._sse?.close();
+                    this._sse = null;
+                    await this._connect();
+                } catch (err) {
+                    this._onError(err);
+                    this._scheduleReconnect();
+                }
+            }, this._reconnectDelay);
+            this._reconnectDelay = Math.min(MAX_RECONNECT_DELAY, this._reconnectDelay * 2);
+        }
+
+        _clearReconnectTimer() {
+            if (this._reconnectTimer) {
+                clearTimeout(this._reconnectTimer);
+                this._reconnectTimer = null;
+            }
+        }
+
+        close() {
+            this._closing = true;
+            this._clearReconnectTimer();
+            this._connectPromise = null;
+            try { this._sse?.close(); } catch (e) { /* ignore */ }
+            this._sse = null;
+        }
+
+        /**
+         * 开始监听指定的变量与事件。
+         *
+         * vars: 数组或对象
+         *   - 数组：元素可以是字符串（仅订阅）或命名函数（函数名为变量名，回调签名 ({name,value}) ）
+         *   - 对象：键为变量名，值为回调函数，回调签名 ({name,value})
+         *
+         * events: 数组或对象
+         *   - 数组：元素可以是字符串（仅订阅）或命名函数（函数名为事件名，会被注册为 listener）
+         *   - 对象：键为事件名，值为回调函数
+         *
+         * 示例：
+         *   await sse.watch({ vars: [function myVar(update) { ... }], events: [] });
+         *   await sse.watch({ vars: { myVar: (update) => { ... } }, events: { fun1: () => {}, fun2: () => {} } });
+         */
+        async watch({ vars = [], events = [] } = {}) {
+            const varNames = [];
+            const eventNames = [];
+            const eventListeners = [];
+
+            if (Array.isArray(vars)) {
+                for (const item of vars) {
+                    if (typeof item === 'function') {
+                        const name = item.name;
+                        if (!name) throw new Error('vars 回调必须是有名字的函数');
+                        varNames.push(name);
+                        this._cbFuncs.set(name, item);
+                    } else if (typeof item === 'string') {
+                        varNames.push(item);
+                    } else {
+                        throw new Error('vars 数组元素仅支持 string 或 function');
+                    }
+                }
+            } else if (typeof vars === 'object' && vars !== null) {
+                for (const [name, fn] of Object.entries(vars)) {
+                    if (typeof fn !== 'function') throw new Error(`vars 对象中 "${name}" 的值必须是函数`);
+                    varNames.push(name);
+                    this._cbFuncs.set(name, fn);
+                }
+            } else {
+                throw new Error('vars 仅支持数组或对象');
+            }
+
+            if (Array.isArray(events)) {
+                for (const item of events) {
+                    if (typeof item === 'function') {
+                        const name = item.name;
+                        if (!name) throw new Error('events 回调必须是有名字的函数');
+                        eventNames.push(name);
+                        eventListeners.push({ name, fn: item });
+                    } else if (typeof item === 'string') {
+                        eventNames.push(item);
+                    } else {
+                        throw new Error('events 数组元素仅支持 string 或 function');
+                    }
+                }
+            } else if (typeof events === 'object' && events !== null) {
+                for (const [name, fn] of Object.entries(events)) {
+                    if (typeof fn !== 'function') throw new Error(`events 对象中 "${name}" 的值必须是函数`);
+                    eventNames.push(name);
+                    eventListeners.push({ name, fn });
+                }
+            } else {
+                throw new Error('events 仅支持数组或对象');
+            }
+
+            this._eventListeners = eventListeners;
+            this._watchConfig = { varNames, eventNames };
+            this._closing = false;
+            await this._connect();
+            return this;
+        }
+
+        // 注册事件监听器的别名
+        onEvent(event, listener, options) {
+            if (!this._sse) throw new Error('未连接');
+            this._eventListeners.push({ name: event, fn: listener });
+            return this._sse.addEventListener(event, listener, options);
+        }
+
+        // 移除 SSE 事件监听器
+        offEvent(event, listener, options) {
+            if (!this._sse) throw new Error('未连接');
+            return this._sse.removeEventListener(event, listener, options);
+        }
+
+        // 通过 HTTP POST 将事件发送到服务器
+        emit(event, data) {
+            return SSE.emit(event, data, { host: this._host, namespace: this._namespace });
+        }
+
+        // 获取当前变量快照（Map）。如需单个变量，请使用 get(name)
+        getAll() { return this._data; }
+
+        // 读取单个变量的当前值（如果不存在返回 undefined）
+        get(name) { return this._data.get(name); }
+
+    }
+
+    exports.SSE = SSE;
+    exports.SyncVar = SyncVar;
+    exports.VersionInfo = VersionInfo;
+    exports.WebSocketClient = WebSocketClient;
+    exports.Worker = Worker;
+
+}));