mcbe-ipc 3.0.4 → 3.1.4

package/README.md

@@ -2,19 +2,25 @@
 
 An IPC[^1] system for MCBE Script API projects
 
-[^1]: Inter-Pack Communication
+## 🔗 Dependencies
+
+| Package              | Version |
+|----------------------|---------|
+| `@minecraft/server`  | 1.18.0  |
+
+## 🚀 Installation
 
-## Dependencies
+### 📦 NPM
+```bash
+npm install mcbe-ipc
+```
 
-| Name | Version |
-|---|---|
-| `@minecraft/server` | Any |
+### 🛠 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.
 
-## 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
 
-**TypeScript**
-1. Download `ipc.ts` from the latest [release](https://github.com/OmniacDev/MCBE-IPC/releases/latest)
-2. Copy file into your project
+
+[^1]: Inter-Pack Communication

package/dist/ipc.d.ts

@@ -24,10 +24,11 @@
  */
 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 {
+    type Infer<S> = S extends PROTO.Serializable<infer T> ? T : never;
+    class Buffer {
         private _buffer;
         private _data_view;
         private _length;
@@ -36,15 +37,17 @@ export declare namespace PROTO {
         get front(): number;
         get data_view(): DataView;
         constructor(size?: number);
-        write(...values: number[]): void;
-        read(amount?: number): number[];
+        write_byte(byte: number): void;
+        write_bytes(bytes: Uint8Array): void;
+        read_byte(): number;
+        read_bytes(amount: number): Uint8Array;
         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,21 +86,22 @@ 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>;
-    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;
+    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<any>>(endpoint: string, serializer: S, value: PROTO.Infer<S>): Generator<void, void, void>;
+    function listen<S extends PROTO.Serializable<any>>(endpoint: string, serializer: S, callback: (value: PROTO.Infer<S>) => Generator<void, void, void>): () => void;
 }
 export declare namespace IPC {
     /** Sends a message with `args` to `channel` */
-    function send<S extends PROTO.Serializable<T>, T>(channel: string, serializer: S & PROTO.Serializable<T>, value: T): void;
+    function send<S extends PROTO.Serializable<any>>(channel: string, serializer: S, value: PROTO.Infer<S>): void;
     /** Sends an `invoke` message through IPC, and expects a result asynchronously. */
-    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>;
+    function invoke<S extends PROTO.Serializable<any>, D extends PROTO.Serializable<any>>(channel: string, serializer: S, value: PROTO.Infer<S>, deserializer: S): Promise<PROTO.Infer<D>>;
     /** Listens to `channel`. When a new message arrives, `listener` will be called with `listener(args)`. */
-    function on<S extends PROTO.Serializable<T>, T>(channel: string, deserializer: S & PROTO.Serializable<T>, listener: (value: T) => void): () => void;
+    function on<D extends PROTO.Serializable<any>>(channel: string, deserializer: D, listener: (value: PROTO.Infer<D>) => void): () => void;
     /** Listens to `channel` once. When a new message arrives, `listener` will be called with `listener(args)`, and then removed. */
-    function once<S extends PROTO.Serializable<T>, T>(channel: string, deserializer: S & PROTO.Serializable<T>, listener: (value: T) => void): () => void;
+    function once<D extends PROTO.Serializable<any>>(channel: string, deserializer: D, listener: (value: PROTO.Infer<D>) => void): () => void;
     /** Adds a handler for an `invoke` IPC. This handler will be called whenever `invoke(channel, ...args)` is called */
-    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;
+    function handle<D extends PROTO.Serializable<any>, S extends PROTO.Serializable<any>>(channel: string, deserializer: D, serializer: S, listener: (value: PROTO.Infer<D>) => PROTO.Infer<S>): () => void;
 }
 export default IPC;

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;
         }
@@ -41,20 +41,31 @@ export var PROTO;
             this._length = 0;
             this._offset = 0;
         }
-        write(...values) {
-            this.ensure_capacity(values.length);
-            this._buffer.set(values, this.end);
-            this._length += values.length;
+        write_byte(byte) {
+            this.ensure_capacity(1);
+            this._buffer[this.end] = byte;
+            this._length++;
         }
-        read(amount = 1) {
+        write_bytes(bytes) {
+            this.ensure_capacity(bytes.length);
+            this._buffer.set(bytes, this.end);
+            this._length += bytes.length;
+        }
+        read_byte() {
+            const byte = this._buffer[this._offset];
+            this._length--;
+            this._offset++;
+            return byte;
+        }
+        read_bytes(amount) {
             if (this._length > 0) {
                 const max_amount = amount > this._length ? this._length : amount;
-                const values = this._buffer.subarray(this._offset, this._offset + max_amount);
+                const values = this._buffer.slice(this._offset, this._offset + max_amount);
                 this._length -= max_amount;
                 this._offset += max_amount;
-                return globalThis.Array.from(values);
+                return values;
             }
-            return [];
+            return new Uint8Array();
         }
         ensure_capacity(size) {
             if (this.end + size > this._buffer.length) {
@@ -66,22 +77,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 +105,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_byte(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 = {}));
@@ -126,90 +137,90 @@ export var PROTO;
     PROTO.Int8 = {
         *serialize(value, stream) {
             const length = 1;
-            stream.write(...globalThis.Array(length).fill(0));
+            stream.write_bytes(new Uint8Array(length));
             stream.data_view.setInt8(stream.end - length, value);
         },
         *deserialize(stream) {
             const value = stream.data_view.getInt8(stream.front);
-            stream.read(1);
+            stream.read_bytes(1);
             return value;
         }
     };
     PROTO.Int16 = {
         *serialize(value, stream) {
             const length = 2;
-            stream.write(...globalThis.Array(length).fill(0));
+            stream.write_bytes(new Uint8Array(length));
             stream.data_view.setInt16(stream.end - length, value);
         },
         *deserialize(stream) {
             const value = stream.data_view.getInt16(stream.front);
-            stream.read(2);
+            stream.read_bytes(2);
             return value;
         }
     };
     PROTO.Int32 = {
         *serialize(value, stream) {
             const length = 4;
-            stream.write(...globalThis.Array(length).fill(0));
+            stream.write_bytes(new Uint8Array(length));
             stream.data_view.setInt32(stream.end - length, value);
         },
         *deserialize(stream) {
             const value = stream.data_view.getInt32(stream.front);
-            stream.read(4);
+            stream.read_bytes(4);
             return value;
         }
     };
     PROTO.UInt8 = {
         *serialize(value, stream) {
             const length = 1;
-            stream.write(...globalThis.Array(length).fill(0));
+            stream.write_bytes(new Uint8Array(length));
             stream.data_view.setUint8(stream.end - length, value);
         },
         *deserialize(stream) {
             const value = stream.data_view.getUint8(stream.front);
-            stream.read(1);
+            stream.read_bytes(1);
             return value;
         }
     };
     PROTO.UInt16 = {
         *serialize(value, stream) {
             const length = 2;
-            stream.write(...globalThis.Array(length).fill(0));
+            stream.write_bytes(new Uint8Array(length));
             stream.data_view.setUint16(stream.end - length, value);
         },
         *deserialize(stream) {
             const value = stream.data_view.getUint16(stream.front);
-            stream.read(2);
+            stream.read_bytes(2);
             return value;
         }
     };
     PROTO.UInt32 = {
         *serialize(value, stream) {
             const length = 4;
-            stream.write(...globalThis.Array(length).fill(0));
+            stream.write_bytes(new Uint8Array(length));
             stream.data_view.setUint32(stream.end - length, value);
         },
         *deserialize(stream) {
             const value = stream.data_view.getUint32(stream.front);
-            stream.read(4);
+            stream.read_bytes(4);
             return value;
         }
     };
     PROTO.UVarInt32 = {
         *serialize(value, stream) {
             while (value >= 0x80) {
-                stream.write((value & 0x7f) | 0x80);
+                stream.write_byte((value & 0x7f) | 0x80);
                 value >>= 7;
                 yield;
             }
-            stream.write(value);
+            stream.write_byte(value);
         },
         *deserialize(stream) {
             let value = 0;
             let size = 0;
             let byte;
             do {
-                byte = stream.read()[0];
+                byte = stream.read_byte();
                 value |= (byte & 0x7f) << (size * 7);
                 size += 1;
                 yield;
@@ -220,24 +231,24 @@ export var PROTO;
     PROTO.Float32 = {
         *serialize(value, stream) {
             const length = 4;
-            stream.write(...globalThis.Array(length).fill(0));
+            stream.write_bytes(new Uint8Array(length));
             stream.data_view.setFloat32(stream.end - length, value);
         },
         *deserialize(stream) {
             const value = stream.data_view.getFloat32(stream.front);
-            stream.read(4);
+            stream.read_bytes(4);
             return value;
         }
     };
     PROTO.Float64 = {
         *serialize(value, stream) {
             const length = 8;
-            stream.write(...globalThis.Array(length).fill(0));
+            stream.write_bytes(new Uint8Array(length));
             stream.data_view.setFloat64(stream.end - length, value);
         },
         *deserialize(stream) {
             const value = stream.data_view.getFloat64(stream.front);
-            stream.read(8);
+            stream.read_bytes(8);
             return value;
         }
     };
@@ -261,21 +272,21 @@ export var PROTO;
     };
     PROTO.Boolean = {
         *serialize(value, stream) {
-            stream.write(value ? 1 : 0);
+            stream.write_byte(value ? 1 : 0);
         },
         *deserialize(stream) {
-            const value = stream.read()[0];
+            const value = stream.read_byte();
             return value === 1;
         }
     };
     PROTO.UInt8Array = {
         *serialize(value, stream) {
             yield* PROTO.UVarInt32.serialize(value.length, stream);
-            stream.write(...value);
+            stream.write_bytes(value);
         },
         *deserialize(stream) {
             const length = yield* PROTO.UVarInt32.deserialize(stream);
-            return new Uint8Array(stream.read(length));
+            return stream.read_bytes(length);
         }
     };
     PROTO.Date = {
@@ -409,11 +420,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 +452,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 +460,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_byte(hex_code & 0xff);
+                    buffer.write_byte(hex_code >> 8);
                 }
                 else {
-                    result.push(char_code & 0xff);
-                    result.push(char_code >> 8);
+                    buffer.write_byte(char_code & 0xff);
+                    buffer.write_byte(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 +514,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.4",
   "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;