mcbe-ipc 3.1.4 → 3.2.1

package/README.md

@@ -23,4 +23,13 @@ npm install mcbe-ipc
 
 
 
+
+> [!NOTE]
+> Official documentation is still in progress.
+> 
+> For now, you can refer to the [DeepWiki page](https://deepwiki.com/OmniacDev/MCBE-IPC/).
+> Please note that while it is generally accurate, some of the more advanced sections may contain small inaccuracies.
+
+
+
 [^1]: Inter-Pack Communication

package/dist/ipc.d.ts

@@ -23,12 +23,20 @@
  * SOFTWARE.
  */
 export declare namespace PROTO {
-    interface Serializable<T> {
+    const t: unique symbol;
+    interface Phantom<T> {
+        readonly [t]?: T;
+    }
+    export interface Serializer<T> extends Phantom<T> {
         serialize(value: T, stream: Buffer): Generator<void, void, void>;
+    }
+    export interface Deserializer<T> extends Phantom<T> {
         deserialize(stream: Buffer): Generator<void, T, void>;
     }
-    type Infer<S> = S extends PROTO.Serializable<infer T> ? T : never;
-    class Buffer {
+    export interface Serializable<T> extends Serializer<T>, Deserializer<T> {
+    }
+    export type Infer<S> = S extends Phantom<infer T> ? T : never;
+    export class Buffer {
         private _buffer;
         private _data_view;
         private _length;
@@ -37,71 +45,75 @@ export declare namespace PROTO {
         get front(): number;
         get data_view(): DataView;
         constructor(size?: number);
-        write_byte(byte: number): void;
-        write_bytes(bytes: Uint8Array): void;
-        read_byte(): number;
-        read_bytes(amount: number): Uint8Array;
+        reserve(amount: number): number;
+        consume(amount: number): number;
+        write(byte: number): void;
+        write(bytes: Uint8Array): void;
+        read(): number;
+        read(amount: number): Uint8Array;
         ensure_capacity(size: number): void;
         static from_uint8array(array: Uint8Array): Buffer;
         to_uint8array(): Uint8Array;
     }
-    namespace MIPS {
+    export namespace MIPS {
         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>;
-    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: {
+    export const Void: PROTO.Serializable<void>;
+    export const Null: PROTO.Serializable<null>;
+    export const Undefined: PROTO.Serializable<undefined>;
+    export const Int8: PROTO.Serializable<number>;
+    export const Int16: PROTO.Serializable<number>;
+    export const Int32: PROTO.Serializable<number>;
+    export const UInt8: PROTO.Serializable<number>;
+    export const UInt16: PROTO.Serializable<number>;
+    export const UInt32: PROTO.Serializable<number>;
+    export const UVarInt32: PROTO.Serializable<number>;
+    export const VarInt32: PROTO.Serializable<number>;
+    export const Float32: PROTO.Serializable<number>;
+    export const Float64: PROTO.Serializable<number>;
+    export const String: PROTO.Serializable<string>;
+    export const Boolean: PROTO.Serializable<boolean>;
+    export const UInt8Array: PROTO.Serializable<Uint8Array>;
+    export const Date: PROTO.Serializable<Date>;
+    export function Object<T extends object>(s: {
         [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: {
+    export function Array<T>(s: PROTO.Serializable<T>): PROTO.Serializable<T[]>;
+    export function Tuple<T extends any[]>(...s: {
         [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 = {
+    export function Optional<T>(s: PROTO.Serializable<T>): PROTO.Serializable<T | undefined>;
+    export function Map<K, V>(kS: PROTO.Serializable<K>, vS: PROTO.Serializable<V>): PROTO.Serializable<Map<K, V>>;
+    export function Set<V>(s: PROTO.Serializable<V>): PROTO.Serializable<Set<V>>;
+    export type Endpoint = string;
+    export type Header = {
         guid: string;
         encoding: string;
         index: number;
         final: boolean;
     };
-    const Endpoint: PROTO.Serializable<Endpoint>;
-    const Header: PROTO.Serializable<Header>;
+    export const Endpoint: PROTO.Serializable<Endpoint>;
+    export const Header: PROTO.Serializable<Header>;
+    export {};
 }
 export declare namespace NET {
     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;
+    function emit<S extends PROTO.Serializer<any>>(endpoint: string, serializer: S, value: PROTO.Infer<S>): Generator<void, void, void>;
+    function listen<D extends PROTO.Deserializer<any>>(endpoint: string, deserializer: D, callback: (value: PROTO.Infer<D>) => Generator<void, void, void>): () => void;
 }
 export declare namespace IPC {
     /** Sends a message with `args` to `channel` */
-    function send<S extends PROTO.Serializable<any>>(channel: string, serializer: S, value: PROTO.Infer<S>): void;
+    function send<S extends PROTO.Serializer<any>>(channel: string, serializer: S, value: PROTO.Infer<S>): void;
     /** Sends an `invoke` message through IPC, and expects a result asynchronously. */
-    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>>;
+    function invoke<S extends PROTO.Serializer<any>, D extends PROTO.Deserializer<any>>(channel: string, serializer: S, value: PROTO.Infer<S>, deserializer: D): Promise<PROTO.Infer<D>>;
     /** Listens to `channel`. When a new message arrives, `listener` will be called with `listener(args)`. */
-    function on<D extends PROTO.Serializable<any>>(channel: string, deserializer: D, listener: (value: PROTO.Infer<D>) => void): () => void;
+    function on<D extends PROTO.Deserializer<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<D extends PROTO.Serializable<any>>(channel: string, deserializer: D, listener: (value: PROTO.Infer<D>) => void): () => void;
+    function once<D extends PROTO.Deserializer<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<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;
+    function handle<D extends PROTO.Deserializer<any>, S extends PROTO.Serializer<any>>(channel: string, deserializer: D, serializer: S, listener: (value: PROTO.Infer<D>) => PROTO.Infer<S>): () => void;
 }
 export default IPC;

package/dist/ipc.js

@@ -41,31 +41,39 @@ export var PROTO;
             this._length = 0;
             this._offset = 0;
         }
-        write_byte(byte) {
-            this.ensure_capacity(1);
-            this._buffer[this.end] = byte;
-            this._length++;
-        }
-        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.slice(this._offset, this._offset + max_amount);
-                this._length -= max_amount;
-                this._offset += max_amount;
-                return values;
+        reserve(amount) {
+            this.ensure_capacity(amount);
+            const end = this.end;
+            this._length += amount;
+            return end;
+        }
+        consume(amount) {
+            if (amount > this._length)
+                throw new Error('not enough bytes');
+            const front = this.front;
+            this._length -= amount;
+            this._offset += amount;
+            return front;
+        }
+        write(input) {
+            if (typeof input === 'number') {
+                const offset = this.reserve(1);
+                this._buffer[offset] = input;
+            }
+            else {
+                const offset = this.reserve(input.length);
+                this._buffer.set(input, offset);
+            }
+        }
+        read(amount) {
+            if (amount === undefined) {
+                const offset = this.consume(1);
+                return this._buffer[offset];
+            }
+            else {
+                const offset = this.consume(amount);
+                return this._buffer.slice(offset, offset + amount);
             }
-            return new Uint8Array();
         }
         ensure_capacity(size) {
             if (this.end + size > this._buffer.length) {
@@ -109,7 +117,7 @@ export var PROTO;
                 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];
-                    buffer.write_byte(parseInt(hex, 16));
+                    buffer.write(parseInt(hex, 16));
                     yield;
                 }
                 return buffer;
@@ -136,120 +144,98 @@ export var PROTO;
     };
     PROTO.Int8 = {
         *serialize(value, stream) {
-            const length = 1;
-            stream.write_bytes(new Uint8Array(length));
-            stream.data_view.setInt8(stream.end - length, value);
+            stream.data_view.setInt8(stream.reserve(1), value);
         },
         *deserialize(stream) {
-            const value = stream.data_view.getInt8(stream.front);
-            stream.read_bytes(1);
-            return value;
+            return stream.data_view.getInt8(stream.consume(1));
         }
     };
     PROTO.Int16 = {
         *serialize(value, stream) {
-            const length = 2;
-            stream.write_bytes(new Uint8Array(length));
-            stream.data_view.setInt16(stream.end - length, value);
+            stream.data_view.setInt16(stream.reserve(2), value);
         },
         *deserialize(stream) {
-            const value = stream.data_view.getInt16(stream.front);
-            stream.read_bytes(2);
-            return value;
+            return stream.data_view.getInt16(stream.consume(2));
         }
     };
     PROTO.Int32 = {
         *serialize(value, stream) {
-            const length = 4;
-            stream.write_bytes(new Uint8Array(length));
-            stream.data_view.setInt32(stream.end - length, value);
+            stream.data_view.setInt32(stream.reserve(4), value);
         },
         *deserialize(stream) {
-            const value = stream.data_view.getInt32(stream.front);
-            stream.read_bytes(4);
-            return value;
+            return stream.data_view.getInt32(stream.consume(4));
         }
     };
     PROTO.UInt8 = {
         *serialize(value, stream) {
-            const length = 1;
-            stream.write_bytes(new Uint8Array(length));
-            stream.data_view.setUint8(stream.end - length, value);
+            stream.data_view.setUint8(stream.reserve(1), value);
         },
         *deserialize(stream) {
-            const value = stream.data_view.getUint8(stream.front);
-            stream.read_bytes(1);
-            return value;
+            return stream.data_view.getUint8(stream.consume(1));
         }
     };
     PROTO.UInt16 = {
         *serialize(value, stream) {
-            const length = 2;
-            stream.write_bytes(new Uint8Array(length));
-            stream.data_view.setUint16(stream.end - length, value);
+            stream.data_view.setUint16(stream.reserve(2), value);
         },
         *deserialize(stream) {
-            const value = stream.data_view.getUint16(stream.front);
-            stream.read_bytes(2);
-            return value;
+            return stream.data_view.getUint16(stream.consume(2));
         }
     };
     PROTO.UInt32 = {
         *serialize(value, stream) {
-            const length = 4;
-            stream.write_bytes(new Uint8Array(length));
-            stream.data_view.setUint32(stream.end - length, value);
+            stream.data_view.setUint32(stream.reserve(4), value);
         },
         *deserialize(stream) {
-            const value = stream.data_view.getUint32(stream.front);
-            stream.read_bytes(4);
-            return value;
+            return stream.data_view.getUint32(stream.consume(4));
         }
     };
     PROTO.UVarInt32 = {
         *serialize(value, stream) {
+            value >>>= 0;
             while (value >= 0x80) {
-                stream.write_byte((value & 0x7f) | 0x80);
-                value >>= 7;
+                stream.write((value & 0x7f) | 0x80);
+                value >>>= 7;
                 yield;
             }
-            stream.write_byte(value);
+            stream.write(value);
         },
         *deserialize(stream) {
             let value = 0;
-            let size = 0;
-            let byte;
-            do {
-                byte = stream.read_byte();
+            for (let size = 0; size < 5; size++) {
+                const byte = stream.read();
                 value |= (byte & 0x7f) << (size * 7);
-                size += 1;
                 yield;
-            } while ((byte & 0x80) !== 0 && size < 10);
-            return value;
+                if ((byte & 0x80) == 0)
+                    break;
+            }
+            return value >>> 0;
+        }
+    };
+    PROTO.VarInt32 = {
+        *serialize(value, stream) {
+            const zigzag = (value << 1) ^ (value >> 31);
+            yield* PROTO.UVarInt32.serialize(zigzag, stream);
+        },
+        *deserialize(stream) {
+            const zigzag = yield* PROTO.UVarInt32.deserialize(stream);
+            return (zigzag >>> 1) ^ -(zigzag & 1);
         }
     };
     PROTO.Float32 = {
         *serialize(value, stream) {
-            const length = 4;
-            stream.write_bytes(new Uint8Array(length));
-            stream.data_view.setFloat32(stream.end - length, value);
+            stream.data_view.setFloat32(stream.reserve(4), value);
         },
         *deserialize(stream) {
-            const value = stream.data_view.getFloat32(stream.front);
-            stream.read_bytes(4);
-            return value;
+            return stream.data_view.getFloat32(stream.consume(4));
         }
     };
     PROTO.Float64 = {
         *serialize(value, stream) {
-            const length = 8;
-            stream.write_bytes(new Uint8Array(length));
-            stream.data_view.setFloat64(stream.end - length, value);
+            stream.data_view.setFloat64(stream.reserve(8), value);
         },
         *deserialize(stream) {
-            const value = stream.data_view.getFloat64(stream.front);
-            stream.read_bytes(8);
-            return value;
+            return stream.data_view.getFloat64(stream.consume(8));
         }
     };
     PROTO.String = {
@@ -272,21 +258,20 @@ export var PROTO;
     };
     PROTO.Boolean = {
         *serialize(value, stream) {
-            stream.write_byte(value ? 1 : 0);
+            stream.write(value ? 1 : 0);
         },
         *deserialize(stream) {
-            const value = stream.read_byte();
-            return value === 1;
+            return stream.read() !== 0;
         }
     };
     PROTO.UInt8Array = {
         *serialize(value, stream) {
             yield* PROTO.UVarInt32.serialize(value.length, stream);
-            stream.write_bytes(value);
+            stream.write(value);
         },
         *deserialize(stream) {
             const length = yield* PROTO.UVarInt32.deserialize(stream);
-            return stream.read_bytes(length);
+            return stream.read(length);
         }
     };
     PROTO.Date = {
@@ -297,92 +282,91 @@ export var PROTO;
             return new globalThis.Date(yield* PROTO.Float64.deserialize(stream));
         }
     };
-    function Object(obj) {
+    function Object(s) {
         return {
             *serialize(value, stream) {
-                for (const key in obj) {
-                    yield* obj[key].serialize(value[key], stream);
+                for (const key in s) {
+                    yield* s[key].serialize(value[key], stream);
                 }
             },
             *deserialize(stream) {
                 const result = {};
-                for (const key in obj) {
-                    result[key] = yield* obj[key].deserialize(stream);
+                for (const key in s) {
+                    result[key] = yield* s[key].deserialize(stream);
                 }
                 return result;
             }
         };
     }
     PROTO.Object = Object;
-    function Array(value) {
+    function Array(s) {
         return {
-            *serialize(array, stream) {
-                yield* PROTO.UVarInt32.serialize(array.length, stream);
-                for (const item of array) {
-                    yield* value.serialize(item, stream);
+            *serialize(value, stream) {
+                yield* PROTO.UVarInt32.serialize(value.length, stream);
+                for (const item of value) {
+                    yield* s.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);
+                    result[i] = yield* s.deserialize(stream);
                 }
                 return result;
             }
         };
     }
     PROTO.Array = Array;
-    function Tuple(...values) {
+    function Tuple(...s) {
         return {
-            *serialize(tuple, stream) {
-                for (let i = 0; i < values.length; i++) {
-                    yield* values[i].serialize(tuple[i], stream);
+            *serialize(value, stream) {
+                for (let i = 0; i < s.length; i++) {
+                    yield* s[i].serialize(value[i], stream);
                 }
             },
             *deserialize(stream) {
                 const result = [];
-                for (let i = 0; i < values.length; i++) {
-                    result[i] = yield* values[i].deserialize(stream);
+                for (let i = 0; i < s.length; i++) {
+                    result[i] = yield* s[i].deserialize(stream);
                 }
                 return result;
             }
         };
     }
     PROTO.Tuple = Tuple;
-    function Optional(value) {
+    function Optional(s) {
         return {
-            *serialize(optional, stream) {
-                yield* PROTO.Boolean.serialize(optional !== undefined, stream);
-                if (optional !== undefined) {
-                    yield* value.serialize(optional, stream);
-                }
+            *serialize(value, stream) {
+                const def = value !== undefined;
+                yield* PROTO.Boolean.serialize(def, stream);
+                if (def)
+                    yield* s.serialize(value, stream);
             },
             *deserialize(stream) {
-                const defined = yield* PROTO.Boolean.deserialize(stream);
-                if (defined) {
-                    return yield* value.deserialize(stream);
-                }
+                const def = yield* PROTO.Boolean.deserialize(stream);
+                if (def)
+                    return yield* s.deserialize(stream);
                 return undefined;
             }
         };
     }
     PROTO.Optional = Optional;
-    function Map(key, value) {
+    function Map(kS, vS) {
         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);
+            *serialize(value, stream) {
+                yield* PROTO.UVarInt32.serialize(value.size, stream);
+                for (const [k, v] of value) {
+                    yield* kS.serialize(k, stream);
+                    yield* vS.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);
+                    const k = yield* kS.deserialize(stream);
+                    const v = yield* vS.deserialize(stream);
                     result.set(k, v);
                 }
                 return result;
@@ -390,19 +374,19 @@ export var PROTO;
         };
     }
     PROTO.Map = Map;
-    function Set(value) {
+    function Set(s) {
         return {
             *serialize(set, stream) {
                 yield* PROTO.UVarInt32.serialize(set.size, stream);
-                for (const [_, v] of set.entries()) {
-                    yield* value.serialize(v, stream);
+                for (const v of set) {
+                    yield* s.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);
+                    const v = yield* s.deserialize(stream);
                     result.add(v);
                 }
                 return result;
@@ -460,12 +444,12 @@ export var NET;
                 if (char_code <= 0xff) {
                     const hex = str[j] + str[++j];
                     const hex_code = parseInt(hex, 16);
-                    buffer.write_byte(hex_code & 0xff);
-                    buffer.write_byte(hex_code >> 8);
+                    buffer.write(hex_code & 0xff);
+                    buffer.write(hex_code >> 8);
                 }
                 else {
-                    buffer.write_byte(char_code & 0xff);
-                    buffer.write_byte(char_code >> 8);
+                    buffer.write(char_code & 0xff);
+                    buffer.write(char_code >> 8);
                 }
                 yield;
             }
@@ -476,16 +460,26 @@ export var NET;
     NET.deserialize = deserialize;
     system.afterEvents.scriptEventReceive.subscribe(event => {
         system.runJob((function* () {
+            if (event.sourceType !== ScriptEventSource.Server)
+                return;
             const [serialized_endpoint, serialized_header] = event.id.split(':');
             const endpoint_stream = yield* PROTO.MIPS.deserialize(serialized_endpoint);
             const endpoint = yield* PROTO.Endpoint.deserialize(endpoint_stream);
             const listeners = ENDPOINTS.get(endpoint);
-            if (event.sourceType === ScriptEventSource.Server && listeners) {
+            if (listeners !== undefined) {
                 const header_stream = yield* PROTO.MIPS.deserialize(serialized_header);
                 const header = yield* PROTO.Header.deserialize(header_stream);
+                const errors = [];
                 for (let i = 0; i < listeners.length; i++) {
-                    yield* listeners[i](header, event.message);
+                    try {
+                        yield* listeners[i](header, event.message);
+                    }
+                    catch (e) {
+                        errors.push(e);
+                    }
                 }
+                if (errors.length > 0)
+                    throw new AggregateError(errors, 'one or more listeners failed');
             }
         })());
     });
@@ -530,7 +524,7 @@ export var NET;
         }
     }
     NET.emit = emit;
-    function listen(endpoint, serializer, callback) {
+    function listen(endpoint, deserializer, callback) {
         const buffer = new Map();
         const listener = function* (payload, serialized_packet) {
             let fragment = buffer.get(payload.guid);
@@ -545,7 +539,7 @@ export var NET;
             fragment.data_size += payload.index + 1;
             if (fragment.size !== -1 && fragment.data_size === (fragment.size * (fragment.size + 1)) / 2) {
                 const stream = yield* deserialize(fragment.serialized_packets);
-                const value = yield* serializer.deserialize(stream);
+                const value = yield* deserializer.deserialize(stream);
                 yield* callback(value);
                 buffer.delete(payload.guid);
             }
@@ -563,12 +557,12 @@ export var IPC;
     IPC.send = send;
     /** Sends an `invoke` message through IPC, and expects a result asynchronously. */
     function invoke(channel, serializer, value, deserializer) {
-        system.runJob(NET.emit(`ipc:${channel}:invoke`, serializer, value));
         return new Promise(resolve => {
             const terminate = NET.listen(`ipc:${channel}:handle`, deserializer, function* (value) {
                 resolve(value);
                 terminate();
             });
+            system.runJob(NET.emit(`ipc:${channel}:invoke`, serializer, value));
         });
     }
     IPC.invoke = invoke;

package/package.json

@@ -3,7 +3,7 @@
   "author": "OmniacDev",
   "description": "IPC system for MCBE Script API projects",
   "license": "MIT",
-  "version": "3.1.4",
+  "version": "3.2.1",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/OmniacDev/MCBE-IPC.git"
@@ -20,12 +20,15 @@
   ],
   "scripts": {
     "build": "tsc",
+    "test": "vitest",
+    "bench": "vitest bench",
     "format": "prettier --write src",
     "prepublishOnly": "npm run build"
   },
   "devDependencies": {
     "prettier": "^3.3.3",
-    "typescript": "^5.5.4"
+    "typescript": "^5.5.4",
+    "vitest": "^4.0.16"
   },
   "dependencies": {
     "@minecraft/server": "^1.18.0"