mcbe-ipc 3.0.4 → 3.1.3

package/README.md

@@ -1,20 +1,26 @@
 # MCBE-IPC 📡
 
-An IPC[^1] system for MCBE Script API projects
+An IPC[^1] system for Minecraft Bedrock Edition Script API projects
 
-[^1]: Inter-Pack Communication
+## 🔗 Dependencies
 
-## Dependencies
+| Package              | Version |
+|----------------------|---------|
+| `@minecraft/server`  | 1.18.0  |
 
-| Name | Version |
-|---|---|
-| `@minecraft/server` | Any |
+## 🚀 Installation
 
-## Installation
-**JavaScript**
-1. Download `ipc.js` and `ipc.d.ts` from the latest [release](https://github.com/OmniacDev/MCBE-IPC/releases/latest)
-2. Copy the files into your project
+### 📦 NPM
+```bash
+npm install mcbe-ipc
+```
 
-**TypeScript**
-1. Download `ipc.ts` from the latest [release](https://github.com/OmniacDev/MCBE-IPC/releases/latest)
-2. Copy file into your project
+### 🛠 Manual
+1. Download the applicable file(s) for your language from the latest [release](https://github.com/OmniacDev/MCBE-IPC/releases/latest):
+    - For **JavaScript**: `ipc.js` and `ipc.d.ts`
+    - For **TypeScript**: `ipc.ts`
+2. Add the downloaded file(s) to your project directory.
+
+
+
+[^1]: Inter-Pack Communication

package/dist/ipc.d.ts

@@ -24,10 +24,10 @@
  */
 export declare namespace PROTO {
     interface Serializable<T> {
-        serialize(value: T, stream: ByteQueue): Generator<void, void, void>;
-        deserialize(stream: ByteQueue): Generator<void, T, void>;
+        serialize(value: T, stream: Buffer): Generator<void, void, void>;
+        deserialize(stream: Buffer): Generator<void, T, void>;
     }
-    class ByteQueue {
+    class Buffer {
         private _buffer;
         private _data_view;
         private _length;
@@ -39,12 +39,12 @@ export declare namespace PROTO {
         write(...values: number[]): void;
         read(amount?: number): number[];
         ensure_capacity(size: number): void;
-        static from_uint8array(array: Uint8Array): ByteQueue;
+        static from_uint8array(array: Uint8Array): Buffer;
         to_uint8array(): Uint8Array;
     }
     namespace MIPS {
-        function serialize(byte_queue: PROTO.ByteQueue): Generator<void, string, void>;
-        function deserialize(str: string): Generator<void, PROTO.ByteQueue, void>;
+        function serialize(stream: PROTO.Buffer): Generator<void, string, void>;
+        function deserialize(str: string): Generator<void, PROTO.Buffer, void>;
     }
     const Void: PROTO.Serializable<void>;
     const Null: PROTO.Serializable<null>;
@@ -83,8 +83,9 @@ export declare namespace PROTO {
     const Header: PROTO.Serializable<Header>;
 }
 export declare namespace NET {
-    function serialize(byte_queue: PROTO.ByteQueue, max_size?: number): Generator<void, string[], void>;
-    function deserialize(strings: string[]): Generator<void, PROTO.ByteQueue, void>;
+    let FRAG_MAX: number;
+    function serialize(buffer: PROTO.Buffer, max_size?: number): Generator<void, string[], void>;
+    function deserialize(strings: string[]): Generator<void, PROTO.Buffer, 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;
 }

package/dist/ipc.js

@@ -22,10 +22,10 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  */
-import { ScriptEventSource, system, world } from '@minecraft/server';
+import { ScriptEventSource, system } from '@minecraft/server';
 export var PROTO;
 (function (PROTO) {
-    class ByteQueue {
+    class Buffer {
         get end() {
             return this._length + this._offset;
         }
@@ -66,22 +66,22 @@ export var PROTO;
             }
         }
         static from_uint8array(array) {
-            const byte_queue = new ByteQueue();
-            byte_queue._buffer = array;
-            byte_queue._length = array.length;
-            byte_queue._offset = 0;
-            byte_queue._data_view = new DataView(array.buffer);
-            return byte_queue;
+            const buffer = new Buffer();
+            buffer._buffer = array;
+            buffer._length = array.length;
+            buffer._offset = 0;
+            buffer._data_view = new DataView(array.buffer);
+            return buffer;
         }
         to_uint8array() {
             return this._buffer.subarray(this._offset, this.end);
         }
     }
-    PROTO.ByteQueue = ByteQueue;
+    PROTO.Buffer = Buffer;
     let MIPS;
     (function (MIPS) {
-        function* serialize(byte_queue) {
-            const uint8array = byte_queue.to_uint8array();
+        function* serialize(stream) {
+            const uint8array = stream.to_uint8array();
             let str = '(0x';
             for (let i = 0; i < uint8array.length; i++) {
                 const hex = uint8array[i].toString(16).padStart(2, '0').toUpperCase();
@@ -94,16 +94,16 @@ export var PROTO;
         MIPS.serialize = serialize;
         function* deserialize(str) {
             if (str.startsWith('(0x') && str.endsWith(')')) {
-                const result = [];
+                const buffer = new Buffer();
                 const hex_str = str.slice(3, str.length - 1);
                 for (let i = 0; i < hex_str.length; i++) {
                     const hex = hex_str[i] + hex_str[++i];
-                    result.push(parseInt(hex, 16));
+                    buffer.write(parseInt(hex, 16));
                     yield;
                 }
-                return ByteQueue.from_uint8array(new Uint8Array(result));
+                return buffer;
             }
-            return new ByteQueue();
+            return new Buffer();
         }
         MIPS.deserialize = deserialize;
     })(MIPS = PROTO.MIPS || (PROTO.MIPS = {}));
@@ -409,11 +409,11 @@ export var PROTO;
 })(PROTO || (PROTO = {}));
 export var NET;
 (function (NET) {
-    const FRAG_MAX = 2048;
+    NET.FRAG_MAX = 2048;
     const ENCODING = 'mcbe-ipc:v3';
     const ENDPOINTS = new Map();
-    function* serialize(byte_queue, max_size = Infinity) {
-        const uint8array = byte_queue.to_uint8array();
+    function* serialize(buffer, max_size = Infinity) {
+        const uint8array = buffer.to_uint8array();
         const result = [];
         let acc_str = '';
         let acc_size = 0;
@@ -441,7 +441,7 @@ export var NET;
     }
     NET.serialize = serialize;
     function* deserialize(strings) {
-        const result = [];
+        const buffer = new PROTO.Buffer();
         for (let i = 0; i < strings.length; i++) {
             const str = strings[i];
             for (let j = 0; j < str.length; j++) {
@@ -449,18 +449,18 @@ export var NET;
                 if (char_code <= 0xff) {
                     const hex = str[j] + str[++j];
                     const hex_code = parseInt(hex, 16);
-                    result.push(hex_code & 0xff);
-                    result.push(hex_code >> 8);
+                    buffer.write(hex_code & 0xff);
+                    buffer.write(hex_code >> 8);
                 }
                 else {
-                    result.push(char_code & 0xff);
-                    result.push(char_code >> 8);
+                    buffer.write(char_code & 0xff);
+                    buffer.write(char_code >> 8);
                 }
                 yield;
             }
             yield;
         }
-        return PROTO.ByteQueue.from_uint8array(new Uint8Array(result));
+        return buffer;
     }
     NET.deserialize = deserialize;
     system.afterEvents.scriptEventReceive.subscribe(event => {
@@ -503,23 +503,19 @@ export var NET;
     }
     function* emit(endpoint, serializer, value) {
         const guid = generate_id();
-        const endpoint_stream = new PROTO.ByteQueue();
+        const endpoint_stream = new PROTO.Buffer();
         yield* PROTO.Endpoint.serialize(endpoint, endpoint_stream);
         const serialized_endpoint = yield* PROTO.MIPS.serialize(endpoint_stream);
-        const RUN = function* (header, serialized_packet) {
-            const header_stream = new PROTO.ByteQueue();
-            yield* PROTO.Header.serialize(header, header_stream);
-            const serialized_header = yield* PROTO.MIPS.serialize(header_stream);
-            world
-                .getDimension('overworld')
-                .runCommand(`scriptevent ${serialized_endpoint}:${serialized_header} ${serialized_packet}`);
-        };
-        const packet_stream = new PROTO.ByteQueue();
+        const packet_stream = new PROTO.Buffer();
         yield* serializer.serialize(value, packet_stream);
-        const serialized_packets = yield* serialize(packet_stream, FRAG_MAX);
+        const serialized_packets = yield* serialize(packet_stream, NET.FRAG_MAX);
         for (let i = 0; i < serialized_packets.length; i++) {
             const serialized_packet = serialized_packets[i];
-            yield* RUN({ guid, encoding: ENCODING, index: i, final: i === serialized_packets.length - 1 }, serialized_packet);
+            const header = { guid, encoding: ENCODING, index: i, final: i === serialized_packets.length - 1 };
+            const header_stream = new PROTO.Buffer();
+            yield* PROTO.Header.serialize(header, header_stream);
+            const serialized_header = yield* PROTO.MIPS.serialize(header_stream);
+            system.sendScriptEvent(`${serialized_endpoint}:${serialized_header}`, serialized_packet);
         }
     }
     NET.emit = emit;

package/package.json

@@ -3,15 +3,15 @@
   "author": "OmniacDev",
   "description": "IPC system for MCBE Script API projects",
   "license": "MIT",
-  "version": "3.0.4",
+  "version": "3.1.3",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/OmniacDev/mcbe-ipc.git"
+    "url": "git+https://github.com/OmniacDev/MCBE-IPC.git"
   },
   "bugs": {
-    "url": "https://github.com/OmniacDev/mcbe-ipc/issues"
+    "url": "https://github.com/OmniacDev/MCBE-IPC/issues"
   },
-  "homepage": "https://github.com/OmniacDev/mcbe-ipc",
+  "homepage": "https://github.com/OmniacDev/MCBE-IPC",
   "type": "module",
   "main": "dist/ipc.js",
   "types": "dist/ipc.d.ts",
@@ -28,6 +28,6 @@
     "typescript": "^5.5.4"
   },
   "dependencies": {
-    "@minecraft/server": "^1.13.0"
+    "@minecraft/server": "^1.18.0"
   }
 }

package/dist/direct.ipc.d.ts

@@ -1,61 +0,0 @@
-/**
- * @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, mod?: number, prime?: 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

@@ -1,369 +0,0 @@
-/**
- * @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) {
-        return Math.floor(Math.random() * (mod - 1)) + 1;
-    }
-    CRYPTO.make_secret = make_secret;
-    function* make_public(secret, mod, prime) {
-        return to_HEX(yield* mod_exp(mod, secret, prime));
-    }
-    CRYPTO.make_public = make_public;
-    function* make_shared(secret, other, 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}:manager:${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}:manager:${channel}:invoke`, ConnectionSerializer, {
-                    from: $._from,
-                    bytes
-                });
-            })());
-            return new Promise(resolve => {
-                const terminate = NET.listen(`ipc:${$._from}:connection:${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}:connection:${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}:connection:${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}:connection:${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}:manager:${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, mod = CRYPTO.MOD, prime = CRYPTO.PRIME) {
-            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(mod);
-                    system.runJob((function* () {
-                        const public_key = yield* CRYPTO.make_public(secret, mod, prime);
-                        yield* NET.emit(`ipc:${to}:handshake:synchronize`, HandshakeSynchronizeSerializer, {
-                            from: $._id,
-                            encryption_enabled: encrypted,
-                            encryption_public_key: public_key,
-                            encryption_prime: prime,
-                            encryption_modulus: 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, prime)
-                                : 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}:connection:${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}:connection:${channel}:invoke`, ConnectionSerializer, {
-                        from: $._id,
-                        bytes
-                    });
-                })());
-                promises.push(new Promise(resolve => {
-                    const terminate = NET.listen(`ipc:${$._id}:manager:${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}:manager:${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}:manager:${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}:manager:${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}:connection:${channel}:handle`, ConnectionSerializer, {
-                        from: $._id,
-                        bytes: output_bytes
-                    });
-                }
-            });
-        }
-    }
-    DirectIPC.ConnectionManager = ConnectionManager;
-})(DirectIPC || (DirectIPC = {}));
-export default DirectIPC;

package/dist/proto.d.ts

@@ -1,84 +0,0 @@
-/**
- * @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.
- */
-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;
-        get end(): number;
-        get front(): number;
-        get data_view(): DataView;
-        constructor(size?: number);
-        write(...values: number[]): void;
-        read(amount?: number): number[];
-        ensure_capacity(size: number): void;
-        static from_uint8array(array: Uint8Array): ByteQueue;
-        to_uint8array(): Uint8Array;
-    }
-    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>;
-}

package/dist/proto.js

@@ -1,408 +0,0 @@
-/**
- * @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.
- */
-export var PROTO;
-(function (PROTO) {
-    class ByteQueue {
-        get end() {
-            return this._length + this._offset;
-        }
-        get front() {
-            return this._offset;
-        }
-        get data_view() {
-            return this._data_view;
-        }
-        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(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 globalThis.Array.from(values);
-            }
-            return [];
-        }
-        ensure_capacity(size) {
-            if (this.end + size > this._buffer.length) {
-                const larger_buffer = new Uint8Array((this.end + 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_queue = new ByteQueue();
-            byte_queue._buffer = array;
-            byte_queue._length = array.length;
-            byte_queue._offset = 0;
-            byte_queue._data_view = new DataView(array.buffer);
-            return byte_queue;
-        }
-        to_uint8array() {
-            return this._buffer.subarray(this._offset, this.end);
-        }
-    }
-    PROTO.ByteQueue = ByteQueue;
-    let MIPS;
-    (function (MIPS) {
-        function* serialize(byte_queue) {
-            const uint8array = byte_queue.to_uint8array();
-            let str = '(0x';
-            for (let i = 0; i < uint8array.length; i++) {
-                const hex = uint8array[i].toString(16).padStart(2, '0').toUpperCase();
-                str += hex;
-                yield;
-            }
-            str += ')';
-            return str;
-        }
-        MIPS.serialize = serialize;
-        function* deserialize(str) {
-            if (str.startsWith('(0x') && str.endsWith(')')) {
-                const result = [];
-                const hex_str = str.slice(3, str.length - 1);
-                for (let i = 0; i < hex_str.length; i++) {
-                    const hex = hex_str[i] + hex_str[++i];
-                    result.push(parseInt(hex, 16));
-                    yield;
-                }
-                return ByteQueue.from_uint8array(new Uint8Array(result));
-            }
-            return new ByteQueue();
-        }
-        MIPS.deserialize = deserialize;
-    })(MIPS = PROTO.MIPS || (PROTO.MIPS = {}));
-    PROTO.Void = {
-        *serialize() { },
-        *deserialize() { }
-    };
-    PROTO.Null = {
-        *serialize() { },
-        *deserialize() {
-            return null;
-        }
-    };
-    PROTO.Undefined = {
-        *serialize() { },
-        *deserialize() {
-            return undefined;
-        }
-    };
-    PROTO.Int8 = {
-        *serialize(value, stream) {
-            const length = 1;
-            stream.write(...globalThis.Array(length).fill(0));
-            stream.data_view.setInt8(stream.end - length, value);
-        },
-        *deserialize(stream) {
-            const value = stream.data_view.getInt8(stream.front);
-            stream.read(1);
-            return value;
-        }
-    };
-    PROTO.Int16 = {
-        *serialize(value, stream) {
-            const length = 2;
-            stream.write(...globalThis.Array(length).fill(0));
-            stream.data_view.setInt16(stream.end - length, value);
-        },
-        *deserialize(stream) {
-            const value = stream.data_view.getInt16(stream.front);
-            stream.read(2);
-            return value;
-        }
-    };
-    PROTO.Int32 = {
-        *serialize(value, stream) {
-            const length = 4;
-            stream.write(...globalThis.Array(length).fill(0));
-            stream.data_view.setInt32(stream.end - length, value);
-        },
-        *deserialize(stream) {
-            const value = stream.data_view.getInt32(stream.front);
-            stream.read(4);
-            return value;
-        }
-    };
-    PROTO.UInt8 = {
-        *serialize(value, stream) {
-            const length = 1;
-            stream.write(...globalThis.Array(length).fill(0));
-            stream.data_view.setUint8(stream.end - length, value);
-        },
-        *deserialize(stream) {
-            const value = stream.data_view.getUint8(stream.front);
-            stream.read(1);
-            return value;
-        }
-    };
-    PROTO.UInt16 = {
-        *serialize(value, stream) {
-            const length = 2;
-            stream.write(...globalThis.Array(length).fill(0));
-            stream.data_view.setUint16(stream.end - length, value);
-        },
-        *deserialize(stream) {
-            const value = stream.data_view.getUint16(stream.front);
-            stream.read(2);
-            return value;
-        }
-    };
-    PROTO.UInt32 = {
-        *serialize(value, stream) {
-            const length = 4;
-            stream.write(...globalThis.Array(length).fill(0));
-            stream.data_view.setUint32(stream.end - length, value);
-        },
-        *deserialize(stream) {
-            const value = stream.data_view.getUint32(stream.front);
-            stream.read(4);
-            return value;
-        }
-    };
-    PROTO.UVarInt32 = {
-        *serialize(value, stream) {
-            while (value >= 0x80) {
-                stream.write((value & 0x7f) | 0x80);
-                value >>= 7;
-                yield;
-            }
-            stream.write(value);
-        },
-        *deserialize(stream) {
-            let value = 0;
-            let size = 0;
-            let byte;
-            do {
-                byte = stream.read()[0];
-                value |= (byte & 0x7f) << (size * 7);
-                size += 1;
-                yield;
-            } while ((byte & 0x80) !== 0 && size < 10);
-            return value;
-        }
-    };
-    PROTO.Float32 = {
-        *serialize(value, stream) {
-            const length = 4;
-            stream.write(...globalThis.Array(length).fill(0));
-            stream.data_view.setFloat32(stream.end - length, value);
-        },
-        *deserialize(stream) {
-            const value = stream.data_view.getFloat32(stream.front);
-            stream.read(4);
-            return value;
-        }
-    };
-    PROTO.Float64 = {
-        *serialize(value, stream) {
-            const length = 8;
-            stream.write(...globalThis.Array(length).fill(0));
-            stream.data_view.setFloat64(stream.end - length, value);
-        },
-        *deserialize(stream) {
-            const value = stream.data_view.getFloat64(stream.front);
-            stream.read(8);
-            return value;
-        }
-    };
-    PROTO.String = {
-        *serialize(value, stream) {
-            yield* PROTO.UVarInt32.serialize(value.length, stream);
-            for (let i = 0; i < value.length; i++) {
-                const code = value.charCodeAt(i);
-                yield* PROTO.UVarInt32.serialize(code, stream);
-            }
-        },
-        *deserialize(stream) {
-            const length = yield* PROTO.UVarInt32.deserialize(stream);
-            let value = '';
-            for (let i = 0; i < length; i++) {
-                const code = yield* PROTO.UVarInt32.deserialize(stream);
-                value += globalThis.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.UVarInt32.serialize(value.length, stream);
-            stream.write(...value);
-        },
-        *deserialize(stream) {
-            const length = yield* PROTO.UVarInt32.deserialize(stream);
-            return new Uint8Array(stream.read(length));
-        }
-    };
-    PROTO.Date = {
-        *serialize(value, stream) {
-            yield* PROTO.Float64.serialize(value.getTime(), stream);
-        },
-        *deserialize(stream) {
-            return new globalThis.Date(yield* PROTO.Float64.deserialize(stream));
-        }
-    };
-    function 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;
-            }
-        };
-    }
-    PROTO.Object = Object;
-    function Array(value) {
-        return {
-            *serialize(array, stream) {
-                yield* PROTO.UVarInt32.serialize(array.length, stream);
-                for (const item of array) {
-                    yield* value.serialize(item, stream);
-                }
-            },
-            *deserialize(stream) {
-                const result = [];
-                const length = yield* PROTO.UVarInt32.deserialize(stream);
-                for (let i = 0; i < length; i++) {
-                    result[i] = yield* value.deserialize(stream);
-                }
-                return result;
-            }
-        };
-    }
-    PROTO.Array = Array;
-    function Tuple(...values) {
-        return {
-            *serialize(tuple, stream) {
-                for (let i = 0; i < values.length; i++) {
-                    yield* values[i].serialize(tuple[i], stream);
-                }
-            },
-            *deserialize(stream) {
-                const result = [];
-                for (let i = 0; i < values.length; i++) {
-                    result[i] = yield* values[i].deserialize(stream);
-                }
-                return result;
-            }
-        };
-    }
-    PROTO.Tuple = Tuple;
-    function Optional(value) {
-        return {
-            *serialize(optional, stream) {
-                yield* PROTO.Boolean.serialize(optional !== undefined, stream);
-                if (optional !== undefined) {
-                    yield* value.serialize(optional, stream);
-                }
-            },
-            *deserialize(stream) {
-                const defined = yield* PROTO.Boolean.deserialize(stream);
-                if (defined) {
-                    return yield* value.deserialize(stream);
-                }
-                return undefined;
-            }
-        };
-    }
-    PROTO.Optional = Optional;
-    function Map(key, value) {
-        return {
-            *serialize(map, stream) {
-                yield* PROTO.UVarInt32.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.UVarInt32.deserialize(stream);
-                const result = new globalThis.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;
-            }
-        };
-    }
-    PROTO.Map = Map;
-    function Set(value) {
-        return {
-            *serialize(set, stream) {
-                yield* PROTO.UVarInt32.serialize(set.size, stream);
-                for (const [_, v] of set.entries()) {
-                    yield* value.serialize(v, stream);
-                }
-            },
-            *deserialize(stream) {
-                const size = yield* PROTO.UVarInt32.deserialize(stream);
-                const result = new globalThis.Set();
-                for (let i = 0; i < size; i++) {
-                    const v = yield* value.deserialize(stream);
-                    result.add(v);
-                }
-                return result;
-            }
-        };
-    }
-    PROTO.Set = Set;
-    PROTO.Endpoint = PROTO.String;
-    PROTO.Header = PROTO.Object({
-        guid: PROTO.String,
-        encoding: PROTO.String,
-        index: PROTO.UVarInt32,
-        final: PROTO.Boolean
-    });
-})(PROTO || (PROTO = {}));