mcbe-ipc 3.0.0 → 3.0.2

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024 OmniacDev
+Copyright (c) 2025 OmniacDev
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/dist/direct.ipc.d.ts

@@ -0,0 +1,61 @@
+/**
+ * @license
+ * MIT License
+ *
+ * Copyright (c) 2025 OmniacDev
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+import { PROTO } from './ipc';
+export declare namespace DirectIPC {
+    class Connection {
+        private readonly _from;
+        private readonly _to;
+        private readonly _enc;
+        private readonly _terminators;
+        private MAYBE_ENCRYPT;
+        private MAYBE_DECRYPT;
+        get from(): string;
+        get to(): string;
+        constructor(from: string, to: string, encryption: string | false);
+        terminate(notify?: boolean): void;
+        send<S extends PROTO.Serializable<T>, T>(channel: string, serializer: S & PROTO.Serializable<T>, value: T): void;
+        invoke<TS extends PROTO.Serializable<T>, T, RS extends PROTO.Serializable<R>, R>(channel: string, serializer: TS & PROTO.Serializable<T>, value: T, deserializer: RS & PROTO.Serializable<R>): Promise<R>;
+        on<S extends PROTO.Serializable<T>, T>(channel: string, deserializer: S & PROTO.Serializable<T>, listener: (value: T) => void): () => void;
+        once<S extends PROTO.Serializable<T>, T>(channel: string, deserializer: S & PROTO.Serializable<T>, listener: (value: T) => void): () => void;
+        handle<TS extends PROTO.Serializable<T>, T, RS extends PROTO.Serializable<R>, R>(channel: string, deserializer: TS & PROTO.Serializable<T>, serializer: RS & PROTO.Serializable<R>, listener: (value: T) => R): () => void;
+    }
+    class ConnectionManager {
+        private readonly _id;
+        private readonly _enc_map;
+        private readonly _con_map;
+        private readonly _enc_force;
+        private MAYBE_ENCRYPT;
+        private MAYBE_DECRYPT;
+        get id(): string;
+        constructor(id: string, force_encryption?: boolean);
+        connect(to: string, encrypted?: boolean, timeout?: number): Promise<Connection>;
+        send<S extends PROTO.Serializable<T>, T>(channel: string, serializer: S & PROTO.Serializable<T>, value: T): void;
+        invoke<TS extends PROTO.Serializable<T>, T, RS extends PROTO.Serializable<R>, R>(channel: string, serializer: TS & PROTO.Serializable<T>, value: T, deserializer: RS & PROTO.Serializable<R>): Promise<R>[];
+        on<S extends PROTO.Serializable<T>, T>(channel: string, deserializer: S & PROTO.Serializable<T>, listener: (value: T) => void): () => void;
+        once<S extends PROTO.Serializable<T>, T>(channel: string, deserializer: S & PROTO.Serializable<T>, listener: (value: T) => void): () => void;
+        handle<TS extends PROTO.Serializable<T>, T, RS extends PROTO.Serializable<R>, R>(channel: string, deserializer: TS & PROTO.Serializable<T>, serializer: RS & PROTO.Serializable<R>, listener: (value: T) => R): () => void;
+    }
+}
+export default DirectIPC;

package/dist/direct.ipc.js

@@ -0,0 +1,369 @@
+/**
+ * @license
+ * MIT License
+ *
+ * Copyright (c) 2025 OmniacDev
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+import { system } from '@minecraft/server';
+import { NET, PROTO } from './ipc';
+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 var DirectIPC;
+(function (DirectIPC) {
+    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.UVarInt32,
+        encryption_modulus: PROTO.UVarInt32
+    });
+    const HandshakeAcknowledgeSerializer = PROTO.Object({
+        from: PROTO.String,
+        encryption_enabled: PROTO.Boolean,
+        encryption_public_key: PROTO.String
+    });
+    class Connection {
+        *MAYBE_ENCRYPT(bytes) {
+            return this._enc !== false ? yield* CRYPTO.encrypt(bytes, this._enc) : bytes;
+        }
+        *MAYBE_DECRYPT(bytes) {
+            return this._enc !== false ? yield* CRYPTO.decrypt(bytes, this._enc) : bytes;
+        }
+        get from() {
+            return this._from;
+        }
+        get to() {
+            return this._to;
+        }
+        constructor(from, to, encryption) {
+            this._from = from;
+            this._to = to;
+            this._enc = encryption;
+            this._terminators = new Array();
+        }
+        terminate(notify = true) {
+            const $ = this;
+            $._terminators.forEach(terminate => terminate());
+            $._terminators.length = 0;
+            if (notify) {
+                system.runJob(NET.emit(`ipc:${$._to}:terminate`, PROTO.String, $._from));
+            }
+        }
+        send(channel, serializer, value) {
+            const $ = this;
+            system.runJob((function* () {
+                const stream = new PROTO.ByteQueue();
+                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, serializer, value, deserializer) {
+            const $ = this;
+            system.runJob((function* () {
+                const stream = new PROTO.ByteQueue();
+                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`, ConnectionSerializer, function* (data) {
+                    if (data.from === $._to) {
+                        const bytes = yield* $.MAYBE_DECRYPT(data.bytes);
+                        const stream = PROTO.ByteQueue.from_uint8array(bytes);
+                        const value = yield* deserializer.deserialize(stream);
+                        resolve(value);
+                        terminate();
+                    }
+                });
+            });
+        }
+        on(channel, deserializer, listener) {
+            const $ = this;
+            const terminate = NET.listen(`ipc:${$._from}:${channel}:send`, ConnectionSerializer, function* (data) {
+                if (data.from === $._to) {
+                    const bytes = yield* $.MAYBE_DECRYPT(data.bytes);
+                    const stream = PROTO.ByteQueue.from_uint8array(bytes);
+                    const value = yield* deserializer.deserialize(stream);
+                    listener(value);
+                }
+            });
+            $._terminators.push(terminate);
+            return terminate;
+        }
+        once(channel, deserializer, listener) {
+            const $ = this;
+            const terminate = NET.listen(`ipc:${$._from}:${channel}:send`, ConnectionSerializer, function* (data) {
+                if (data.from === $._to) {
+                    const bytes = yield* $.MAYBE_DECRYPT(data.bytes);
+                    const stream = PROTO.ByteQueue.from_uint8array(bytes);
+                    const value = yield* deserializer.deserialize(stream);
+                    listener(value);
+                    terminate();
+                }
+            });
+            $._terminators.push(terminate);
+            return terminate;
+        }
+        handle(channel, deserializer, serializer, listener) {
+            const $ = this;
+            const terminate = NET.listen(`ipc:${$._from}:${channel}:invoke`, ConnectionSerializer, function* (data) {
+                if (data.from === $._to) {
+                    const bytes = yield* $.MAYBE_DECRYPT(data.bytes);
+                    const stream = PROTO.ByteQueue.from_uint8array(bytes);
+                    const value = yield* deserializer.deserialize(stream);
+                    const result = listener(value);
+                    const return_stream = new PROTO.ByteQueue();
+                    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);
+            return terminate;
+        }
+    }
+    DirectIPC.Connection = Connection;
+    class ConnectionManager {
+        *MAYBE_ENCRYPT(bytes, encryption) {
+            return encryption !== false ? yield* CRYPTO.encrypt(bytes, encryption) : bytes;
+        }
+        *MAYBE_DECRYPT(bytes, encryption) {
+            return encryption !== false ? yield* CRYPTO.decrypt(bytes, encryption) : bytes;
+        }
+        get id() {
+            return this._id;
+        }
+        constructor(id, force_encryption = false) {
+            const $ = this;
+            this._id = id;
+            this._enc_map = new Map();
+            this._con_map = new Map();
+            this._enc_force = force_encryption;
+            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`, PROTO.String, function* (value) {
+                $._enc_map.delete(value);
+            });
+        }
+        connect(to, encrypted = false, timeout = 20) {
+            const $ = this;
+            return new Promise((resolve, reject) => {
+                const con = this._con_map.get(to);
+                if (con !== undefined) {
+                    con.terminate(false);
+                    resolve(con);
+                }
+                else {
+                    const secret = CRYPTO.make_secret();
+                    system.runJob((function* () {
+                        const public_key = yield* CRYPTO.make_public(secret);
+                        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();
+                        system.clearRun(timeout_handle);
+                    }
+                    const timeout_handle = system.runTimeout(() => {
+                        reject();
+                        clear();
+                    }, timeout);
+                    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);
+                            clear();
+                        }
+                    });
+                }
+            });
+        }
+        send(channel, serializer, value) {
+            const $ = this;
+            system.runJob((function* () {
+                for (const [key, enc] of $._enc_map) {
+                    const stream = new PROTO.ByteQueue();
+                    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, serializer, value, deserializer) {
+            const $ = this;
+            const promises = [];
+            for (const [key, enc] of $._enc_map) {
+                system.runJob((function* () {
+                    const stream = new PROTO.ByteQueue();
+                    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`, ConnectionSerializer, function* (data) {
+                        if (data.from === key) {
+                            const bytes = yield* $.MAYBE_DECRYPT(data.bytes, enc);
+                            const stream = PROTO.ByteQueue.from_uint8array(bytes);
+                            const value = yield* deserializer.deserialize(stream);
+                            resolve(value);
+                            terminate();
+                        }
+                    });
+                }));
+            }
+            return promises;
+        }
+        on(channel, deserializer, listener) {
+            const $ = this;
+            return NET.listen(`ipc:${$._id}:${channel}:send`, ConnectionSerializer, function* (data) {
+                const enc = $._enc_map.get(data.from);
+                if (enc !== undefined) {
+                    const bytes = yield* $.MAYBE_DECRYPT(data.bytes, enc);
+                    const stream = PROTO.ByteQueue.from_uint8array(bytes);
+                    const value = yield* deserializer.deserialize(stream);
+                    listener(value);
+                }
+            });
+        }
+        once(channel, deserializer, listener) {
+            const $ = this;
+            const terminate = NET.listen(`ipc:${$._id}:${channel}:send`, ConnectionSerializer, function* (data) {
+                const enc = $._enc_map.get(data.from);
+                if (enc !== undefined) {
+                    const bytes = yield* $.MAYBE_DECRYPT(data.bytes, enc);
+                    const stream = PROTO.ByteQueue.from_uint8array(bytes);
+                    const value = yield* deserializer.deserialize(stream);
+                    listener(value);
+                    terminate();
+                }
+            });
+            return terminate;
+        }
+        handle(channel, deserializer, serializer, listener) {
+            const $ = this;
+            return NET.listen(`ipc:${$._id}:${channel}:invoke`, ConnectionSerializer, function* (data) {
+                const enc = $._enc_map.get(data.from);
+                if (enc !== undefined) {
+                    const input_bytes = yield* $.MAYBE_DECRYPT(data.bytes, enc);
+                    const input_stream = PROTO.ByteQueue.from_uint8array(input_bytes);
+                    const input_value = yield* deserializer.deserialize(input_stream);
+                    const result = listener(input_value);
+                    const output_stream = new PROTO.ByteQueue();
+                    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
+                    });
+                }
+            });
+        }
+    }
+    DirectIPC.ConnectionManager = ConnectionManager;
+})(DirectIPC || (DirectIPC = {}));
+export default DirectIPC;

package/dist/ipc.d.ts

@@ -2,7 +2,7 @@
  * @license
  * MIT License
  *
- * Copyright (c) 2024 OmniacDev
+ * Copyright (c) 2025 OmniacDev
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -22,116 +22,82 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  */
-export declare namespace SERDE {
-    class ByteArray {
+export declare namespace PROTO {
+    interface Serializable<T> {
+        serialize(value: T, stream: ByteQueue): Generator<void, void, void>;
+        deserialize(stream: ByteQueue): Generator<void, T, void>;
+    }
+    class ByteQueue {
         private _buffer;
         private _data_view;
         private _length;
         private _offset;
-        private get _end();
+        get end(): number;
+        get front(): number;
+        get data_view(): DataView;
         constructor(size?: number);
         write(...values: number[]): void;
         read(amount?: number): number[];
-        write_uint8(value: number): void;
-        read_uint8(): number | undefined;
-        write_uint16(value: number): void;
-        read_uint16(): number | undefined;
-        write_uint32(value: number): void;
-        read_uint32(): number | undefined;
-        write_int8(value: number): void;
-        read_int8(): number | undefined;
-        write_int16(value: number): void;
-        read_int16(): number | undefined;
-        write_int32(value: number): void;
-        read_int32(): number | undefined;
-        write_f32(value: number): void;
-        read_f32(): number | undefined;
-        write_f64(value: number): void;
-        read_f64(): number | undefined;
-        private _ensure_capacity;
-        static from_uint8array(array: Uint8Array): ByteArray;
+        ensure_capacity(size: number): void;
+        static from_uint8array(array: Uint8Array): ByteQueue;
         to_uint8array(): Uint8Array;
     }
-    function serialize(byte_array: ByteArray, max_size?: number): Generator<void, string[], void>;
-    function deserialize(strings: string[]): Generator<void, ByteArray, void>;
-}
-export declare class Proto {
-    static Int8: NET.Serializable<number>;
-    static Int16: NET.Serializable<number>;
-    static Int32: NET.Serializable<number>;
-    static UInt8: NET.Serializable<number>;
-    static UInt16: NET.Serializable<number>;
-    static UInt32: NET.Serializable<number>;
-    static Float32: NET.Serializable<number>;
-    static Float64: NET.Serializable<number>;
-    static VarInt: NET.Serializable<number>;
-    static String: NET.Serializable<string>;
-    static Boolean: NET.Serializable<boolean>;
-    static UInt8Array: NET.Serializable<Uint8Array>;
-    static Date: NET.Serializable<Date>;
-    static Object<T extends object>(obj: {
-        [K in keyof T]: NET.Serializable<T[K]>;
-    }): NET.Serializable<T>;
-    static Array<T>(items: NET.Serializable<T>): NET.Serializable<T[]>;
-    static Tuple<T extends any[]>(...items: {
-        [K in keyof T]: NET.Serializable<T[K]>;
-    }): NET.Serializable<T>;
-    static Optional<T>(item: NET.Serializable<T>): NET.Serializable<T | undefined>;
-    static Map<K, V>(key: NET.Serializable<K>, value: NET.Serializable<V>): NET.Serializable<Map<K, V>>;
-    static Set<V>(value: NET.Serializable<V>): NET.Serializable<Set<V>>;
+    namespace MIPS {
+        function serialize(byte_queue: PROTO.ByteQueue): Generator<void, string, void>;
+        function deserialize(str: string): Generator<void, PROTO.ByteQueue, void>;
+    }
+    const Void: PROTO.Serializable<void>;
+    const Null: PROTO.Serializable<null>;
+    const Undefined: PROTO.Serializable<undefined>;
+    const Int8: PROTO.Serializable<number>;
+    const Int16: PROTO.Serializable<number>;
+    const Int32: PROTO.Serializable<number>;
+    const UInt8: PROTO.Serializable<number>;
+    const UInt16: PROTO.Serializable<number>;
+    const UInt32: PROTO.Serializable<number>;
+    const UVarInt32: PROTO.Serializable<number>;
+    const Float32: PROTO.Serializable<number>;
+    const Float64: PROTO.Serializable<number>;
+    const String: PROTO.Serializable<string>;
+    const Boolean: PROTO.Serializable<boolean>;
+    const UInt8Array: PROTO.Serializable<Uint8Array>;
+    const Date: PROTO.Serializable<Date>;
+    function Object<T extends object>(obj: {
+        [K in keyof T]: PROTO.Serializable<T[K]>;
+    }): PROTO.Serializable<T>;
+    function Array<T>(value: PROTO.Serializable<T>): PROTO.Serializable<T[]>;
+    function Tuple<T extends any[]>(...values: {
+        [K in keyof T]: PROTO.Serializable<T[K]>;
+    }): PROTO.Serializable<T>;
+    function Optional<T>(value: PROTO.Serializable<T>): PROTO.Serializable<T | undefined>;
+    function Map<K, V>(key: PROTO.Serializable<K>, value: PROTO.Serializable<V>): PROTO.Serializable<Map<K, V>>;
+    function Set<V>(value: PROTO.Serializable<V>): PROTO.Serializable<Set<V>>;
+    type Endpoint = string;
+    type Header = {
+        guid: string;
+        encoding: string;
+        index: number;
+        final: boolean;
+    };
+    const Endpoint: PROTO.Serializable<Endpoint>;
+    const Header: PROTO.Serializable<Header>;
 }
 export declare namespace NET {
-    interface Serializable<T = any> {
-        serialize(value: T, stream: ByteArray): Generator<void, void, void>;
-        deserialize(stream: ByteArray): Generator<void, T, void>;
-    }
-    import ByteArray = SERDE.ByteArray;
-    function emit<T>(endpoint: string, serializer: Serializable<T>, value: T): Generator<void, void, void>;
-    function listen<T>(endpoint: string, serializer: Serializable<T>, callback: (value: T) => Generator<void, void, void>): () => void;
+    function serialize(byte_queue: PROTO.ByteQueue, max_size?: number): Generator<void, string[], void>;
+    function deserialize(strings: string[]): Generator<void, PROTO.ByteQueue, void>;
+    function emit<S extends PROTO.Serializable<T>, T>(endpoint: string, serializer: S & PROTO.Serializable<T>, value: T): Generator<void, void, void>;
+    function listen<T, S extends PROTO.Serializable<T>>(endpoint: string, serializer: S & PROTO.Serializable<T>, callback: (value: T) => Generator<void, void, void>): () => void;
 }
 export declare namespace IPC {
-    class Connection {
-        private readonly _from;
-        private readonly _to;
-        private readonly _enc;
-        private readonly _terminators;
-        private MAYBE_ENCRYPT;
-        private MAYBE_DECRYPT;
-        get from(): string;
-        get to(): string;
-        constructor(from: string, to: string, encryption: string | false);
-        terminate(notify?: boolean): void;
-        send<T>(channel: string, serializer: NET.Serializable<T>, value: T): void;
-        invoke<T, R>(channel: string, serializer: NET.Serializable<T>, value: T, deserializer: NET.Serializable<R>): Promise<R>;
-        on<T>(channel: string, deserializer: NET.Serializable<T>, listener: (value: T) => void): () => void;
-        once<T>(channel: string, deserializer: NET.Serializable<T>, listener: (value: T) => void): () => void;
-        handle<T, R>(channel: string, deserializer: NET.Serializable<T>, serializer: NET.Serializable<R>, listener: (value: T) => R): () => void;
-    }
-    class ConnectionManager {
-        private readonly _id;
-        private readonly _enc_map;
-        private readonly _con_map;
-        private readonly _enc_force;
-        private MAYBE_ENCRYPT;
-        private MAYBE_DECRYPT;
-        get id(): string;
-        constructor(id: string, force_encryption?: boolean);
-        connect(to: string, encrypted?: boolean, timeout?: number): Promise<Connection>;
-        send<T>(channel: string, serializer: NET.Serializable<T>, value: T): void;
-        invoke<T, R>(channel: string, serializer: NET.Serializable<T>, value: T, deserializer: NET.Serializable<R>): Promise<R>[];
-        on<T>(channel: string, deserializer: NET.Serializable<T>, listener: (value: T) => void): () => void;
-        once<T>(channel: string, deserializer: NET.Serializable<T>, listener: (value: T) => void): () => void;
-        handle<T, R>(channel: string, deserializer: NET.Serializable<T>, serializer: NET.Serializable<R>, listener: (value: T) => R): () => void;
-    }
     /** Sends a message with `args` to `channel` */
-    function send<T>(channel: string, serializer: NET.Serializable<T>, value: T): void;
+    function send<S extends PROTO.Serializable<T>, T>(channel: string, serializer: S & PROTO.Serializable<T>, value: T): void;
     /** Sends an `invoke` message through IPC, and expects a result asynchronously. */
-    function invoke<T, R>(channel: string, serializer: NET.Serializable<T>, value: T, deserializer: NET.Serializable<R>): Promise<R>;
+    function invoke<TS extends PROTO.Serializable<T>, T, RS extends PROTO.Serializable<R>, R>(channel: string, serializer: TS & PROTO.Serializable<T>, value: T, deserializer: RS & PROTO.Serializable<R>): Promise<R>;
     /** Listens to `channel`. When a new message arrives, `listener` will be called with `listener(args)`. */
-    function on<T>(channel: string, deserializer: NET.Serializable<T>, listener: (value: T) => void): () => void;
+    function on<S extends PROTO.Serializable<T>, T>(channel: string, deserializer: S & PROTO.Serializable<T>, listener: (value: T) => void): () => void;
     /** Listens to `channel` once. When a new message arrives, `listener` will be called with `listener(args)`, and then removed. */
-    function once<T>(channel: string, deserializer: NET.Serializable<T>, listener: (value: T) => void): () => void;
+    function once<S extends PROTO.Serializable<T>, T>(channel: string, deserializer: S & PROTO.Serializable<T>, listener: (value: T) => void): () => void;
     /** Adds a handler for an `invoke` IPC. This handler will be called whenever `invoke(channel, ...args)` is called */
-    function handle<T, R>(channel: string, deserializer: NET.Serializable<T>, serializer: NET.Serializable<R>, listener: (value: T) => R): () => void;
+    function handle<TS extends PROTO.Serializable<T>, T, RS extends PROTO.Serializable<R>, R>(channel: string, deserializer: TS & PROTO.Serializable<T>, serializer: RS & PROTO.Serializable<R>, listener: (value: T) => R): () => void;
 }
 export default IPC;