@spider-mesh/core 1.0.115 → 1.0.117

package/build/src/SpiderMesh.js

@@ -6,26 +6,27 @@ import { RPCOptionsList } from './RPCOptions.js';
 import os from 'os';
 import { listEventSubscribers } from './decorators/ListenEvent.js';
 import { listReadyHookMethods } from './decorators/OnMicroserviceReady.js';
-import { BehaviorSubject, EMPTY, Observable, Subject, bufferTime, catchError, debounceTime, filter, firstValueFrom, from, groupBy, map, merge, mergeAll, mergeMap, of, retry, takeUntil, tap, timer } from 'rxjs';
+import { BehaviorSubject, EMPTY, Observable, Subject, bufferTime, catchError, debounceTime, filter, finalize, first, firstValueFrom, from, groupBy, map, mergeAll, mergeMap, of, share, tap } from 'rxjs';
 import { readFileSync } from 'fs';
 import { serviceInstanceList } from './decorators/Microservice.js';
 import { sleep } from './helpers/sleep.js';
 import { BuiltinTransporter } from './builtin-transporter/BuiltinTransporter.js';
 import { NAMEPSACE, NODE_ID } from './const.js';
-export class SpiderMeshConfig {
-    namespace;
-    node_id;
-    transporter;
-}
+import { Encoder } from './Encoder.js';
+export var MessageType;
+(function (MessageType) {
+    MessageType[MessageType["RpcRequest"] = 10] = "RpcRequest";
+    MessageType[MessageType["RpcSubscribeChannel"] = 20] = "RpcSubscribeChannel";
+    MessageType[MessageType["RpcUnsubscribeChannel"] = 30] = "RpcUnsubscribeChannel";
+    MessageType[MessageType["RpcStream"] = 50] = "RpcStream";
+})(MessageType || (MessageType = {}));
 const PACKAGE_JSON = JSON.parse(readFileSync(`package.json`, 'utf8')) || {};
 export class SpiderMesh {
     transporter;
-    #$isolated = new BehaviorSubject(false);
-    #local_rpc_services = new Map();
-    #remote_rpc_services = new Map;
+    #requests = new Map;
+    #local_services = new Map();
+    #remote_services = new Map;
     #linked_nodes = new Map();
-    #rpc_queue = new Map;
-    #rpc_response_queue = new Map;
     #public_ip = new Promise(async (s) => {
         for (let i = 1; i <= 5; i++) {
             const ip = await new Promise(s => {
@@ -44,19 +45,258 @@ export class SpiderMesh {
     });
     $nodes_monitor = new Subject();
     #initing;
+    #$isolated = new BehaviorSubject(false);
     constructor(transporter = new BuiltinTransporter(NODE_ID, NAMEPSACE)) {
         this.transporter = transporter;
         this.#initing = this.#init();
     }
-    static add_transporter(transporter) {
-        new this(transporter);
+    #caculate_rpc_node_id(service_name, options = {}) {
+        const current = this.#remote_services.get(service_name);
+        if (!current || current.nodes.length == 0)
+            return;
+        if (options.$node_id) {
+            if (current.nodes.some(node => node.id == options.$node_id))
+                return options.$node_id;
+            return;
+        }
+        const option_ip = options.$ip;
+        const nodes = option_ip ? (current
+            .nodes
+            .filter(node => node.public_ip == option_ip || node.ip_addresses.includes(option_ip))) : current.nodes;
+        if (nodes.length == 0)
+            return;
+        current.last_call_index = (current.last_call_index + 1) % nodes.length;
+        return nodes[current.last_call_index].id;
+    }
+    rpc(service, method, args, options = {}) {
+        const target_node_id = this.#caculate_rpc_node_id(service, options);
+        if (!target_node_id)
+            throw `SERVICE_NOT_RUNNING:${service}`;
+        const session_id = randomUUID();
+        const { buffer, observables } = Encoder.encode(args);
+        const req = {
+            channels: new Map(),
+            target_node_id,
+            observables,
+            subscriptions: new Map()
+        };
+        this.#requests.set(session_id, req);
+        this.publish(target_node_id, {
+            type: MessageType.RpcRequest,
+            session_id,
+            args: buffer,
+            method,
+            service,
+        }, target_node_id);
+        const o = new Subject();
+        req.channels.set(session_id, o);
+        const $ = o.pipe(first(), mergeMap(data => {
+            if (data instanceof Buffer) {
+                const [response, is_pure] = this.#decode_rpc_buffer(req, data, session_id);
+                if (is_pure) {
+                    this.#requests.delete(session_id);
+                }
+                req.channels.delete(session_id);
+                return response instanceof Observable ? response : of(response);
+            }
+            return EMPTY;
+        }), catchError(err => {
+            if (options.$fallback) {
+                return of(options.$fallback);
+            }
+            throw err;
+        }), share());
+        $.subscribe();
+        return Object.assign($, {
+            then: async (success, error) => {
+                try {
+                    const value = await firstValueFrom($);
+                    success(options.$safe_mode ? [null, value] : value);
+                }
+                catch (e) {
+                    options.$safe_mode ? success([e, null]) : error(e);
+                }
+            },
+            async catch() {
+                return {};
+            },
+            async finally() {
+                return {};
+            },
+            [Symbol.toStringTag]: ''
+        });
+    }
+    #get_rpc_target(msg) {
+        if (msg.service == 'SpiderMesh') {
+            if (!msg.method.startsWith('$'))
+                throw `SPIDER_MESH_METHOD_NOT_ALLOW`;
+            return this;
+        }
+        const service = this.#local_services.get(msg.service)?.instance;
+        if (!service)
+            throw 'RPC_SERVICE_NOT_FOUND';
+        if (typeof service[msg.method] != 'function')
+            throw 'RPC_METHOD_NOT_FOUND';
+        return service;
+    }
+    #decode_rpc_buffer(req, data, session_id) {
+        let is_pure = true;
+        const result = Encoder.decode(data, () => () => {
+            throw new Error('CAN_NOT_CALL_FUNCTION_IN_RPC');
+        }, observable_id => {
+            is_pure = false;
+            const tid = setTimeout(() => {
+                throw new Error('Orphant Observable detected !', {
+                    cause: 'All Observable object need to subscribe within 2 second'
+                });
+            }, 2000);
+            return new Observable(o => {
+                clearTimeout(tid);
+                if (!this.#requests.has(session_id)) {
+                    return o.next('RPC_OFFLINE');
+                }
+                const channel_id = randomUUID();
+                const s = new Subject();
+                req.channels.set(channel_id, s);
+                s.subscribe(o);
+                this.#subscribe_channel(req.target_node_id, session_id, observable_id, channel_id);
+                return () => {
+                    this.#unsubcribe_channel(req.target_node_id, session_id, channel_id);
+                };
+            });
+        });
+        return [result, is_pure];
+    }
+    async #on_rpc(msg, sender_node_id) {
+        const instance = this.#get_rpc_target(msg);
+        this.#requests.set(msg.session_id, {
+            observables: new Map(),
+            target_node_id: sender_node_id,
+            subscriptions: new Map(),
+            channels: new Map()
+        });
+        const req = this.#requests.get(msg.session_id);
+        if (!req)
+            return;
+        const channel_id = msg.session_id;
+        try {
+            const [args] = this.#decode_rpc_buffer(req, msg.args, msg.session_id);
+            if (!args)
+                return this.#stream_error(sender_node_id, msg.session_id, channel_id, Buffer.from('INVAILD_ARGS'));
+            const result = await instance?.[msg.method]?.(...args);
+            const { buffer, observables } = Encoder.encode(await result);
+            for (const [observable_id, o] of observables)
+                req.observables.set(observable_id, o);
+            this.#stream_next(sender_node_id, msg.session_id, channel_id, buffer);
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                this.#stream_error(sender_node_id, msg.session_id, channel_id, Encoder.encode(JSON.stringify(error)).buffer);
+            }
+        }
+    }
+    #stream_next(node_id, session_id, channel_id, data) {
+        return this.publish(node_id, {
+            type: MessageType.RpcStream,
+            channel_id,
+            session_id,
+            data
+        }, node_id);
+    }
+    #stream_error(node_id, session_id, channel_id, error) {
+        return this.publish(node_id, {
+            type: MessageType.RpcStream,
+            channel_id,
+            session_id,
+            error
+        }, node_id);
+    }
+    #stream_complete(node_id, session_id, channel_id) {
+        return this.publish(node_id, {
+            type: MessageType.RpcStream,
+            channel_id,
+            completed: true,
+            session_id
+        }, node_id);
+    }
+    #subscribe_channel(node_id, session_id, observable_id, channel_id) {
+        return this.publish(node_id, {
+            type: MessageType.RpcSubscribeChannel,
+            channel_id,
+            session_id,
+            observable_id
+        }, node_id);
+    }
+    #on_subscribe_channel(msg, sender_node_id) {
+        const response = (e) => {
+            this.publish(sender_node_id, {
+                session_id: msg.session_id,
+                channel_id: msg.channel_id,
+                type: MessageType.RpcStream,
+                ...e
+            }, sender_node_id);
+        };
+        const req = this.#requests.get(msg.session_id);
+        if (!req) {
+            response({ error: 'RPC_SESSION_EXPIRED' });
+            return;
+        }
+        const o = req.observables.get(msg.observable_id);
+        if (!o)
+            return;
+        const subscription = o.pipe(finalize(() => {
+            if (req.subscriptions.size == 0 && req.channels.size == 0) {
+                this.#requests.delete(msg.session_id);
+            }
+        })).subscribe({
+            complete: () => this.#stream_complete(sender_node_id, msg.session_id, msg.channel_id),
+            error: error => this.#stream_error(sender_node_id, msg.session_id, msg.channel_id, error),
+            next: data => this.#stream_next(sender_node_id, msg.session_id, msg.channel_id, data)
+        });
+        req.subscriptions.set(msg.channel_id, subscription);
+    }
+    #unsubcribe_channel(node_id, session_id, channel_id) {
+        return this.publish(node_id, {
+            type: MessageType.RpcUnsubscribeChannel,
+            channel_id,
+            session_id
+        }, node_id);
+    }
+    #on_unsubscribe_channel(msg) {
+        const req = this.#requests.get(msg.session_id);
+        if (!req)
+            return;
+        req.subscriptions.get(msg.channel_id)?.unsubscribe();
+        req.subscriptions.delete(msg.channel_id);
+        if (req.channels.size == 0 && req.subscriptions.size == 0) {
+            this.#requests.delete(msg.session_id);
+        }
+    }
+    #on_stream(stream) {
+        const req = this.#requests.get(stream.session_id);
+        if (!req)
+            return;
+        const $ = req.channels.get(stream.channel_id);
+        if (!$)
+            return;
+        if (stream.data != undefined) {
+            $.next(stream.data);
+        }
+        if (stream.completed || stream.error) {
+            stream.error && $.error(stream.error);
+            stream.completed && $.complete();
+            req.channels.delete(stream.channel_id);
+            if (req.channels.size == 0 && req.subscriptions.size == 0) {
+                this.#requests.delete(stream.session_id);
+            }
+        }
     }
     async $metadata() {
         const ips = (Object.values(networkInterfaces())
             .flat(2)
-            .filter(a => !a.internal)
-            .map(a => a.address));
-        const services = [...this.#local_rpc_services.entries()].reduce((p, [service_id, { metadata }]) => ({
+            .filter(a => a && !a.internal && a.address)
+            .map(a => a?.address));
+        const services = [...this.#local_services.entries()].reduce((p, [service_id, { metadata }]) => ({
             ...p,
             [service_id]: metadata
         }), {});
@@ -88,11 +328,7 @@ export class SpiderMesh {
     }
     async #self_introduce(node_id) {
         const me = await this.$metadata();
-        this.transporter.publish({
-            event: '#join',
-            data: [me],
-            node_id
-        });
+        await this.publish('#join', [me], node_id);
         return me;
     }
     async $update_isolate_mode(active) {
@@ -100,143 +336,22 @@ export class SpiderMesh {
         const me = await this.#self_introduce();
         return me;
     }
-    async #node_event_handler({ data: msg, sender_node_id }) {
-        if (msg.type == 'rpc') {
-            if (msg.service == 'SpiderMesh' && !msg.method.startsWith('$')) {
-                sender_node_id && this.transporter.publish({
-                    data: [{
-                            id: msg.id,
-                            type: 'error',
-                            error: 'NOT_ALLOW'
-                        }],
-                    event: sender_node_id,
-                    node_id: sender_node_id
-                });
-                return;
-            }
-            const instance = msg.service == 'SpiderMesh' ? this : this.#local_rpc_services.get(msg.service)?.instance;
-            if (!instance)
-                return this.transporter.publish({
-                    data: [{
-                            id: msg.id,
-                            type: 'error',
-                            error: 'SERVICE_NOT_FOUND'
-                        }],
-                    event: sender_node_id,
-                    node_id: sender_node_id
-                });
-            if (typeof instance?.[msg.method] != 'function')
-                return this.transporter.publish({
-                    data: [{
-                            id: msg.id,
-                            type: 'error',
-                            error: 'SERVICE_METHOD_NOT_FOUND'
-                        }],
-                    event: sender_node_id,
-                    node_id: sender_node_id
-                });
-            const args = msg.args.map(arg => arg != '__FUNCTION__' ? arg : (...args) => {
-                sender_node_id && this.transporter.publish({
-                    event: sender_node_id,
-                    node_id: sender_node_id,
-                    data: [{ id: msg.id, type: 'callback', args }]
-                });
-            });
-            try {
-                const response = await instance?.[msg.method]?.(...args);
-                if (response && typeof response.subscribe == 'function') {
-                    const $cancel = new Subject();
-                    this.#rpc_response_queue.set(msg.id, { $cancel });
-                    response
-                        .pipe(takeUntil($cancel))
-                        .subscribe({
-                        complete: () => {
-                            this.#rpc_response_queue.delete(msg.id);
-                            sender_node_id && this.transporter.publish({
-                                event: sender_node_id,
-                                node_id: sender_node_id,
-                                data: [{ id: msg.id, type: 'end' }]
-                            });
-                        },
-                        error: (error) => {
-                            this.#rpc_response_queue.delete(msg.id);
-                            sender_node_id && this.transporter.publish({
-                                event: sender_node_id,
-                                node_id: sender_node_id,
-                                data: [{ id: msg.id, type: 'error', error: error?.code || error?.message || error || 'UNKNOWN' }]
-                            });
-                        },
-                        next: (response) => {
-                            sender_node_id && this.transporter.publish({
-                                event: sender_node_id,
-                                node_id: sender_node_id,
-                                data: [{ id: msg.id, type: 'next', response }]
-                            });
-                        }
-                    });
-                }
-                else {
-                    sender_node_id && this.transporter.publish({
-                        event: sender_node_id,
-                        node_id: sender_node_id,
-                        data: [{ id: msg.id, type: 'response', response }]
-                    });
-                }
-            }
-            catch (error) {
-                sender_node_id && this.transporter.publish({
-                    event: sender_node_id,
-                    node_id: sender_node_id,
-                    data: [{ id: msg.id, type: 'error', error: error?.code || error?.message || error || 'UNKNOWN' }]
-                });
-            }
-            return;
-        }
-        if (msg.type == 'rpc-cancel') {
-            const responding = this.#rpc_response_queue.get(msg.id);
-            responding?.$cancel.next();
-            return;
-        }
-        const request = this.#rpc_queue.get(msg.id);
-        if (!request)
-            return;
-        if (msg.type == 'callback') {
-            request.args?.[msg.index]?.();
-            return;
-        }
-        if (msg.type == 'next') {
-            request.$.next(msg.response);
-            return;
-        }
-        if (msg.type == 'ack') {
-            request.last_ping = Date.now();
-            return;
-        }
-        if (msg.type == 'error') {
-            request.$.error(msg.error);
-            this.#rpc_queue.delete(msg.id);
-            return;
-        }
-        if (msg.type == 'response') {
-            request.$.next(msg.response);
-            request.$.complete();
-            this.#rpc_queue.delete(msg.id);
-            return;
-        }
-        if (msg.type == 'end') {
-            request.$.complete();
-            this.#rpc_queue.delete(msg.id);
-            return;
-        }
+    #node_event_handler({ data: msg, sender_node_id }) {
+        if (msg.type == MessageType.RpcRequest)
+            return this.#on_rpc(msg, sender_node_id);
+        if (msg.type == MessageType.RpcStream)
+            return this.#on_stream(msg);
+        if (msg.type == MessageType.RpcSubscribeChannel)
+            return this.#on_subscribe_channel(msg, sender_node_id);
+        if (msg.type == MessageType.RpcUnsubscribeChannel)
+            return this.#on_unsubscribe_channel(msg);
     }
     async #init() {
         await this.transporter.start();
-        this.listen(this.transporter.node_id).subscribe(evt => this.#node_event_handler(evt));
+        this.listen(this.transporter.node_id).subscribe(msg => this.#node_event_handler(msg));
         this.listen('#join')
-            .pipe(groupBy(node => node.sender_node_id), mergeMap(grouped => grouped.pipe(debounceTime(1000))))
-            .subscribe(({ data }) => {
-            this.#on_node_discovered(data);
-        });
+            .pipe(groupBy(node => node.sender_node_id), mergeMap(grouped => grouped.pipe(debounceTime(1000))), mergeMap(({ data }) => this.#on_node_discovered(data), 1))
+            .subscribe();
         this.transporter.$nodes_status.pipe(tap(node => !node.online && this.#on_node_offline(node.node_id)), groupBy(node => node.node_id), mergeMap(grouped => grouped.pipe(debounceTime(1000))), filter(node => node.online), mergeMap(({ node_id }) => this.#self_introduce(node_id), 1))
             .subscribe();
         serviceInstanceList.pipe(filter(i => i.namespace == this.transporter.namespace), mergeMap(async ({ instance, metadata }) => {
@@ -257,106 +372,38 @@ export class SpiderMesh {
             ...node,
             online: true
         };
-        this.#linked_nodes.set(node.id, new_node);
         if (!peer_updated)
-            return await this.#self_introduce(node.id);
+            await this.#self_introduce(node.id);
+        this.#linked_nodes.set(node.id, new_node);
         for (const service_id of Object.keys(node.services)) {
-            if (!this.#remote_rpc_services.has(service_id)) {
-                this.#remote_rpc_services.set(service_id, {
+            if (!this.#remote_services.has(service_id)) {
+                this.#remote_services.set(service_id, {
                     last_call_index: -1,
                     nodes: []
                 });
             }
-            const $service = this.#remote_rpc_services.get(service_id);
+            const $service = this.#remote_services.get(service_id);
             const index = $service.nodes.findIndex(n => n.id == new_node.id);
             index >= 0 ? ($service.nodes[index] = new_node) : $service.nodes.push(new_node);
-            this.$nodes_monitor.next(node);
         }
+        this.$nodes_monitor.next(node);
     }
     #on_node_offline(id) {
-        for (const service of this.#remote_rpc_services.values()) {
+        for (const service of this.#remote_services.values()) {
             service.nodes = service.nodes.filter(node => node.id != id);
         }
-        for (const [rid, { target_node_id, $ }] of this.#rpc_queue) {
+        for (const [rid, { target_node_id, channels, observables, subscriptions }] of this.#requests) {
             if (target_node_id == id) {
-                $.error(new Error('SERVICE_OFFLINE'));
-                this.#rpc_queue.delete(rid);
+                for (const [_, $] of channels)
+                    $.error(new Error('SERVICE_OFFLINE'));
+                subscriptions.forEach(s => s.unsubscribe());
+                this.#requests.delete(rid);
             }
         }
         const node = this.#linked_nodes.get(id);
         node && this.$nodes_monitor.next({ ...node, online: false });
         this.#linked_nodes.delete(id);
     }
-    #caculate_rpc_node_id(service_name, options = {}) {
-        const current = this.#remote_rpc_services.get(service_name);
-        if (!current || current.nodes.length == 0)
-            return;
-        if (options.$node_id) {
-            if (current.nodes.some(node => node.id == options.$node_id))
-                return options.$node_id;
-            return;
-        }
-        const nodes = options.$ip ? (current
-            .nodes
-            .filter(node => node.public_ip == options.$ip || node.ip_addresses.includes(options.$ip))) : current.nodes;
-        if (nodes.length == 0)
-            return;
-        current.last_call_index = (current.last_call_index + 1) % nodes.length;
-        return nodes[current.last_call_index].id;
-    }
-    rpc(service, method, args, options) {
-        const rid = randomUUID();
-        const observable = new Observable(o => {
-            setTimeout(async () => {
-                await this.#initing;
-                const reject = (err) => {
-                    if (options.$fallback != undefined) {
-                        o.next(options.$fallback);
-                        o.complete();
-                    }
-                    else {
-                        o.error(err);
-                    }
-                };
-                of(1).pipe(mergeMap(async () => {
-                    const target_node_id = this.#caculate_rpc_node_id(service, options);
-                    if (!target_node_id)
-                        return reject(`SERVICE_NOT_RUNNING:${service}`);
-                    !options.$nevermind && this.#rpc_queue.set(rid, {
-                        args,
-                        last_ping: 0,
-                        $: o,
-                        request_time: Date.now(),
-                        timeout: options.$timeout,
-                        target_node_id
-                    });
-                    await this.publish(service, { type: 'rpc', id: rid, args, method, service }, target_node_id);
-                }), retry(options.$retry || 1), catchError(() => {
-                    reject('RETRY_EXECTED');
-                    return EMPTY;
-                })).subscribe();
-            });
-            return () => {
-                const req = this.#rpc_queue.get(rid);
-                req?.target_node_id && this.publish(service, { type: 'rpc-cancel', id: rid, args: [], method, service }, req.target_node_id);
-                this.#rpc_queue.delete(rid);
-            };
-        });
-        const $timeout = !options.$timeout ? EMPTY : timer(options.$timeout).pipe(takeUntil(observable), map(() => {
-            throw new Error('SPIDER_MESH_RPC_TIMEOUT');
-        }));
-        return Object.assign(observable, {
-            then: async (success, error) => {
-                try {
-                    const value = await firstValueFrom(merge(observable, $timeout));
-                    success(options.$safe_mode ? [null, value] : value);
-                }
-                catch (e) {
-                    options.$safe_mode ? success([e, null]) : error(e);
-                }
-            }
-        });
-    }
     async link_remote_service(factory, wait_service_online = false) {
         const service_name = factory.name;
         const omit_properties = new Set([
@@ -387,9 +434,6 @@ export class SpiderMesh {
                 typeof f[method] == 'function' && actions.add(method);
             }
         }
-        if (!this.#remote_rpc_services.has(service_name)) {
-            this.#remote_rpc_services.set(service_name, { last_call_index: -1, nodes: [] });
-        }
         wait_service_online && await this.#wait_service_online(service_name);
         return new Proxy({}, {
             get: (_, method) => {
@@ -399,16 +443,24 @@ export class SpiderMesh {
                 if (method == '$watch')
                     return () => this.$nodes_monitor.pipe(filter(node => !!node.services[service_name]));
                 if (method == '$list_nodes') {
-                    return (() => this.#remote_rpc_services.get(service_name)?.nodes.filter(node => !node.isolated).filter(node => node.online) || []);
+                    return (() => this.#remote_services.get(service_name)?.nodes.filter(node => !node.isolated).filter(node => node.online) || []);
                 }
                 if (method.startsWith('$batch_')) {
                     const real_method = method.split('$batch_')?.[1];
                     if (!real_method || !actions.has(real_method))
                         return null;
-                    const nodes = this.#remote_rpc_services.get(service_name)?.nodes.filter(node => !node.isolated) || [];
+                    const nodes = this.#remote_services.get(service_name)?.nodes.filter(node => !node.isolated) || [];
                     return (...args) => {
                         const o = new Subject();
-                        from(nodes).pipe(mergeMap(async (node) => this.rpc(service_name, real_method, args, { $node_id: node.id }))).subscribe(o);
+                        from(nodes).pipe(mergeMap(async (node) => {
+                            try {
+                                const data = await this.rpc(service_name, real_method, args, { $node_id: node.id });
+                                return { node, data };
+                            }
+                            catch (error) {
+                                return { node, error };
+                            }
+                        })).subscribe(o);
                         return o;
                     };
                 }
@@ -423,16 +475,15 @@ export class SpiderMesh {
         const $ = new Subject();
         const $$ = publish_buffer_ms ? $.pipe(bufferTime(publish_buffer_ms), filter(l => l.length > 0)) : $;
         $$.subscribe(data => this.publish(event_factory.name, data));
-        const event_hub = {
+        return {
             publish: async (data) => $.next(data),
-            listen: () => this.listen(event_factory.name)
+            listen: () => this.listen(event_factory)
         };
-        return event_hub;
     }
     async #active_local_service(instance, metadata) {
         const prototype = Object.getPrototypeOf(instance);
         const name = prototype.constructor.name;
-        this.#local_rpc_services.set(name, { instance, metadata });
+        this.#local_services.set(name, { instance, metadata });
         this.listen(name).subscribe(evt => this.#node_event_handler(evt));
         const event_subscribers = listEventSubscribers(prototype);
         for (const { event, method, buffer_ms } of event_subscribers) {
@@ -442,13 +493,18 @@ export class SpiderMesh {
         }
     }
     async #wait_service_online(service_name = 'all') {
-        if (this.#remote_rpc_services.size == 0)
-            return;
         while (true) {
-            await sleep(500);
-            const nodes = service_name == 'all' ? ([...this.#remote_rpc_services.values()].map(s => s.nodes).flat(2)) : (this.#remote_rpc_services.get(service_name)?.nodes || []);
-            if (nodes.length > 0)
-                break;
+            await sleep(1000);
+            if (service_name == 'all') {
+                if ([...this.#remote_services.values()].every(e => e.nodes.length > 0)) {
+                    return true;
+                }
+            }
+            else {
+                const nodes = this.#remote_services.get(service_name)?.nodes || [];
+                if (nodes.length > 0)
+                    return;
+            }
         }
     }
     async #active_ready_hooks(instance) {
@@ -461,15 +517,20 @@ export class SpiderMesh {
         await this.#initing;
         const event = typeof topic == 'string' ? topic : topic.name;
         const data = Array.isArray(payload) ? payload : [payload];
-        this.transporter.publish({ event, data, node_id });
+        this.transporter.publish({
+            event,
+            data,
+            node_id
+        });
     }
     listen(topic) {
         const topic_name = typeof topic == 'string' ? topic : topic.name;
         return this.transporter.listen(topic_name).pipe(map(e => {
-            if (!Array.isArray(e.data))
+            const data = e.data;
+            if (!Array.isArray(data))
                 return [];
-            return e.data.map(data => ({
-                data,
+            return data.map(data => ({
+                data: data,
                 sender_node_id: e.sender_node_id
             }));
         }), mergeAll());