mcbe-ipc 2.0.0 → 3.0.0

package/dist/ipc.js

@@ -22,15 +22,634 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  */
-import { world, system, ScriptEventSource } from '@minecraft/server';
-var IPC;
+import { ScriptEventSource, system, world } from '@minecraft/server';
+export var SERDE;
+(function (SERDE) {
+    class ByteArray {
+        get _end() {
+            return this._length + this._offset;
+        }
+        constructor(size = 256) {
+            this._buffer = new Uint8Array(size);
+            this._data_view = new DataView(this._buffer.buffer);
+            this._length = 0;
+            this._offset = 0;
+        }
+        write(...values) {
+            this._ensure_capacity(this._end + values.length);
+            this._buffer.set(values, this._end);
+            this._length += values.length;
+        }
+        read(amount = 1) {
+            if (this._length > 0) {
+                const max_amount = amount > this._length ? this._length : amount;
+                const values = this._buffer.subarray(this._offset, this._offset + max_amount);
+                this._length -= max_amount;
+                this._offset += max_amount;
+                return Array.from(values);
+            }
+            return [];
+        }
+        write_uint8(value) {
+            this._ensure_capacity(this._end + 1);
+            this._data_view.setUint8(this._end, value);
+            this._length += 1;
+        }
+        read_uint8() {
+            if (this._length >= 1) {
+                const value = this._data_view.getUint8(this._offset);
+                this._length -= 1;
+                this._offset += 1;
+                return value;
+            }
+            return undefined;
+        }
+        write_uint16(value) {
+            this._ensure_capacity(this._end + 2);
+            this._data_view.setUint16(this._end, value);
+            this._length += 2;
+        }
+        read_uint16() {
+            if (this._length >= 2) {
+                const value = this._data_view.getUint16(this._offset);
+                this._length -= 2;
+                this._offset += 2;
+                return value;
+            }
+            return undefined;
+        }
+        write_uint32(value) {
+            this._ensure_capacity(this._end + 4);
+            this._data_view.setUint32(this._end, value);
+            this._length += 4;
+        }
+        read_uint32() {
+            if (this._length >= 4) {
+                const value = this._data_view.getUint32(this._offset);
+                this._length -= 4;
+                this._offset += 4;
+                return value;
+            }
+            return undefined;
+        }
+        write_int8(value) {
+            this._ensure_capacity(this._end + 1);
+            this._data_view.setInt8(this._end, value);
+            this._length += 1;
+        }
+        read_int8() {
+            if (this._length >= 1) {
+                const value = this._data_view.getInt8(this._offset);
+                this._length -= 1;
+                this._offset += 1;
+                return value;
+            }
+            return undefined;
+        }
+        write_int16(value) {
+            this._ensure_capacity(this._end + 2);
+            this._data_view.setInt16(this._end, value);
+            this._length += 2;
+        }
+        read_int16() {
+            if (this._length >= 2) {
+                const value = this._data_view.getInt16(this._offset);
+                this._length -= 2;
+                this._offset += 2;
+                return value;
+            }
+            return undefined;
+        }
+        write_int32(value) {
+            this._ensure_capacity(this._end + 4);
+            this._data_view.setInt32(this._end, value);
+            this._length += 4;
+        }
+        read_int32() {
+            if (this._length >= 4) {
+                const value = this._data_view.getInt32(this._offset);
+                this._length -= 4;
+                this._offset += 4;
+                return value;
+            }
+            return undefined;
+        }
+        write_f32(value) {
+            this._ensure_capacity(this._end + 4);
+            this._data_view.setFloat32(this._end, value);
+            this._length += 4;
+        }
+        read_f32() {
+            if (this._length >= 4) {
+                const value = this._data_view.getFloat32(this._offset);
+                this._length -= 4;
+                this._offset += 4;
+                return value;
+            }
+            return undefined;
+        }
+        write_f64(value) {
+            this._ensure_capacity(this._end + 8);
+            this._data_view.setFloat64(this._end, value);
+            this._length += 8;
+        }
+        read_f64() {
+            if (this._length >= 8) {
+                const value = this._data_view.getFloat64(this._offset);
+                this._length -= 8;
+                this._offset += 8;
+                return value;
+            }
+            return undefined;
+        }
+        _ensure_capacity(size) {
+            if (size > this._buffer.length) {
+                const larger_buffer = new Uint8Array(size * 2);
+                larger_buffer.set(this._buffer.subarray(this._offset, this._end), 0);
+                this._buffer = larger_buffer;
+                this._offset = 0;
+                this._data_view = new DataView(this._buffer.buffer);
+            }
+        }
+        static from_uint8array(array) {
+            const byte_array = new ByteArray();
+            byte_array._buffer = array;
+            byte_array._length = array.length;
+            byte_array._offset = 0;
+            byte_array._data_view = new DataView(array.buffer);
+            return byte_array;
+        }
+        to_uint8array() {
+            return this._buffer.subarray(this._offset, this._end);
+        }
+    }
+    SERDE.ByteArray = ByteArray;
+    function* serialize(byte_array, max_size = Infinity) {
+        const uint8array = byte_array.to_uint8array();
+        const result = [];
+        let acc_str = '';
+        let acc_size = 0;
+        for (let i = 0; i < uint8array.length; i++) {
+            const char_code = uint8array[i] | (uint8array[++i] << 8);
+            const utf16_size = char_code <= 0x7f ? 1 : char_code <= 0x7ff ? 2 : char_code <= 0xffff ? 3 : 4;
+            const char_size = char_code > 0xff ? utf16_size : 3;
+            if (acc_size + char_size > max_size) {
+                result.push(acc_str);
+                acc_str = '';
+                acc_size = 0;
+            }
+            if (char_code > 0xff) {
+                acc_str += String.fromCharCode(char_code);
+                acc_size += utf16_size;
+            }
+            else {
+                acc_str += `?${char_code.toString(16).padStart(2, '0')}`;
+                acc_size += 3;
+            }
+            yield;
+        }
+        result.push(acc_str);
+        return result;
+    }
+    SERDE.serialize = serialize;
+    function* deserialize(strings) {
+        const result = [];
+        for (let i = 0; i < strings.length; i++) {
+            const str = strings[i];
+            for (let j = 0; j < str.length; j++) {
+                const char_code = str.charCodeAt(j);
+                if (char_code === '?'.charCodeAt(0) && j + 2 < str.length) {
+                    const hex = str.slice(j + 1, j + 3);
+                    const hex_code = parseInt(hex, 16);
+                    result.push(hex_code & 0xff);
+                    result.push(hex_code >> 8);
+                    j += 2;
+                }
+                else {
+                    result.push(char_code & 0xff);
+                    result.push(char_code >> 8);
+                }
+                yield;
+            }
+            yield;
+        }
+        return ByteArray.from_uint8array(new Uint8Array(result));
+    }
+    SERDE.deserialize = deserialize;
+})(SERDE || (SERDE = {}));
+var CRYPTO;
+(function (CRYPTO) {
+    CRYPTO.PRIME = 19893121;
+    CRYPTO.MOD = 341;
+    const to_HEX = (n) => n.toString(16).toUpperCase();
+    const to_NUM = (h) => parseInt(h, 16);
+    function* mod_exp(base, exp, mod) {
+        let result = 1;
+        let b = base % mod;
+        for (let e = exp; e > 0; e = Math.floor(e / 2)) {
+            if (e % 2 === 1) {
+                result = (result * b) % mod;
+            }
+            b = (b * b) % mod;
+            yield;
+        }
+        return result;
+    }
+    function make_secret(mod = CRYPTO.MOD) {
+        return Math.floor(Math.random() * (mod - 1)) + 1;
+    }
+    CRYPTO.make_secret = make_secret;
+    function* make_public(secret, mod = CRYPTO.MOD, prime = CRYPTO.PRIME) {
+        return to_HEX(yield* mod_exp(mod, secret, prime));
+    }
+    CRYPTO.make_public = make_public;
+    function* make_shared(secret, other, prime = CRYPTO.PRIME) {
+        return to_HEX(yield* mod_exp(to_NUM(other), secret, prime));
+    }
+    CRYPTO.make_shared = make_shared;
+    function* encrypt(raw, key) {
+        let encrypted = new Uint8Array(raw.length);
+        for (let i = 0; i < raw.length; i++) {
+            encrypted[i] = raw[i] ^ key.charCodeAt(i % key.length);
+            yield;
+        }
+        return encrypted;
+    }
+    CRYPTO.encrypt = encrypt;
+    function* decrypt(encrypted, key) {
+        let decrypted = new Uint8Array(encrypted.length);
+        for (let i = 0; i < encrypted.length; i++) {
+            decrypted[i] = encrypted[i] ^ key.charCodeAt(i % key.length);
+            yield;
+        }
+        return decrypted;
+    }
+    CRYPTO.decrypt = decrypt;
+})(CRYPTO || (CRYPTO = {}));
+export class Proto {
+    static Object(obj) {
+        return {
+            *serialize(value, stream) {
+                for (const key in obj) {
+                    yield* obj[key].serialize(value[key], stream);
+                }
+            },
+            *deserialize(stream) {
+                const result = {};
+                for (const key in obj) {
+                    result[key] = yield* obj[key].deserialize(stream);
+                }
+                return result;
+            }
+        };
+    }
+    static Array(items) {
+        return {
+            *serialize(value, stream) {
+                yield* Proto.VarInt.serialize(value.length, stream);
+                for (const item of value) {
+                    yield* items.serialize(item, stream);
+                }
+            },
+            *deserialize(stream) {
+                const result = [];
+                const length = yield* Proto.VarInt.deserialize(stream);
+                for (let i = 0; i < length; i++) {
+                    result[i] = yield* items.deserialize(stream);
+                }
+                return result;
+            }
+        };
+    }
+    static Tuple(...items) {
+        return {
+            *serialize(value, stream) {
+                for (let i = 0; i < items.length; i++) {
+                    yield* items[i].serialize(value[i], stream);
+                }
+            },
+            *deserialize(stream) {
+                const result = [];
+                for (let i = 0; i < items.length; i++) {
+                    result[i] = yield* items[i].deserialize(stream);
+                }
+                return result;
+            }
+        };
+    }
+    static Optional(item) {
+        return {
+            *serialize(value, stream) {
+                yield* Proto.Boolean.serialize(value !== undefined, stream);
+                if (value !== undefined) {
+                    yield* item.serialize(value, stream);
+                }
+            },
+            *deserialize(stream) {
+                const defined = yield* Proto.Boolean.deserialize(stream);
+                if (defined) {
+                    return yield* item.deserialize(stream);
+                }
+            }
+        };
+    }
+    static Map(key, value) {
+        return {
+            *serialize(map, stream) {
+                yield* Proto.VarInt.serialize(map.size, stream);
+                for (const [k, v] of map.entries()) {
+                    yield* key.serialize(k, stream);
+                    yield* value.serialize(v, stream);
+                }
+            },
+            *deserialize(stream) {
+                const size = yield* Proto.VarInt.deserialize(stream);
+                const result = new Map();
+                for (let i = 0; i < size; i++) {
+                    const k = yield* key.deserialize(stream);
+                    const v = yield* value.deserialize(stream);
+                    result.set(k, v);
+                }
+                return result;
+            }
+        };
+    }
+    static Set(value) {
+        return {
+            *serialize(set, stream) {
+                yield* Proto.VarInt.serialize(set.size, stream);
+                for (const [_, v] of set.entries()) {
+                    yield* value.serialize(v, stream);
+                }
+            },
+            *deserialize(stream) {
+                const size = yield* Proto.VarInt.deserialize(stream);
+                const result = new Set();
+                for (let i = 0; i < size; i++) {
+                    const v = yield* value.deserialize(stream);
+                    result.add(v);
+                }
+                return result;
+            }
+        };
+    }
+}
+Proto.Int8 = {
+    *serialize(value, stream) {
+        stream.write_int8(value);
+    },
+    *deserialize(stream) {
+        return stream.read_int8();
+    }
+};
+Proto.Int16 = {
+    *serialize(value, stream) {
+        stream.write_int16(value);
+    },
+    *deserialize(stream) {
+        return stream.read_int16();
+    }
+};
+Proto.Int32 = {
+    *serialize(value, stream) {
+        stream.write_int32(value);
+    },
+    *deserialize(stream) {
+        return stream.read_int32();
+    }
+};
+Proto.UInt8 = {
+    *serialize(value, stream) {
+        stream.write_uint8(value);
+    },
+    *deserialize(stream) {
+        return stream.read_uint8();
+    }
+};
+Proto.UInt16 = {
+    *serialize(value, stream) {
+        stream.write_uint16(value);
+    },
+    *deserialize(stream) {
+        return stream.read_uint16();
+    }
+};
+Proto.UInt32 = {
+    *serialize(value, stream) {
+        stream.write_uint32(value);
+    },
+    *deserialize(stream) {
+        return stream.read_uint32();
+    }
+};
+Proto.Float32 = {
+    *serialize(value, stream) {
+        stream.write_f32(value);
+    },
+    *deserialize(stream) {
+        return stream.read_f32();
+    }
+};
+Proto.Float64 = {
+    *serialize(value, stream) {
+        stream.write_f64(value);
+    },
+    *deserialize(stream) {
+        return stream.read_f64();
+    }
+};
+Proto.VarInt = {
+    *serialize(value, stream) {
+        while (value >= 0x80) {
+            stream.write((value & 0x7f) | 0x80);
+            value >>= 7;
+            yield;
+        }
+        stream.write(value);
+    },
+    *deserialize(stream) {
+        let value = 0;
+        let shift = 0;
+        let byte;
+        do {
+            byte = stream.read()[0];
+            value |= (byte & 0x7f) << shift;
+            shift += 7;
+            yield;
+        } while (byte & 0x80);
+        return value;
+    }
+};
+Proto.String = {
+    *serialize(value, stream) {
+        yield* Proto.VarInt.serialize(value.length, stream);
+        for (let i = 0; i < value.length; i++) {
+            const code = value.charCodeAt(i);
+            yield* Proto.VarInt.serialize(code, stream);
+        }
+    },
+    *deserialize(stream) {
+        const length = yield* Proto.VarInt.deserialize(stream);
+        let value = '';
+        for (let i = 0; i < length; i++) {
+            const code = yield* Proto.VarInt.deserialize(stream);
+            value += String.fromCharCode(code);
+        }
+        return value;
+    }
+};
+Proto.Boolean = {
+    *serialize(value, stream) {
+        stream.write(value ? 1 : 0);
+    },
+    *deserialize(stream) {
+        const value = stream.read()[0];
+        return value === 1;
+    }
+};
+Proto.UInt8Array = {
+    *serialize(value, stream) {
+        yield* Proto.VarInt.serialize(value.length, stream);
+        for (const item of value) {
+            stream.write_uint8(item);
+            yield;
+        }
+    },
+    *deserialize(stream) {
+        const length = yield* Proto.VarInt.deserialize(stream);
+        const result = new Uint8Array(length);
+        for (let i = 0; i < length; i++) {
+            result[i] = stream.read_uint8();
+        }
+        return result;
+    }
+};
+Proto.Date = {
+    *serialize(value, stream) {
+        yield* Proto.VarInt.serialize(value.getTime(), stream);
+    },
+    *deserialize(stream) {
+        return new Date(yield* Proto.VarInt.deserialize(stream));
+    }
+};
+export var NET;
+(function (NET) {
+    var ByteArray = SERDE.ByteArray;
+    const FRAG_MAX = 2048;
+    const Header = Proto.Object({
+        guid: Proto.String,
+        index: Proto.VarInt,
+        final: Proto.Boolean
+    });
+    const endpoint_map = new Map();
+    system.afterEvents.scriptEventReceive.subscribe(event => {
+        system.runJob((function* () {
+            const [serialized_endpoint, serialized_header] = event.id.split(':');
+            const endpoint_stream = yield* SERDE.deserialize([serialized_endpoint]);
+            const endpoint = yield* Proto.String.deserialize(endpoint_stream);
+            const listeners = endpoint_map.get(endpoint);
+            if (event.sourceType === ScriptEventSource.Server && listeners) {
+                const header_stream = yield* SERDE.deserialize([serialized_header]);
+                const header = yield* Header.deserialize(header_stream);
+                for (let i = 0; i < listeners.length; i++) {
+                    yield* listeners[i](header, event.message);
+                }
+            }
+        })());
+    });
+    function create_listener(endpoint, listener) {
+        let listeners = endpoint_map.get(endpoint);
+        if (!listeners) {
+            listeners = new Array();
+            endpoint_map.set(endpoint, listeners);
+        }
+        listeners.push(listener);
+        return () => {
+            const idx = listeners.indexOf(listener);
+            if (idx !== -1)
+                listeners.splice(idx, 1);
+            if (listeners.length === 0) {
+                endpoint_map.delete(endpoint);
+            }
+        };
+    }
+    function generate_id() {
+        const r = (Math.random() * 0x100000000) >>> 0;
+        return ((r & 0xff).toString(16).padStart(2, '0') +
+            ((r >> 8) & 0xff).toString(16).padStart(2, '0') +
+            ((r >> 16) & 0xff).toString(16).padStart(2, '0') +
+            ((r >> 24) & 0xff).toString(16).padStart(2, '0')).toUpperCase();
+    }
+    function* emit(endpoint, serializer, value) {
+        const guid = generate_id();
+        const endpoint_stream = new ByteArray();
+        yield* Proto.String.serialize(endpoint, endpoint_stream);
+        const [serialized_endpoint] = yield* SERDE.serialize(endpoint_stream);
+        const RUN = function* (header, serialized_packet) {
+            const header_stream = new SERDE.ByteArray();
+            yield* Header.serialize(header, header_stream);
+            const [serialized_header] = yield* SERDE.serialize(header_stream);
+            world
+                .getDimension('overworld')
+                .runCommand(`scriptevent ${serialized_endpoint}:${serialized_header} ${serialized_packet}`);
+        };
+        const packet_stream = new ByteArray();
+        yield* serializer.serialize(value, packet_stream);
+        const serialized_packets = yield* SERDE.serialize(packet_stream, FRAG_MAX);
+        for (let i = 0; i < serialized_packets.length; i++) {
+            const serialized_packet = serialized_packets[i];
+            yield* RUN({ guid, index: i, final: i === serialized_packets.length - 1 }, serialized_packet);
+        }
+    }
+    NET.emit = emit;
+    function listen(endpoint, serializer, callback) {
+        const buffer = new Map();
+        const listener = function* (payload, serialized_packet) {
+            let fragment = buffer.get(payload.guid);
+            if (!fragment) {
+                fragment = { size: -1, serialized_packets: [], data_size: 0 };
+                buffer.set(payload.guid, fragment);
+            }
+            if (payload.final) {
+                fragment.size = payload.index + 1;
+            }
+            fragment.serialized_packets[payload.index] = serialized_packet;
+            fragment.data_size += payload.index + 1;
+            if (fragment.size !== -1 && fragment.data_size === (fragment.size * (fragment.size + 1)) / 2) {
+                const stream = yield* SERDE.deserialize(fragment.serialized_packets);
+                const value = yield* serializer.deserialize(stream);
+                yield* callback(value);
+                buffer.delete(payload.guid);
+            }
+        };
+        return create_listener(endpoint, listener);
+    }
+    NET.listen = listen;
+})(NET || (NET = {}));
+export var IPC;
 (function (IPC) {
+    const ConnectionSerializer = Proto.Object({
+        from: Proto.String,
+        bytes: Proto.UInt8Array
+    });
+    const HandshakeSynchronizeSerializer = Proto.Object({
+        from: Proto.String,
+        encryption_enabled: Proto.Boolean,
+        encryption_public_key: Proto.String,
+        encryption_prime: Proto.VarInt,
+        encryption_modulus: Proto.VarInt
+    });
+    const HandshakeAcknowledgeSerializer = Proto.Object({
+        from: Proto.String,
+        encryption_enabled: Proto.Boolean,
+        encryption_public_key: Proto.String
+    });
     class Connection {
-        *MAYBE_ENCRYPT(args) {
-            return this._enc !== false ? yield* CRYPTO.encrypt(JSON.stringify(args), this._enc) : args;
+        *MAYBE_ENCRYPT(bytes) {
+            return this._enc !== false ? yield* CRYPTO.encrypt(bytes, this._enc) : bytes;
         }
-        *MAYBE_DECRYPT(args) {
-            return this._enc !== false ? JSON.parse(yield* CRYPTO.decrypt(args[1], this._enc)) : args[1];
+        *MAYBE_DECRYPT(bytes) {
+            return this._enc !== false ? yield* CRYPTO.decrypt(bytes, this._enc) : bytes;
         }
         get from() {
             return this._from;
@@ -49,63 +668,86 @@ var IPC;
             $._terminators.forEach(terminate => terminate());
             $._terminators.length = 0;
             if (notify) {
-                system.runJob(NET.emit('ipc', `${$._to}:terminate`, [$._from]));
+                system.runJob(NET.emit(`ipc:${$._to}:terminate`, Proto.String, $._from));
             }
         }
-        send(channel, ...args) {
+        send(channel, serializer, value) {
             const $ = this;
             system.runJob((function* () {
-                const data = yield* $.MAYBE_ENCRYPT(args);
-                yield* NET.emit('ipc', `${$._to}:${channel}:send`, [$._from, data]);
+                const stream = new SERDE.ByteArray();
+                yield* serializer.serialize(value, stream);
+                const bytes = yield* $.MAYBE_ENCRYPT(stream.to_uint8array());
+                yield* NET.emit(`ipc:${$._to}:${channel}:send`, ConnectionSerializer, {
+                    from: $._from,
+                    bytes
+                });
             })());
         }
-        invoke(channel, ...args) {
+        invoke(channel, serializer, value, deserializer) {
             const $ = this;
             system.runJob((function* () {
-                const data = yield* $.MAYBE_ENCRYPT(args);
-                yield* NET.emit('ipc', `${$._to}:${channel}:invoke`, [$._from, data]);
+                const stream = new SERDE.ByteArray();
+                yield* serializer.serialize(value, stream);
+                const bytes = yield* $.MAYBE_ENCRYPT(stream.to_uint8array());
+                yield* NET.emit(`ipc:${$._to}:${channel}:invoke`, ConnectionSerializer, {
+                    from: $._from,
+                    bytes
+                });
             })());
             return new Promise(resolve => {
-                const terminate = NET.listen('ipc', `${$._from}:${channel}:handle`, function* (args) {
-                    if (args[0] === $._to) {
-                        const data = yield* $.MAYBE_DECRYPT(args);
-                        resolve(data);
+                const terminate = NET.listen(`ipc:${$._from}:${channel}:handle`, ConnectionSerializer, function* (data) {
+                    if (data.from === $._to) {
+                        const bytes = yield* $.MAYBE_DECRYPT(data.bytes);
+                        const stream = SERDE.ByteArray.from_uint8array(bytes);
+                        const value = yield* deserializer.deserialize(stream);
+                        resolve(value);
                         terminate();
                     }
                 });
             });
         }
-        on(channel, listener) {
+        on(channel, deserializer, listener) {
             const $ = this;
-            const terminate = NET.listen('ipc', `${$._from}:${channel}:send`, function* (args) {
-                if (args[0] === $._to) {
-                    const data = yield* $.MAYBE_DECRYPT(args);
-                    listener(...data);
+            const terminate = NET.listen(`ipc:${$._from}:${channel}:send`, ConnectionSerializer, function* (data) {
+                if (data.from === $._to) {
+                    const bytes = yield* $.MAYBE_DECRYPT(data.bytes);
+                    const stream = SERDE.ByteArray.from_uint8array(bytes);
+                    const value = yield* deserializer.deserialize(stream);
+                    listener(value);
                 }
             });
             $._terminators.push(terminate);
             return terminate;
         }
-        once(channel, listener) {
+        once(channel, deserializer, listener) {
             const $ = this;
-            const terminate = NET.listen('ipc', `${$._from}:${channel}:send`, function* (args) {
-                if (args[0] === $._to) {
-                    const data = yield* $.MAYBE_DECRYPT(args);
-                    listener(...data);
+            const terminate = NET.listen(`ipc:${$._from}:${channel}:send`, ConnectionSerializer, function* (data) {
+                if (data.from === $._to) {
+                    const bytes = yield* $.MAYBE_DECRYPT(data.bytes);
+                    const stream = SERDE.ByteArray.from_uint8array(bytes);
+                    const value = yield* deserializer.deserialize(stream);
+                    listener(value);
                     terminate();
                 }
             });
             $._terminators.push(terminate);
             return terminate;
         }
-        handle(channel, listener) {
+        handle(channel, deserializer, serializer, listener) {
             const $ = this;
-            const terminate = NET.listen('ipc', `${$._from}:${channel}:invoke`, function* (args) {
-                if (args[0] === $._to) {
-                    const data = yield* $.MAYBE_DECRYPT(args);
-                    const result = listener(...data);
-                    const return_data = yield* $.MAYBE_ENCRYPT([result]);
-                    yield* NET.emit('ipc', `${$._to}:${channel}:handle`, [$._from, return_data]);
+            const terminate = NET.listen(`ipc:${$._from}:${channel}:invoke`, ConnectionSerializer, function* (data) {
+                if (data.from === $._to) {
+                    const bytes = yield* $.MAYBE_DECRYPT(data.bytes);
+                    const stream = SERDE.ByteArray.from_uint8array(bytes);
+                    const value = yield* deserializer.deserialize(stream);
+                    const result = listener(value);
+                    const return_stream = new SERDE.ByteArray();
+                    yield* serializer.serialize(result, return_stream);
+                    const return_bytes = yield* $.MAYBE_ENCRYPT(return_stream.to_uint8array());
+                    yield* NET.emit(`ipc:${$._to}:${channel}:handle`, ConnectionSerializer, {
+                        from: $._from,
+                        bytes: return_bytes
+                    });
                 }
             });
             $._terminators.push(terminate);
@@ -114,11 +756,11 @@ var IPC;
     }
     IPC.Connection = Connection;
     class ConnectionManager {
-        *MAYBE_ENCRYPT(args, encryption) {
-            return encryption !== false ? yield* CRYPTO.encrypt(JSON.stringify(args), encryption) : args;
+        *MAYBE_ENCRYPT(bytes, encryption) {
+            return encryption !== false ? yield* CRYPTO.encrypt(bytes, encryption) : bytes;
         }
-        *MAYBE_DECRYPT(args, encryption) {
-            return encryption !== false ? JSON.parse(yield* CRYPTO.decrypt(args[1], encryption)) : args[1];
+        *MAYBE_DECRYPT(bytes, encryption) {
+            return encryption !== false ? yield* CRYPTO.decrypt(bytes, encryption) : bytes;
         }
         get id() {
             return this._id;
@@ -129,19 +771,21 @@ var IPC;
             this._enc_map = new Map();
             this._con_map = new Map();
             this._enc_force = force_encryption;
-            NET.listen('ipc', `${this._id}:handshake:SYN`, function* (args) {
-                const secret = CRYPTO.make_secret(args[4]);
-                const public_key = yield* CRYPTO.make_public(secret, args[4], args[3]);
-                const enc = args[1] === 1 || $._enc_force ? yield* CRYPTO.make_shared(secret, args[2], args[3]) : false;
-                $._enc_map.set(args[0], enc);
-                yield* NET.emit('ipc', `${args[0]}:handshake:ACK`, [
-                    $._id,
-                    $._enc_force ? 1 : 0,
-                    public_key
-                ]);
+            NET.listen(`ipc:${this._id}:handshake:synchronize`, HandshakeSynchronizeSerializer, function* (data) {
+                const secret = CRYPTO.make_secret(data.encryption_modulus);
+                const public_key = yield* CRYPTO.make_public(secret, data.encryption_modulus, data.encryption_prime);
+                const enc = data.encryption_enabled || $._enc_force
+                    ? yield* CRYPTO.make_shared(secret, data.encryption_public_key, data.encryption_prime)
+                    : false;
+                $._enc_map.set(data.from, enc);
+                yield* NET.emit(`ipc:${data.from}:handshake:acknowledge`, HandshakeAcknowledgeSerializer, {
+                    from: $._id,
+                    encryption_public_key: public_key,
+                    encryption_enabled: $._enc_force
+                });
             });
-            NET.listen('ipc', `${this._id}:terminate`, function* (args) {
-                $._enc_map.delete(args[0]);
+            NET.listen(`ipc:${this._id}:terminate`, Proto.String, function* (value) {
+                $._enc_map.delete(value);
             });
         }
         connect(to, encrypted = false, timeout = 20) {
@@ -154,16 +798,15 @@ var IPC;
                 }
                 else {
                     const secret = CRYPTO.make_secret();
-                    const enc_flag = encrypted ? 1 : 0;
                     system.runJob((function* () {
                         const public_key = yield* CRYPTO.make_public(secret);
-                        yield* NET.emit('ipc', `${to}:handshake:SYN`, [
-                            $._id,
-                            enc_flag,
-                            public_key,
-                            CRYPTO.PRIME,
-                            CRYPTO.MOD
-                        ]);
+                        yield* NET.emit(`ipc:${to}:handshake:synchronize`, HandshakeSynchronizeSerializer, {
+                            from: $._id,
+                            encryption_enabled: encrypted,
+                            encryption_public_key: public_key,
+                            encryption_prime: CRYPTO.PRIME,
+                            encryption_modulus: CRYPTO.MOD
+                        });
                     })());
                     function clear() {
                         terminate();
@@ -173,9 +816,11 @@ var IPC;
                         reject();
                         clear();
                     }, timeout);
-                    const terminate = NET.listen('ipc', `${this._id}:handshake:ACK`, function* (args) {
-                        if (args[0] === to) {
-                            const enc = args[1] === 1 || encrypted ? yield* CRYPTO.make_shared(secret, args[2]) : false;
+                    const terminate = NET.listen(`ipc:${this._id}:handshake:acknowledge`, HandshakeAcknowledgeSerializer, function* (data) {
+                        if (data.from === to) {
+                            const enc = data.encryption_enabled || encrypted
+                                ? yield* CRYPTO.make_shared(secret, data.encryption_public_key)
+                                : false;
                             const new_con = new Connection($._id, to, enc);
                             $._con_map.set(to, new_con);
                             resolve(new_con);
@@ -185,28 +830,40 @@ var IPC;
                 }
             });
         }
-        send(channel, ...args) {
+        send(channel, serializer, value) {
             const $ = this;
             system.runJob((function* () {
-                for (const [key, value] of $._enc_map) {
-                    const data = yield* $.MAYBE_ENCRYPT(args, value);
-                    yield* NET.emit('ipc', `${key}:${channel}:send`, [$._id, data]);
+                for (const [key, enc] of $._enc_map) {
+                    const stream = new SERDE.ByteArray();
+                    yield* serializer.serialize(value, stream);
+                    const bytes = yield* $.MAYBE_ENCRYPT(stream.to_uint8array(), enc);
+                    yield* NET.emit(`ipc:${key}:${channel}:send`, ConnectionSerializer, {
+                        from: $._id,
+                        bytes
+                    });
                 }
             })());
         }
-        invoke(channel, ...args) {
+        invoke(channel, serializer, value, deserializer) {
             const $ = this;
             const promises = [];
-            for (const [key, value] of $._enc_map) {
+            for (const [key, enc] of $._enc_map) {
                 system.runJob((function* () {
-                    const data = yield* $.MAYBE_ENCRYPT(args, value);
-                    yield* NET.emit('ipc', `${key}:${channel}:invoke`, [$._id, data]);
+                    const stream = new SERDE.ByteArray();
+                    yield* serializer.serialize(value, stream);
+                    const bytes = yield* $.MAYBE_ENCRYPT(stream.to_uint8array(), enc);
+                    yield* NET.emit(`ipc:${key}:${channel}:invoke`, ConnectionSerializer, {
+                        from: $._id,
+                        bytes
+                    });
                 })());
                 promises.push(new Promise(resolve => {
-                    const terminate = NET.listen('ipc', `${$._id}:${channel}:handle`, function* (args) {
-                        if (args[0] === key) {
-                            const data = yield* $.MAYBE_DECRYPT(args, value);
-                            resolve(data);
+                    const terminate = NET.listen(`ipc:${$._id}:${channel}:handle`, ConnectionSerializer, function* (data) {
+                        if (data.from === key) {
+                            const bytes = yield* $.MAYBE_DECRYPT(data.bytes, enc);
+                            const stream = SERDE.ByteArray.from_uint8array(bytes);
+                            const value = yield* deserializer.deserialize(stream);
+                            resolve(value);
                             terminate();
                         }
                     });
@@ -214,302 +871,92 @@ var IPC;
             }
             return promises;
         }
-        on(channel, listener) {
+        on(channel, deserializer, listener) {
             const $ = this;
-            return NET.listen('ipc', `${$._id}:${channel}:send`, function* (args) {
-                const enc = $._enc_map.get(args[0]);
+            return NET.listen(`ipc:${$._id}:${channel}:send`, ConnectionSerializer, function* (data) {
+                const enc = $._enc_map.get(data.from);
                 if (enc !== undefined) {
-                    const data = yield* $.MAYBE_DECRYPT(args, enc);
-                    listener(...data);
+                    const bytes = yield* $.MAYBE_DECRYPT(data.bytes, enc);
+                    const stream = SERDE.ByteArray.from_uint8array(bytes);
+                    const value = yield* deserializer.deserialize(stream);
+                    listener(value);
                 }
             });
         }
-        once(channel, listener) {
+        once(channel, deserializer, listener) {
             const $ = this;
-            const terminate = NET.listen('ipc', `${$._id}:${channel}:send`, function* (args) {
-                const enc = $._enc_map.get(args[0]);
+            const terminate = NET.listen(`ipc:${$._id}:${channel}:send`, ConnectionSerializer, function* (data) {
+                const enc = $._enc_map.get(data.from);
                 if (enc !== undefined) {
-                    const data = yield* $.MAYBE_DECRYPT(args, enc);
-                    listener(...data);
+                    const bytes = yield* $.MAYBE_DECRYPT(data.bytes, enc);
+                    const stream = SERDE.ByteArray.from_uint8array(bytes);
+                    const value = yield* deserializer.deserialize(stream);
+                    listener(value);
                     terminate();
                 }
             });
             return terminate;
         }
-        handle(channel, listener) {
+        handle(channel, deserializer, serializer, listener) {
             const $ = this;
-            return NET.listen('ipc', `${$._id}:${channel}:invoke`, function* (args) {
-                const enc = $._enc_map.get(args[0]);
+            return NET.listen(`ipc:${$._id}:${channel}:invoke`, ConnectionSerializer, function* (data) {
+                const enc = $._enc_map.get(data.from);
                 if (enc !== undefined) {
-                    const data = yield* $.MAYBE_DECRYPT(args, enc);
-                    const result = listener(...data);
-                    const return_data = yield* $.MAYBE_ENCRYPT([result], enc);
-                    yield* NET.emit('ipc', `${args[0]}:${channel}:handle`, [$._id, return_data]);
+                    const input_bytes = yield* $.MAYBE_DECRYPT(data.bytes, enc);
+                    const input_stream = SERDE.ByteArray.from_uint8array(input_bytes);
+                    const input_value = yield* deserializer.deserialize(input_stream);
+                    const result = listener(input_value);
+                    const output_stream = new SERDE.ByteArray();
+                    yield* serializer.serialize(result, output_stream);
+                    const output_bytes = yield* $.MAYBE_ENCRYPT(output_stream.to_uint8array(), enc);
+                    yield* NET.emit(`ipc:${data.from}:${channel}:handle`, ConnectionSerializer, {
+                        from: $._id,
+                        bytes: output_bytes
+                    });
                 }
             });
         }
     }
     IPC.ConnectionManager = ConnectionManager;
     /** Sends a message with `args` to `channel` */
-    function send(channel, ...args) {
-        system.runJob(NET.emit('ipc', `${channel}:send`, args));
+    function send(channel, serializer, value) {
+        system.runJob(NET.emit(`ipc:${channel}:send`, serializer, value));
     }
     IPC.send = send;
-    function invoke(channel, ...args) {
-        system.runJob(NET.emit('ipc', `${channel}:invoke`, args));
+    /** Sends an `invoke` message through IPC, and expects a result asynchronously. */
+    function invoke(channel, serializer, value, deserializer) {
+        system.runJob(NET.emit(`ipc:${channel}:invoke`, serializer, value));
         return new Promise(resolve => {
-            const terminate = NET.listen('ipc', `${channel}:handle`, function* (args) {
-                resolve(args);
+            const terminate = NET.listen(`ipc:${channel}:handle`, deserializer, function* (value) {
+                resolve(value);
                 terminate();
             });
         });
     }
     IPC.invoke = invoke;
     /** Listens to `channel`. When a new message arrives, `listener` will be called with `listener(args)`. */
-    function on(channel, listener) {
-        return NET.listen('ipc', `${channel}:send`, function* (args) {
-            listener(...args);
+    function on(channel, deserializer, listener) {
+        return NET.listen(`ipc:${channel}:send`, deserializer, function* (value) {
+            listener(value);
         });
     }
     IPC.on = on;
     /** Listens to `channel` once. When a new message arrives, `listener` will be called with `listener(args)`, and then removed. */
-    function once(channel, listener) {
-        const terminate = NET.listen('ipc', `${channel}:send`, function* (args) {
-            listener(...args);
+    function once(channel, deserializer, listener) {
+        const terminate = NET.listen(`ipc:${channel}:send`, deserializer, function* (value) {
+            listener(value);
             terminate();
         });
         return terminate;
     }
     IPC.once = once;
     /** Adds a handler for an `invoke` IPC. This handler will be called whenever `invoke(channel, ...args)` is called */
-    function handle(channel, listener) {
-        return NET.listen('ipc', `${channel}:invoke`, function* (args) {
-            const result = listener(...args);
-            yield* NET.emit('ipc', `${channel}:handle`, result);
+    function handle(channel, deserializer, serializer, listener) {
+        return NET.listen(`ipc:${channel}:invoke`, deserializer, function* (value) {
+            const result = listener(value);
+            yield* NET.emit(`ipc:${channel}:handle`, serializer, result);
         });
     }
     IPC.handle = handle;
 })(IPC || (IPC = {}));
 export default IPC;
-var SERDE;
-(function (SERDE) {
-    const INVALID_START_CODES = [48, 49, 50, 51, 52, 53, 54, 55, 56, 57];
-    const INVALID_CODES = [
-        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
-        31, 32, 33, 34, 35, 36, 37, 38, 39, 42, 43, 44, 47, 58, 59, 60, 61, 62, 63, 64, 91, 92, 93, 94, 96, 123, 124, 125,
-        126, 127
-    ];
-    const sequence_regex = /\?[0-9a-zA-Z.\-]{2}|[^?]+/g;
-    const encoded_regex = /^\?[0-9a-zA-Z.\-]{2}$/;
-    const BASE64 = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ.-';
-    function* b64_encode(char) {
-        let encoded = '';
-        for (let code = char.charCodeAt(0); code > 0; code = Math.floor(code / 64)) {
-            encoded = BASE64[code % 64] + encoded;
-            yield;
-        }
-        return encoded;
-    }
-    function* b64_decode(enc) {
-        let code = 0;
-        for (let i = 0; i < enc.length; i++) {
-            code += 64 ** (enc.length - 1 - i) * BASE64.indexOf(enc[i]);
-            yield;
-        }
-        return String.fromCharCode(code);
-    }
-    function* encode(str) {
-        let result = '';
-        for (let i = 0; i < str.length; i++) {
-            const char = str.charAt(i);
-            const char_code = char.charCodeAt(0);
-            if ((i === 0 && INVALID_START_CODES.includes(char_code)) || INVALID_CODES.includes(char_code)) {
-                result += `?${(yield* b64_encode(char)).padStart(2, '0')}`;
-            }
-            else {
-                result += char;
-            }
-            yield;
-        }
-        return result;
-    }
-    SERDE.encode = encode;
-    function* decode(str) {
-        let result = '';
-        const seqs = str.match(sequence_regex) ?? [];
-        for (let i = 0; i < seqs.length; i++) {
-            const seq = seqs[i];
-            if (seq.startsWith('?') && encoded_regex.test(seq))
-                result += yield* b64_decode(seq.slice(1));
-            else {
-                result += seq;
-            }
-            yield;
-        }
-        return result;
-    }
-    SERDE.decode = decode;
-})(SERDE || (SERDE = {}));
-var CRYPTO;
-(function (CRYPTO) {
-    CRYPTO.PRIME = 19893121;
-    CRYPTO.MOD = 341;
-    const to_HEX = (n) => n.toString(16).toUpperCase();
-    const to_NUM = (h) => parseInt(h, 16);
-    function* mod_exp(base, exp, mod) {
-        let result = 1;
-        let b = base % mod;
-        for (let e = exp; e > 0; e = Math.floor(e / 2)) {
-            if (e % 2 === 1) {
-                result = (result * b) % mod;
-            }
-            b = (b * b) % mod;
-            yield;
-        }
-        return result;
-    }
-    function make_secret(mod = CRYPTO.MOD) {
-        return Math.floor(Math.random() * (mod - 1)) + 1;
-    }
-    CRYPTO.make_secret = make_secret;
-    function* make_public(secret, mod = CRYPTO.MOD, prime = CRYPTO.PRIME) {
-        return to_HEX(yield* mod_exp(mod, secret, prime));
-    }
-    CRYPTO.make_public = make_public;
-    function* make_shared(secret, other, prime = CRYPTO.PRIME) {
-        return to_HEX(yield* mod_exp(to_NUM(other), secret, prime));
-    }
-    CRYPTO.make_shared = make_shared;
-    function* encrypt(raw, key) {
-        let encrypted = '';
-        for (let i = 0; i < raw.length; i++) {
-            encrypted += String.fromCharCode(raw.charCodeAt(i) ^ key.charCodeAt(i % key.length));
-            yield;
-        }
-        return encrypted;
-    }
-    CRYPTO.encrypt = encrypt;
-    function* decrypt(encrypted, key) {
-        let decrypted = '';
-        for (let i = 0; i < encrypted.length; i++) {
-            decrypted += String.fromCharCode(encrypted.charCodeAt(i) ^ key.charCodeAt(i % key.length));
-            yield;
-        }
-        return decrypted;
-    }
-    CRYPTO.decrypt = decrypt;
-})(CRYPTO || (CRYPTO = {}));
-export var NET;
-(function (NET) {
-    const FRAG_MAX = 2048;
-    const namespace_listeners = new Map();
-    system.afterEvents.scriptEventReceive.subscribe(event => {
-        system.runJob((function* () {
-            const ids = event.id.split(':');
-            const namespace = yield* SERDE.decode(ids[0]);
-            const listeners = namespace_listeners.get(namespace);
-            if (event.sourceType === ScriptEventSource.Server && listeners) {
-                const payload = Payload.fromString(yield* SERDE.decode(ids[1]));
-                for (let i = 0; i < listeners.length; i++) {
-                    yield* listeners[i](payload, event.message);
-                }
-            }
-        })());
-    });
-    function create_listener(namespace, listener) {
-        let listeners = namespace_listeners.get(namespace);
-        if (!listeners) {
-            listeners = new Array();
-            namespace_listeners.set(namespace, listeners);
-        }
-        listeners.push(listener);
-        return () => {
-            const idx = listeners.indexOf(listener);
-            if (idx !== -1)
-                listeners.splice(idx, 1);
-            if (listeners.length === 0) {
-                namespace_listeners.delete(namespace);
-            }
-        };
-    }
-    let Payload;
-    (function (Payload) {
-        function toString(p) {
-            return JSON.stringify(p);
-        }
-        Payload.toString = toString;
-        function fromString(s) {
-            return JSON.parse(s);
-        }
-        Payload.fromString = fromString;
-    })(Payload || (Payload = {}));
-    function generate_id() {
-        const r = (Math.random() * 0x100000000) >>> 0;
-        return ((r & 0xff).toString(16).padStart(2, '0') +
-            ((r >> 8) & 0xff).toString(16).padStart(2, '0') +
-            ((r >> 16) & 0xff).toString(16).padStart(2, '0') +
-            ((r >> 24) & 0xff).toString(16).padStart(2, '0')).toUpperCase();
-    }
-    function* emit(namespace, channel, args) {
-        const id = generate_id();
-        const enc_namespace = yield* SERDE.encode(namespace);
-        const enc_args_str = yield* SERDE.encode(JSON.stringify(args));
-        const RUN = function* (payload, data_str) {
-            const enc_payload = yield* SERDE.encode(Payload.toString(payload));
-            world.getDimension('overworld').runCommand(`scriptevent ${enc_namespace}:${enc_payload} ${data_str}`);
-        };
-        let len = 0;
-        let str = '';
-        let str_size = 0;
-        for (let i = 0; i < enc_args_str.length; i++) {
-            const char = enc_args_str[i];
-            const code = char.charCodeAt(0);
-            const char_size = code <= 0x7f ? 1 : code <= 0x7ff ? 2 : code <= 0xffff ? 3 : 4;
-            if (str_size + char_size < FRAG_MAX) {
-                str += char;
-                str_size += char_size;
-            }
-            else {
-                yield* RUN([channel, id, len], str);
-                len++;
-                str = char;
-                str_size = char_size;
-            }
-            yield;
-        }
-        yield* RUN(len === 0 ? [channel, id] : [channel, id, len, 1], str);
-    }
-    NET.emit = emit;
-    function listen(namespace, channel, callback) {
-        const buffer = new Map();
-        const listener = function* ([p_channel, p_id, p_index, p_final], data) {
-            if (p_channel === channel) {
-                if (p_index === undefined) {
-                    yield* callback(JSON.parse(yield* SERDE.decode(data)));
-                }
-                else {
-                    let fragment = buffer.get(p_id);
-                    if (!fragment) {
-                        fragment = { size: -1, data_strs: [], data_size: 0 };
-                        buffer.set(p_id, fragment);
-                    }
-                    if (p_final === 1)
-                        fragment.size = p_index + 1;
-                    fragment.data_strs[p_index] = data;
-                    fragment.data_size += p_index + 1;
-                    if (fragment.size !== -1 && fragment.data_size === (fragment.size * (fragment.size + 1)) / 2) {
-                        let full_str = '';
-                        for (let i = 0; i < fragment.data_strs.length; i++) {
-                            full_str += fragment.data_strs[i];
-                            yield;
-                        }
-                        yield* callback(JSON.parse(yield* SERDE.decode(full_str)));
-                        buffer.delete(p_id);
-                    }
-                }
-            }
-        };
-        return create_listener(namespace, listener);
-    }
-    NET.listen = listen;
-})(NET || (NET = {}));