seyfert 3.1.3-dev-15068780757.0 → 3.1.3-dev-15124346914.0

package/lib/client/workerclient.d.ts

@@ -1,14 +1,15 @@
-import { type DeepPartial, type MakeRequired, type When } from '../common';
+import { type Awaitable, type DeepPartial, type MakeRequired, type When } from '../common';
 import { EventHandler } from '../events';
 import type { GatewayDispatchPayload } from '../types';
 import { Shard, type ShardManagerOptions, type WorkerData } from '../websocket';
-import type { WorkerMessages, WorkerShardInfo } from '../websocket/discord/worker';
+import type { ClientHeartbeaterMessages, WorkerMessages, WorkerShardInfo } from '../websocket/discord/worker';
 import type { ManagerMessages, ManagerSpawnShards } from '../websocket/discord/workermanager';
 import type { BaseClientOptions, ServicesOptions, StartOptions } from './base';
 import { BaseClient } from './base';
 import type { Client, ClientOptions } from './client';
 import { MemberUpdateHandler } from '../websocket/discord/events/memberUpdate';
 import { PresenceUpdateHandler } from '../websocket/discord/events/presenceUpdate';
+import type { WorkerHeartbeaterMessages } from '../websocket/discord/heartbeater';
 import type { ShardData } from '../websocket/discord/shared';
 import { Collectors } from './collectors';
 import { type ClientUserStructure } from './transformers';
@@ -35,8 +36,8 @@ export declare class WorkerClient<Ready extends boolean = boolean> extends BaseC
     get workerData(): WorkerData;
     start(options?: Omit<DeepPartial<StartOptions>, 'httpConnection' | 'token' | 'connection'>): Promise<void>;
     loadEvents(dir?: string): Promise<void>;
-    postMessage(body: WorkerMessages): unknown;
-    handleManagerMessages(data: ManagerMessages): Promise<any>;
+    postMessage(body: WorkerMessages | ClientHeartbeaterMessages): unknown;
+    handleManagerMessages(data: ManagerMessages | WorkerHeartbeaterMessages): Promise<any>;
     calculateShardId(guildId: string): number;
     private generateNonce;
     private generateSendPromise;
@@ -51,8 +52,8 @@ export interface WorkerClientOptions extends BaseClientOptions {
     commands?: NonNullable<Client['options']>['commands'];
     handlePayload?: ShardManagerOptions['handlePayload'];
     gateway?: ClientOptions['gateway'];
-    postMessage?: (body: unknown) => unknown;
+    postMessage?: (body: unknown) => Awaitable<unknown>;
     /** can have perfomance issues in big bots if the client sends every event, specially in startup (false by default) */
     sendPayloadToParent?: boolean;
-    handleManagerMessages?(message: ManagerMessages): any;
+    handleManagerMessages?(message: ManagerMessages | WorkerHeartbeaterMessages): Awaitable<unknown>;
 }

package/lib/client/workerclient.js

@@ -131,6 +131,12 @@ class WorkerClient extends base_1.BaseClient {
     }
     async handleManagerMessages(data) {
         switch (data.type) {
+            case 'HEARTBEAT':
+                this.postMessage({
+                    type: 'ACK_HEARTBEAT',
+                    workerId: workerData.workerId,
+                });
+                break;
             case 'CACHE_RESULT':
                 if (this.cache.adapter instanceof cache_1.WorkerAdapter && this.cache.adapter.promises.has(data.nonce)) {
                     const cacheData = this.cache.adapter.promises.get(data.nonce);

package/lib/websocket/discord/heartbeater.d.ts

@@ -0,0 +1,17 @@
+import type { Awaitable } from '../../common';
+export type WorkerHeartbeaterMessages = SendHeartbeat;
+export type CreateHeartbeaterMessage<T extends string, D extends object = object> = {
+    type: T;
+} & D;
+export type SendHeartbeat = CreateHeartbeaterMessage<'HEARTBEAT'>;
+export declare class Heartbeater {
+    sendMethod: (workerId: number, data: WorkerHeartbeaterMessages) => Awaitable<void>;
+    interval: number;
+    store: Map<number, {
+        ack: boolean;
+        interval: NodeJS.Timeout;
+    }>;
+    constructor(sendMethod: (workerId: number, data: WorkerHeartbeaterMessages) => Awaitable<void>, interval: number);
+    register(workerId: number, recreate: (workerId: number) => Awaitable<void>): void;
+    acknowledge(workerId: number): void;
+}

package/lib/websocket/discord/heartbeater.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Heartbeater = void 0;
+class Heartbeater {
+    sendMethod;
+    interval;
+    store = new Map();
+    constructor(sendMethod, interval) {
+        this.sendMethod = sendMethod;
+        this.interval = interval;
+    }
+    register(workerId, recreate) {
+        if (this.interval <= 0)
+            return;
+        this.store.set(workerId, {
+            ack: true,
+            interval: setInterval(() => {
+                const heartbeat = this.store.get(workerId);
+                if (!heartbeat.ack) {
+                    heartbeat.ack = true;
+                    return recreate(workerId);
+                }
+                heartbeat.ack = false;
+                this.sendMethod(workerId, { type: 'HEARTBEAT' });
+            }, this.interval),
+        });
+    }
+    acknowledge(workerId) {
+        const heartbeat = this.store.get(workerId);
+        if (!heartbeat)
+            return;
+        heartbeat.ack = true;
+    }
+}
+exports.Heartbeater = Heartbeater;

package/lib/websocket/discord/shard.d.ts

@@ -23,7 +23,7 @@ export declare class Shard {
     heart: ShardHeart;
     bucket: DynamicBucket;
     offlineSendQueue: ((_?: unknown) => void)[];
-    pendingGuilds: Set<string>;
+    pendingGuilds?: Set<string>;
     options: MakeRequired<ShardOptions, 'properties' | 'ratelimitOptions' | 'reconnectTimeout' | 'connectionTimeout'>;
     isReady: boolean;
     connectionTimeout?: NodeJS.Timeout;

package/lib/websocket/discord/shard.js

@@ -24,7 +24,7 @@ class Shard {
     };
     bucket;
     offlineSendQueue = [];
-    pendingGuilds = new Set();
+    pendingGuilds;
     options;
     isReady = false;
     connectionTimeout;
@@ -217,15 +217,13 @@ class Shard {
                             clearTimeout(this.connectionTimeout);
                             this.connectionTimeout = undefined;
                             if ((0, common_1.hasIntent)(this.options.intents, 'Guilds')) {
-                                for (let i = 0; i < packet.d.guilds.length; i++) {
-                                    this.pendingGuilds.add(packet.d.guilds.at(i).id);
-                                }
+                                this.pendingGuilds = new Set(...packet.d.guilds.map(guild => guild.id));
                             }
                             this.data.resume_gateway_url = packet.d.resume_gateway_url;
                             this.data.session_id = packet.d.session_id;
                             this.offlineSendQueue.map(resolve => resolve());
                             this.options.handlePayload(this.id, packet);
-                            if (this.pendingGuilds.size === 0) {
+                            if (this.pendingGuilds?.size === 0) {
                                 this.isReady = true;
                                 this.options.handlePayload(this.id, {
                                     t: types_1.GatewayDispatchEvents.GuildsReady,
@@ -237,7 +235,7 @@ class Shard {
                         }
                         case types_1.GatewayDispatchEvents.GuildCreate:
                         case types_1.GatewayDispatchEvents.GuildDelete:
-                            if (this.pendingGuilds.delete(packet.d.id)) {
+                            if (this.pendingGuilds?.delete(packet.d.id)) {
                                 packet.t = `RAW_${packet.t}`;
                                 this.options.handlePayload(this.id, packet);
                                 if (this.pendingGuilds.size === 0) {

package/lib/websocket/discord/shared.d.ts

@@ -55,6 +55,8 @@ export interface WorkerManagerOptions extends Omit<ShardManagerOptions, 'handleP
      */
     shardsPerWorker?: number;
     workerProxy?: boolean;
+    /** @default 15000 */
+    heartbeaterInterval?: number;
     path: string;
     handlePayload?(shardId: number, workerId: number, packet: GatewayDispatchPayload): any;
     handleWorkerMessage?(message: WorkerMessages): any;

package/lib/websocket/discord/worker.d.ts

@@ -68,7 +68,9 @@ export type CustomWorkerClientMessages = {
         workerId: number;
     } & Identify<CustomWorkerClientEvents[K] extends never ? {} : CustomWorkerClientEvents[K]>>;
 };
-export type WorkerMessages = {
+export type ClientHeartbeaterMessages = ACKHeartbeat;
+export type ACKHeartbeat = CreateWorkerMessage<'ACK_HEARTBEAT'>;
+export type WorkerMessages = ClientHeartbeaterMessages | {
     [K in BaseWorkerMessage['type']]: Identify<Extract<BaseWorkerMessage, {
         type: K;
     }>>;

package/lib/websocket/discord/workermanager.d.ts

@@ -5,6 +5,7 @@ import { type Adapter } from '../../cache';
 import { type Identify, type PickPartial } from '../../common';
 import type { GatewayPresenceUpdateData, GatewaySendPayload } from '../../types';
 import { ConnectQueue } from '../structures/timeout';
+import { Heartbeater, type WorkerHeartbeaterMessages } from './heartbeater';
 import type { ShardOptions, WorkerData, WorkerManagerOptions } from './shared';
 import type { WorkerInfo, WorkerMessages, WorkerShardInfo } from './worker';
 export declare class WorkerManager extends Map<number, (ClusterWorker | WorkerThreadsWorker | {
@@ -31,6 +32,7 @@ export declare class WorkerManager extends Map<number, (ClusterWorker | WorkerTh
     rest: ApiHandler;
     reshardingWorkerQueue: (() => void)[];
     private _info?;
+    heartbeater: Heartbeater;
     constructor(options: Omit<PickPartial<WorkerManagerOptions, 'token' | 'intents' | 'info' | 'handlePayload' | 'handleWorkerMessage'>, 'resharding'> & {
         resharding?: PickPartial<NonNullable<WorkerManagerOptions['resharding']>, 'getInfo'>;
     });
@@ -52,8 +54,8 @@ export declare class WorkerManager extends Map<number, (ClusterWorker | WorkerTh
     }): Promise<number>;
     calculateShardId(guildId: string): number;
     calculateWorkerId(shardId: number): number;
-    postMessage(id: number, body: ManagerMessages): void;
-    prepareWorkers(shards: number[][], resharding?: boolean): void;
+    postMessage(id: number, body: ManagerMessages | WorkerHeartbeaterMessages): void;
+    prepareWorkers(shards: number[][], rawResharding?: boolean): void;
     createWorker(workerData: WorkerData): ClusterWorker | WorkerThreadsWorker | ({
         ready?: boolean;
     } & {

package/lib/websocket/discord/workermanager.js

@@ -13,6 +13,7 @@ const common_1 = require("../../common");
 const constants_1 = require("../constants");
 const structures_1 = require("../structures");
 const timeout_1 = require("../structures/timeout");
+const heartbeater_1 = require("./heartbeater");
 class WorkerManager extends Map {
     static prepareSpaces(options, logger) {
         logger?.info('Preparing buckets');
@@ -35,6 +36,7 @@ class WorkerManager extends Map {
     rest;
     reshardingWorkerQueue = [];
     _info;
+    heartbeater;
     constructor(options) {
         super();
         this.options = options;
@@ -46,6 +48,7 @@ class WorkerManager extends Map {
                 return oldFn(message);
             };
         }
+        this.heartbeater = new heartbeater_1.Heartbeater(this.postMessage.bind(this), options.heartbeaterInterval ?? 15e3);
     }
     setCache(adapter) {
         this.cacheAdapter = adapter;
@@ -101,7 +104,8 @@ class WorkerManager extends Map {
             return this.debugger?.error(`Worker ${id} does not exists.`);
         switch (this.options.mode) {
             case 'clusters':
-                worker.send(body);
+                if (worker.isConnected())
+                    worker.send(body);
                 break;
             case 'threads':
                 worker.postMessage(body);
@@ -111,33 +115,40 @@ class WorkerManager extends Map {
                 break;
         }
     }
-    prepareWorkers(shards, resharding = false) {
+    prepareWorkers(shards, rawResharding = false) {
         const worker_threads = (0, common_1.lazyLoadPackage)('node:worker_threads');
         if (!worker_threads)
             throw new Error('Cannot prepare workers without worker_threads.');
         for (let i = 0; i < shards.length; i++) {
+            const registerWorker = (resharding) => {
+                const worker = this.createWorker({
+                    path: this.options.path,
+                    debug: this.options.debug,
+                    token: this.options.token,
+                    shards: shards[i],
+                    intents: this.options.intents,
+                    workerId: i,
+                    workerProxy: this.options.workerProxy,
+                    totalShards: resharding ? this._info.shards : this.totalShards,
+                    mode: this.options.mode,
+                    resharding,
+                    totalWorkers: shards.length,
+                    info: {
+                        ...this.options.info,
+                        shards: this.totalShards,
+                    },
+                    compress: this.options.compress,
+                });
+                this.set(i, worker);
+            };
             const workerExists = this.has(i);
-            if (resharding || !workerExists) {
-                this[resharding ? 'reshardingWorkerQueue' : 'workerQueue'].push(() => {
-                    const worker = this.createWorker({
-                        path: this.options.path,
-                        debug: this.options.debug,
-                        token: this.options.token,
-                        shards: shards[i],
-                        intents: this.options.intents,
-                        workerId: i,
-                        workerProxy: this.options.workerProxy,
-                        totalShards: resharding ? this._info.shards : this.totalShards,
-                        mode: this.options.mode,
-                        resharding,
-                        totalWorkers: shards.length,
-                        info: {
-                            ...this.options.info,
-                            shards: this.totalShards,
-                        },
-                        compress: this.options.compress,
+            if (rawResharding || !workerExists) {
+                this[rawResharding ? 'reshardingWorkerQueue' : 'workerQueue'].push(() => {
+                    registerWorker(rawResharding);
+                    this.heartbeater.register(i, () => {
+                        this.delete(i);
+                        registerWorker(false);
                     });
-                    this.set(i, worker);
                 });
             }
         }
@@ -170,6 +181,9 @@ class WorkerManager extends Map {
                     env,
                 });
                 worker.on('message', data => this.handleWorkerMessage(data));
+                worker.on('error', err => {
+                    this.debugger?.error(`[Worker #${workerData.workerId}]`, err);
+                });
                 return worker;
             }
             case 'clusters': {
@@ -204,6 +218,9 @@ class WorkerManager extends Map {
     }
     async handleWorkerMessage(message) {
         switch (message.type) {
+            case 'ACK_HEARTBEAT':
+                this.heartbeater.acknowledge(message.workerId);
+                break;
             case 'WORKER_READY_RESHARDING':
                 {
                     this.get(message.workerId).resharded = true;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "seyfert",
-	"version": "3.1.3-dev-15068780757.0",
+	"version": "3.1.3-dev-15124346914.0",
 	"description": "The most advanced framework for discord bots",
 	"main": "./lib/index.js",
 	"module": "./lib/index.js",