seyfert 4.5.0 → 5.0.0

package/lib/websocket/discord/socket/custom.js

@@ -182,6 +182,10 @@ class SeyfertWebSocket {
         this.socket?.removeAllListeners();
         this.socket?.destroy();
         this.socket = undefined;
+        for (const [, promise] of this.__promises) {
+            promise.reject(new Error('WebSocket closed'));
+        }
+        this.__promises.clear();
         if (this.__closeCalled)
             return;
         this.#emitClose(this.__lastError ?? {
@@ -287,6 +291,7 @@ class SeyfertWebSocket {
         })
             .finally(() => {
             clearTimeout(timeout);
+            this.__promises.delete(id);
         });
     }
     #randomUUID() {

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

@@ -1,6 +1,7 @@
 import type { ApiRequestOptions, CustomWorkerClientEvents, HttpMethods } from '../..';
 import type { Identify } from '../../common';
 import type { GatewayDispatchPayload } from '../../types';
+export declare const WORKER_TIMEOUT_MS = 60000;
 export interface WorkerShardInfo {
     open: boolean;
     shardId: number;

package/lib/websocket/discord/worker.js

@@ -1,2 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.WORKER_TIMEOUT_MS = void 0;
+exports.WORKER_TIMEOUT_MS = 60_000;

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

@@ -1,4 +1,4 @@
-import { type Worker as ClusterWorker } from 'node:cluster';
+import cluster, { type Worker as ClusterWorker } from 'node:cluster';
 import type { Worker as WorkerThreadsWorker } from 'node:worker_threads';
 import { ApiHandler, type CustomWorkerManagerEvents, Logger, type UsingClient, type WorkerClient } from '../..';
 import { type Adapter } from '../../cache';
@@ -7,7 +7,22 @@ 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';
+import { type WorkerInfo, type WorkerMessages, type WorkerShardInfo } from './worker';
+type WorkerManagerConstructorOptionalKeys = 'token' | 'intents' | 'info' | 'handlePayload' | 'handleWorkerMessage';
+type WorkerManagerConstructorOptions = WorkerManagerOptions extends infer Options ? Options extends WorkerManagerOptions ? Omit<Options, WorkerManagerConstructorOptionalKeys | 'resharding'> & Partial<Pick<Options, WorkerManagerConstructorOptionalKeys>> & {
+    resharding?: PickPartial<NonNullable<WorkerManagerOptions['resharding']>, 'getInfo'>;
+} : never : never;
+type WorkerManagerNativeOptions = Exclude<WorkerManagerOptions, {
+    mode: 'custom';
+}>;
+type WorkerManagerCustomOptions = Extract<WorkerManagerOptions, {
+    mode: 'custom';
+}>;
+type WorkerManagerRuntimeOptionalKeys = 'adapter' | 'handleWorkerMessage' | 'handlePayload' | 'getRC';
+type WorkerManagerCustomRuntimeOptionalKeys = 'handleWorkerMessage' | 'handlePayload' | 'getRC';
+type WorkerManagerRuntimeOptions = PickPartial<Required<WorkerManagerNativeOptions>, WorkerManagerRuntimeOptionalKeys> | (PickPartial<Required<Omit<WorkerManagerCustomOptions, 'path'>>, WorkerManagerCustomRuntimeOptionalKeys> & {
+    path?: string;
+});
 export declare class WorkerManager extends Map<number, (ClusterWorker | WorkerThreadsWorker | {
     ready?: boolean;
 }) & {
@@ -20,7 +35,7 @@ export declare class WorkerManager extends Map<number, (ClusterWorker | WorkerTh
         shardEnd: number;
         shardsPerWorker: number;
     }, logger?: Logger): number[][];
-    options: PickPartial<Required<WorkerManagerOptions>, 'adapter' | 'handleWorkerMessage' | 'handlePayload' | 'getRC'>;
+    options: WorkerManagerRuntimeOptions;
     debugger?: Logger;
     connectQueue: ConnectQueue;
     workerQueue: (() => void)[];
@@ -33,9 +48,7 @@ export declare class WorkerManager extends Map<number, (ClusterWorker | WorkerTh
     reshardingWorkerQueue: (() => void)[];
     private _info?;
     heartbeater: Heartbeater;
-    constructor(options: Omit<PickPartial<WorkerManagerOptions, 'token' | 'intents' | 'info' | 'handlePayload' | 'handleWorkerMessage'>, 'resharding'> & {
-        resharding?: PickPartial<NonNullable<WorkerManagerOptions['resharding']>, 'getInfo'>;
-    });
+    constructor(options: WorkerManagerConstructorOptions);
     setCache(adapter: Adapter): void;
     setRest(rest: ApiHandler): void;
     get remaining(): number;
@@ -56,18 +69,19 @@ export declare class WorkerManager extends Map<number, (ClusterWorker | WorkerTh
     calculateWorkerId(shardId: number): number;
     postMessage(id: number, body: ManagerMessages | WorkerHeartbeaterMessages): void;
     prepareWorkers(shards: number[][], rawResharding?: boolean): void;
-    createWorker(workerData: WorkerData): ClusterWorker | WorkerThreadsWorker | ({
+    createWorker(workerData: WorkerData): WorkerThreadsWorker | ({
         ready?: boolean;
     } & {
         ready?: boolean;
         disconnected?: boolean;
         resharded?: boolean;
-    });
+    }) | cluster.Worker;
     spawn(workerId: number, shardId: number, resharding?: boolean): void;
     handleWorkerMessage(message: WorkerMessages): Promise<void>;
     private generateNonce;
     private generateSendPromise;
-    send(data: GatewaySendPayload, shardId: number): Promise<true>;
+    send(data: GatewaySendPayload, shardId: number): Promise<boolean>;
+    private resolveSendPayload;
     getShardInfo(shardId: number): Promise<WorkerShardInfo>;
     getWorkerInfo(workerId: number): Promise<WorkerInfo>;
     tellWorker<R, V extends Record<string, unknown>>(workerId: number, func: (_: WorkerClient & UsingClient, vars: V) => R, vars: V): Promise<R>;
@@ -80,11 +94,11 @@ type CreateManagerMessage<T extends string, D extends object = object> = {
 } & D;
 export type ManagerAllowConnect = CreateManagerMessage<'ALLOW_CONNECT', {
     shardId: number;
-    presence: GatewayPresenceUpdateData;
+    presence?: GatewayPresenceUpdateData;
 }>;
 export type ManagerAllowConnectResharding = CreateManagerMessage<'ALLOW_CONNECT_RESHARDING', {
     shardId: number;
-    presence: GatewayPresenceUpdateData;
+    presence?: GatewayPresenceUpdateData;
 }>;
 export type ManagerWorkerAlreadyExistsResharding = CreateManagerMessage<'WORKER_ALREADY_EXISTS_RESHARDING'>;
 export type ManagerSpawnShards = CreateManagerMessage<'SPAWN_SHARDS', Pick<ShardOptions, 'info' | 'properties' | 'compress'>>;

package/lib/websocket/discord/workermanager.js

@@ -14,6 +14,7 @@ const constants_1 = require("../constants");
 const structures_1 = require("../structures");
 const timeout_1 = require("../structures/timeout");
 const heartbeater_1 = require("./heartbeater");
+const worker_1 = require("./worker");
 class WorkerManager extends Map {
     static prepareSpaces(options, logger) {
         logger?.info('Preparing buckets');
@@ -39,7 +40,8 @@ class WorkerManager extends Map {
     heartbeater;
     constructor(options) {
         super();
-        this.options = options;
+        // The constructor permits runtime config values that start() fills before use.
+        this.options = { mode: 'threads', ...options };
         this.cacheAdapter = new cache_1.MemoryAdapter();
         if (this.options.handleWorkerMessage) {
             const oldFn = this.handleWorkerMessage.bind(this);
@@ -90,12 +92,28 @@ class WorkerManager extends Map {
             });
         }
         const data = await this.getWorkerInfo(id);
+        if (!data.shards.length)
+            return 0;
         return data.shards.reduce((acc, prv) => acc + prv.latency, 0) / data.shards.length;
     }
     calculateShardId(guildId) {
         return Number((BigInt(guildId) >> 22n) % BigInt(this.totalShards));
     }
     calculateWorkerId(shardId) {
+        if (shardId < this.shardStart || shardId >= this.shardEnd) {
+            throw new common_1.SeyfertError('INVALID_SHARD_ID', {
+                metadata: {
+                    ...{
+                        shardId,
+                        shardStart: this.shardStart,
+                        shardEnd: this.shardEnd,
+                        shardsPerWorker: this.shardsPerWorker,
+                        totalWorkers: this.totalWorkers,
+                    },
+                    detail: 'Invalid shardId',
+                },
+            });
+        }
         const workerId = Math.floor((shardId - this.shardStart) / this.shardsPerWorker);
         if (workerId >= this.totalWorkers) {
             throw new common_1.SeyfertError('INVALID_SHARD_ID', {
@@ -138,7 +156,7 @@ class WorkerManager extends Map {
         for (let i = 0; i < shards.length; i++) {
             const registerWorker = (resharding) => {
                 const worker = this.createWorker({
-                    path: this.options.path,
+                    path: this.options.path ?? '',
                     debug: this.options.debug,
                     token: this.options.token,
                     shards: shards[i],
@@ -156,15 +174,19 @@ class WorkerManager extends Map {
                     compress: this.options.compress,
                 });
                 this.set(i, worker);
+                return i;
+            };
+            const registerWorkerHeartbeat = (workerId, resharding) => {
+                this.heartbeater.register(workerId, deadWorkerId => {
+                    this.heartbeater.unregister(deadWorkerId);
+                    this.delete(deadWorkerId);
+                    registerWorkerHeartbeat(registerWorker(resharding), resharding);
+                });
             };
             const workerExists = this.has(i);
             if (rawResharding || !workerExists) {
                 this[rawResharding ? 'reshardingWorkerQueue' : 'workerQueue'].push(() => {
-                    registerWorker(rawResharding);
-                    this.heartbeater.register(i, () => {
-                        this.delete(i);
-                        registerWorker(false);
-                    });
+                    registerWorkerHeartbeat(registerWorker(rawResharding), rawResharding);
                 });
             }
         }
@@ -462,7 +484,7 @@ class WorkerManager extends Map {
             const timeout = setTimeout(() => {
                 this.promises.delete(nonce);
                 rej(new common_1.SeyfertError('WORKER_TIMEOUT', { metadata: { ...{ nonce }, detail: message } }));
-            }, 60e3);
+            }, worker_1.WORKER_TIMEOUT_MS);
             this.promises.set(nonce, { resolve: res, timeout });
         });
     }
@@ -472,15 +494,24 @@ class WorkerManager extends Map {
         if (!worker) {
             throw new common_1.SeyfertError('INTERNAL_ERROR', { metadata: { detail: `Worker #${workerId} doesn't exist` } });
         }
+        const payload = await this.resolveSendPayload(shardId, data);
+        if (!payload)
+            return false;
         const nonce = this.generateNonce();
         this.postMessage(workerId, {
             type: 'SEND_PAYLOAD',
             shardId,
             nonce,
-            ...data,
+            ...payload,
         });
         return this.generateSendPromise(nonce, 'Shard send payload timeout');
     }
+    async resolveSendPayload(shardId, payload) {
+        const result = await this.options.handleSendPayload?.(shardId, payload);
+        if (result === null)
+            return null;
+        return result ?? payload;
+    }
     async getShardInfo(shardId) {
         const workerId = this.calculateWorkerId(shardId);
         const worker = this.has(workerId);
@@ -521,7 +552,7 @@ class WorkerManager extends Map {
         const rc = (await this.options.getRC?.()) ??
             (await base_1.BaseClient.prototype.getRC());
         this.options.debug ||= rc.debug ?? false;
-        this.options.intents ||= rc.intents ?? 0;
+        this.options.intents ??= rc.intents ?? 0;
         this.options.token ??= rc.token;
         this.rest ??= new __1.ApiHandler({
             token: this.options.token,

package/package.json

@@ -1,7 +1,8 @@
 {
 	"name": "seyfert",
-	"version": "4.5.0",
+	"version": "5.0.0",
 	"description": "The most advanced framework for discord bots",
+	"packageManager": "pnpm@11.11.0",
 	"main": "./lib/index.js",
 	"module": "./lib/index.js",
 	"types": "./lib/index.d.ts",
@@ -16,19 +17,20 @@
 		"format": "biome format --write ./src",
 		"check-h": "biome check --write ./src",
 		"check": "biome check --verbose --write --no-errors-on-unmatched ./src",
-		"test": "vitest run --config ./tests/vitest.config.mts ./tests/"
+		"test:types": "pnpm run build && tsc --noEmit --project tests/tsconfig.json",
+		"test": "pnpm run test:types && vitest run --config ./tests/vitest.config.mts ./tests/"
 	},
 	"author": "MARCROCK22",
 	"license": "MIT",
 	"devDependencies": {
-		"@biomejs/biome": "2.3.4",
-		"@changesets/cli": "^2.29.7",
-		"@commitlint/cli": "^19.8.1",
-		"@commitlint/config-conventional": "^19.8.1",
-		"@types/node": "^24.10.0",
+		"@biomejs/biome": "2.5.3",
+		"@changesets/cli": "^2.31.0",
+		"@commitlint/cli": "^21.2.1",
+		"@commitlint/config-conventional": "^21.2.0",
+		"@types/node": "^26.1.1",
 		"husky": "^9.1.7",
-		"typescript": "^5.9.3",
-		"vitest": "^3.2.4"
+		"typescript": "^6.0.3",
+		"vitest": "^4.1.10"
 	},
 	"homepage": "https://seyfert.dev",
 	"repository": {
@@ -63,11 +65,5 @@
 			"name": "David",
 			"url": "https://github.com/Drylozu"
 		}
-	],
-	"pnpm": {
-		"onlyBuiltDependencies": [
-			"@biomejs/biome",
-			"esbuild"
-		]
-	}
+	]
 }