@jubbio/core 1.0.0

package/dist/rest/index.d.ts

@@ -0,0 +1 @@
+export * from './REST';

package/dist/rest/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./REST"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcmVzdC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEseUNBQXVCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9SRVNUJztcclxuIl19

package/dist/sharding/ShardingManager.d.ts

@@ -0,0 +1,179 @@
+/**
+ * ShardingManager - Multi-process bot support
+ */
+import { EventEmitter } from 'events';
+import { ChildProcess } from 'child_process';
+/**
+ * Shard status
+ */
+export declare enum ShardStatus {
+    Ready = 0,
+    Connecting = 1,
+    Reconnecting = 2,
+    Idle = 3,
+    Nearly = 4,
+    Disconnected = 5,
+    WaitingForGuilds = 6,
+    Identifying = 7,
+    Resuming = 8
+}
+/**
+ * Options for ShardingManager
+ */
+export interface ShardingManagerOptions {
+    /** Total number of shards (auto if not specified) */
+    totalShards?: number | 'auto';
+    /** Specific shard IDs to spawn */
+    shardList?: number[] | 'auto';
+    /** Sharding mode */
+    mode?: 'process' | 'worker';
+    /** Respawn shards on exit */
+    respawn?: boolean;
+    /** Arguments to pass to shards */
+    shardArgs?: string[];
+    /** Arguments to pass to node */
+    execArgv?: string[];
+    /** Bot token */
+    token?: string;
+}
+/**
+ * Represents a single shard
+ */
+export declare class Shard extends EventEmitter {
+    /** The manager that spawned this shard */
+    manager: ShardingManager;
+    /** The shard ID */
+    id: number;
+    /** The child process */
+    process: ChildProcess | null;
+    /** Whether the shard is ready */
+    ready: boolean;
+    /** Shard status */
+    status: ShardStatus;
+    /** Environment variables for the shard */
+    private env;
+    constructor(manager: ShardingManager, id: number);
+    /**
+     * Spawn the shard process
+     */
+    spawn(timeout?: number): Promise<ChildProcess>;
+    /**
+     * Kill the shard process
+     */
+    kill(): void;
+    /**
+     * Respawn the shard
+     */
+    respawn(options?: {
+        delay?: number;
+        timeout?: number;
+    }): Promise<ChildProcess>;
+    /**
+     * Send a message to the shard
+     */
+    send(message: any): Promise<void>;
+    /**
+     * Evaluate code on the shard
+     */
+    eval<T>(script: string | ((client: any) => T)): Promise<T>;
+    /**
+     * Fetch a client property
+     */
+    fetchClientValue(prop: string): Promise<any>;
+    private _handleMessage;
+    private _handleExit;
+    private _handleError;
+}
+/**
+ * Manages multiple shards for large bots
+ */
+export declare class ShardingManager extends EventEmitter {
+    /** Path to the bot file */
+    file: string;
+    /** Total number of shards */
+    totalShards: number | 'auto';
+    /** List of shard IDs to spawn */
+    shardList: number[];
+    /** Sharding mode */
+    mode: 'process' | 'worker';
+    /** Whether to respawn shards */
+    respawn: boolean;
+    /** Arguments to pass to shards */
+    shardArgs: string[];
+    /** Arguments to pass to node */
+    execArgv: string[];
+    /** Bot token */
+    token?: string;
+    /** Collection of shards */
+    shards: Map<number, Shard>;
+    constructor(file: string, options?: ShardingManagerOptions);
+    /**
+     * Spawn all shards
+     */
+    spawn(options?: {
+        amount?: number | 'auto';
+        delay?: number;
+        timeout?: number;
+    }): Promise<Map<number, Shard>>;
+    /**
+     * Create a shard
+     */
+    createShard(id: number): Shard;
+    /**
+     * Fetch recommended shard count from API
+     */
+    fetchRecommendedShards(): Promise<number>;
+    /**
+     * Broadcast a message to all shards
+     */
+    broadcast(message: any): Promise<void[]>;
+    /**
+     * Broadcast an eval to all shards
+     */
+    broadcastEval<T>(script: string | ((client: any) => T)): Promise<T[]>;
+    /**
+     * Fetch a client value from all shards
+     */
+    fetchClientValues(prop: string): Promise<any[]>;
+    /**
+     * Respawn all shards
+     */
+    respawnAll(options?: {
+        shardDelay?: number;
+        respawnDelay?: number;
+        timeout?: number;
+    }): Promise<Map<number, Shard>>;
+}
+/**
+ * Shard client utilities - use in bot file
+ */
+export declare class ShardClientUtil {
+    /** The client */
+    client: any;
+    /** The shard ID */
+    id: number;
+    /** Total shard count */
+    count: number;
+    constructor(client: any);
+    /**
+     * Send a message to the parent process
+     */
+    send(message: any): Promise<void>;
+    /**
+     * Fetch a client value from all shards
+     */
+    fetchClientValues(prop: string): Promise<any[]>;
+    /**
+     * Broadcast an eval to all shards
+     */
+    broadcastEval<T>(script: string | ((client: any) => T)): Promise<T[]>;
+    /**
+     * Signal ready to the parent process
+     */
+    ready(): void;
+    /**
+     * Get the shard ID for a guild
+     */
+    static shardIdForGuildId(guildId: string, shardCount: number): number;
+}
+export default ShardingManager;

package/dist/sharding/ShardingManager.js

@@ -0,0 +1,375 @@
+"use strict";
+/**
+ * ShardingManager - Multi-process bot support
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShardClientUtil = exports.ShardingManager = exports.Shard = exports.ShardStatus = void 0;
+const events_1 = require("events");
+const child_process_1 = require("child_process");
+const path_1 = __importDefault(require("path"));
+/**
+ * Shard status
+ */
+var ShardStatus;
+(function (ShardStatus) {
+    ShardStatus[ShardStatus["Ready"] = 0] = "Ready";
+    ShardStatus[ShardStatus["Connecting"] = 1] = "Connecting";
+    ShardStatus[ShardStatus["Reconnecting"] = 2] = "Reconnecting";
+    ShardStatus[ShardStatus["Idle"] = 3] = "Idle";
+    ShardStatus[ShardStatus["Nearly"] = 4] = "Nearly";
+    ShardStatus[ShardStatus["Disconnected"] = 5] = "Disconnected";
+    ShardStatus[ShardStatus["WaitingForGuilds"] = 6] = "WaitingForGuilds";
+    ShardStatus[ShardStatus["Identifying"] = 7] = "Identifying";
+    ShardStatus[ShardStatus["Resuming"] = 8] = "Resuming";
+})(ShardStatus || (exports.ShardStatus = ShardStatus = {}));
+/**
+ * Represents a single shard
+ */
+class Shard extends events_1.EventEmitter {
+    /** The manager that spawned this shard */
+    manager;
+    /** The shard ID */
+    id;
+    /** The child process */
+    process = null;
+    /** Whether the shard is ready */
+    ready = false;
+    /** Shard status */
+    status = ShardStatus.Idle;
+    /** Environment variables for the shard */
+    env;
+    constructor(manager, id) {
+        super();
+        this.manager = manager;
+        this.id = id;
+        this.env = {
+            SHARD_ID: String(id),
+            SHARD_COUNT: String(manager.totalShards),
+            JUBBIO_TOKEN: manager.token ?? '',
+        };
+    }
+    /**
+     * Spawn the shard process
+     */
+    async spawn(timeout = 30000) {
+        if (this.process) {
+            throw new Error(`Shard ${this.id} already has a process`);
+        }
+        this.status = ShardStatus.Connecting;
+        this.process = (0, child_process_1.fork)(this.manager.file, this.manager.shardArgs, {
+            env: { ...process.env, ...this.env },
+            execArgv: this.manager.execArgv,
+        });
+        this.process.on('message', this._handleMessage.bind(this));
+        this.process.on('exit', this._handleExit.bind(this));
+        this.process.on('error', this._handleError.bind(this));
+        // Wait for ready
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                reject(new Error(`Shard ${this.id} took too long to become ready`));
+            }, timeout);
+            this.once('ready', () => {
+                clearTimeout(timer);
+                resolve(this.process);
+            });
+            this.once('disconnect', () => {
+                clearTimeout(timer);
+                reject(new Error(`Shard ${this.id} disconnected before becoming ready`));
+            });
+        });
+    }
+    /**
+     * Kill the shard process
+     */
+    kill() {
+        if (this.process) {
+            this.process.removeAllListeners();
+            this.process.kill();
+            this.process = null;
+        }
+        this.status = ShardStatus.Disconnected;
+        this.ready = false;
+    }
+    /**
+     * Respawn the shard
+     */
+    async respawn(options) {
+        this.kill();
+        if (options?.delay) {
+            await new Promise(r => setTimeout(r, options.delay));
+        }
+        return this.spawn(options?.timeout);
+    }
+    /**
+     * Send a message to the shard
+     */
+    send(message) {
+        return new Promise((resolve, reject) => {
+            if (!this.process) {
+                reject(new Error(`Shard ${this.id} has no process`));
+                return;
+            }
+            this.process.send(message, (err) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve();
+            });
+        });
+    }
+    /**
+     * Evaluate code on the shard
+     */
+    async eval(script) {
+        const _eval = typeof script === 'function' ? `(${script})(this)` : script;
+        return new Promise((resolve, reject) => {
+            const id = Date.now().toString(36) + Math.random().toString(36);
+            const handler = (message) => {
+                if (message._evalId !== id)
+                    return;
+                this.process?.off('message', handler);
+                if (message._error) {
+                    reject(new Error(message._error));
+                }
+                else {
+                    resolve(message._result);
+                }
+            };
+            this.process?.on('message', handler);
+            this.send({ _eval, _evalId: id }).catch(reject);
+        });
+    }
+    /**
+     * Fetch a client property
+     */
+    async fetchClientValue(prop) {
+        return this.eval(`this.${prop}`);
+    }
+    _handleMessage(message) {
+        if (message._ready) {
+            this.ready = true;
+            this.status = ShardStatus.Ready;
+            this.emit('ready');
+            this.manager.emit('shardReady', this.id);
+            return;
+        }
+        if (message._disconnect) {
+            this.ready = false;
+            this.status = ShardStatus.Disconnected;
+            this.emit('disconnect');
+            this.manager.emit('shardDisconnect', this.id);
+            return;
+        }
+        if (message._reconnecting) {
+            this.ready = false;
+            this.status = ShardStatus.Reconnecting;
+            this.emit('reconnecting');
+            this.manager.emit('shardReconnecting', this.id);
+            return;
+        }
+        this.emit('message', message);
+        this.manager.emit('message', this.id, message);
+    }
+    _handleExit(code, signal) {
+        this.ready = false;
+        this.status = ShardStatus.Disconnected;
+        this.process = null;
+        this.emit('death', { code, signal });
+        this.manager.emit('shardDeath', this.id, { code, signal });
+        if (this.manager.respawn) {
+            this.spawn().catch(err => {
+                this.manager.emit('shardError', this.id, err);
+            });
+        }
+    }
+    _handleError(error) {
+        this.emit('error', error);
+        this.manager.emit('shardError', this.id, error);
+    }
+}
+exports.Shard = Shard;
+/**
+ * Manages multiple shards for large bots
+ */
+class ShardingManager extends events_1.EventEmitter {
+    /** Path to the bot file */
+    file;
+    /** Total number of shards */
+    totalShards;
+    /** List of shard IDs to spawn */
+    shardList;
+    /** Sharding mode */
+    mode;
+    /** Whether to respawn shards */
+    respawn;
+    /** Arguments to pass to shards */
+    shardArgs;
+    /** Arguments to pass to node */
+    execArgv;
+    /** Bot token */
+    token;
+    /** Collection of shards */
+    shards = new Map();
+    constructor(file, options = {}) {
+        super();
+        this.file = path_1.default.resolve(file);
+        this.totalShards = options.totalShards ?? 'auto';
+        this.shardList = options.shardList === 'auto' ? [] : (options.shardList ?? []);
+        this.mode = options.mode ?? 'process';
+        this.respawn = options.respawn ?? true;
+        this.shardArgs = options.shardArgs ?? [];
+        this.execArgv = options.execArgv ?? [];
+        this.token = options.token;
+    }
+    /**
+     * Spawn all shards
+     */
+    async spawn(options) {
+        // Determine shard count
+        if (this.totalShards === 'auto' || options?.amount === 'auto') {
+            this.totalShards = await this.fetchRecommendedShards();
+        }
+        else if (options?.amount) {
+            this.totalShards = options.amount;
+        }
+        // Build shard list if not specified
+        if (this.shardList.length === 0) {
+            this.shardList = Array.from({ length: this.totalShards }, (_, i) => i);
+        }
+        // Spawn shards sequentially with delay
+        const delay = options?.delay ?? 5500;
+        for (const id of this.shardList) {
+            const shard = this.createShard(id);
+            await shard.spawn(options?.timeout);
+            if (id !== this.shardList[this.shardList.length - 1]) {
+                await new Promise(r => setTimeout(r, delay));
+            }
+        }
+        return this.shards;
+    }
+    /**
+     * Create a shard
+     */
+    createShard(id) {
+        const shard = new Shard(this, id);
+        this.shards.set(id, shard);
+        return shard;
+    }
+    /**
+     * Fetch recommended shard count from API
+     */
+    async fetchRecommendedShards() {
+        // In a real implementation, this would call the API
+        // For now, return a default
+        return 1;
+    }
+    /**
+     * Broadcast a message to all shards
+     */
+    async broadcast(message) {
+        const promises = [...this.shards.values()].map(shard => shard.send(message));
+        return Promise.all(promises);
+    }
+    /**
+     * Broadcast an eval to all shards
+     */
+    async broadcastEval(script) {
+        const promises = [...this.shards.values()].map(shard => shard.eval(script));
+        return Promise.all(promises);
+    }
+    /**
+     * Fetch a client value from all shards
+     */
+    async fetchClientValues(prop) {
+        return this.broadcastEval(`this.${prop}`);
+    }
+    /**
+     * Respawn all shards
+     */
+    async respawnAll(options) {
+        for (const shard of this.shards.values()) {
+            await shard.respawn({ delay: options?.respawnDelay, timeout: options?.timeout });
+            if (options?.shardDelay) {
+                await new Promise(r => setTimeout(r, options.shardDelay));
+            }
+        }
+        return this.shards;
+    }
+}
+exports.ShardingManager = ShardingManager;
+/**
+ * Shard client utilities - use in bot file
+ */
+class ShardClientUtil {
+    /** The client */
+    client;
+    /** The shard ID */
+    id;
+    /** Total shard count */
+    count;
+    constructor(client) {
+        this.client = client;
+        this.id = parseInt(process.env.SHARD_ID ?? '0', 10);
+        this.count = parseInt(process.env.SHARD_COUNT ?? '1', 10);
+    }
+    /**
+     * Send a message to the parent process
+     */
+    send(message) {
+        return new Promise((resolve, reject) => {
+            process.send?.(message, (err) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve();
+            });
+        });
+    }
+    /**
+     * Fetch a client value from all shards
+     */
+    async fetchClientValues(prop) {
+        return this.broadcastEval(`this.${prop}`);
+    }
+    /**
+     * Broadcast an eval to all shards
+     */
+    async broadcastEval(script) {
+        const _eval = typeof script === 'function' ? `(${script})(this)` : script;
+        return new Promise((resolve, reject) => {
+            const id = Date.now().toString(36) + Math.random().toString(36);
+            const handler = (message) => {
+                if (message._broadcastEvalId !== id)
+                    return;
+                process.off('message', handler);
+                if (message._error) {
+                    reject(new Error(message._error));
+                }
+                else {
+                    resolve(message._results);
+                }
+            };
+            process.on('message', handler);
+            this.send({ _broadcastEval: _eval, _broadcastEvalId: id }).catch(reject);
+        });
+    }
+    /**
+     * Signal ready to the parent process
+     */
+    ready() {
+        process.send?.({ _ready: true });
+    }
+    /**
+     * Get the shard ID for a guild
+     */
+    static shardIdForGuildId(guildId, shardCount) {
+        const id = BigInt(guildId);
+        return Number(id >> 22n) % shardCount;
+    }
+}
+exports.ShardClientUtil = ShardClientUtil;
+exports.default = ShardingManager;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ShardingManager.js","sourceRoot":"","sources":["../../src/sharding/ShardingManager.ts"],"names":[],"mappings":"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","sourcesContent":["/**\r\n * ShardingManager - Multi-process bot support\r\n */\r\n\r\nimport { EventEmitter } from 'events';\r\nimport { fork, ChildProcess } from 'child_process';\r\nimport path from 'path';\r\n\r\n/**\r\n * Shard status\r\n */\r\nexport enum ShardStatus {\r\n  Ready = 0,\r\n  Connecting = 1,\r\n  Reconnecting = 2,\r\n  Idle = 3,\r\n  Nearly = 4,\r\n  Disconnected = 5,\r\n  WaitingForGuilds = 6,\r\n  Identifying = 7,\r\n  Resuming = 8,\r\n}\r\n\r\n/**\r\n * Options for ShardingManager\r\n */\r\nexport interface ShardingManagerOptions {\r\n  /** Total number of shards (auto if not specified) */\r\n  totalShards?: number | 'auto';\r\n  /** Specific shard IDs to spawn */\r\n  shardList?: number[] | 'auto';\r\n  /** Sharding mode */\r\n  mode?: 'process' | 'worker';\r\n  /** Respawn shards on exit */\r\n  respawn?: boolean;\r\n  /** Arguments to pass to shards */\r\n  shardArgs?: string[];\r\n  /** Arguments to pass to node */\r\n  execArgv?: string[];\r\n  /** Bot token */\r\n  token?: string;\r\n}\r\n\r\n/**\r\n * Represents a single shard\r\n */\r\nexport class Shard extends EventEmitter {\r\n  /** The manager that spawned this shard */\r\n  public manager: ShardingManager;\r\n  /** The shard ID */\r\n  public id: number;\r\n  /** The child process */\r\n  public process: ChildProcess | null = null;\r\n  /** Whether the shard is ready */\r\n  public ready: boolean = false;\r\n  /** Shard status */\r\n  public status: ShardStatus = ShardStatus.Idle;\r\n  /** Environment variables for the shard */\r\n  private env: Record<string, string>;\r\n\r\n  constructor(manager: ShardingManager, id: number) {\r\n    super();\r\n    this.manager = manager;\r\n    this.id = id;\r\n    this.env = {\r\n      SHARD_ID: String(id),\r\n      SHARD_COUNT: String(manager.totalShards),\r\n      JUBBIO_TOKEN: manager.token ?? '',\r\n    };\r\n  }\r\n\r\n  /**\r\n   * Spawn the shard process\r\n   */\r\n  async spawn(timeout = 30000): Promise<ChildProcess> {\r\n    if (this.process) {\r\n      throw new Error(`Shard ${this.id} already has a process`);\r\n    }\r\n\r\n    this.status = ShardStatus.Connecting;\r\n\r\n    this.process = fork(this.manager.file, this.manager.shardArgs, {\r\n      env: { ...process.env, ...this.env },\r\n      execArgv: this.manager.execArgv,\r\n    });\r\n\r\n    this.process.on('message', this._handleMessage.bind(this));\r\n    this.process.on('exit', this._handleExit.bind(this));\r\n    this.process.on('error', this._handleError.bind(this));\r\n\r\n    // Wait for ready\r\n    return new Promise((resolve, reject) => {\r\n      const timer = setTimeout(() => {\r\n        reject(new Error(`Shard ${this.id} took too long to become ready`));\r\n      }, timeout);\r\n\r\n      this.once('ready', () => {\r\n        clearTimeout(timer);\r\n        resolve(this.process!);\r\n      });\r\n\r\n      this.once('disconnect', () => {\r\n        clearTimeout(timer);\r\n        reject(new Error(`Shard ${this.id} disconnected before becoming ready`));\r\n      });\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Kill the shard process\r\n   */\r\n  kill(): void {\r\n    if (this.process) {\r\n      this.process.removeAllListeners();\r\n      this.process.kill();\r\n      this.process = null;\r\n    }\r\n    this.status = ShardStatus.Disconnected;\r\n    this.ready = false;\r\n  }\r\n\r\n  /**\r\n   * Respawn the shard\r\n   */\r\n  async respawn(options?: { delay?: number; timeout?: number }): Promise<ChildProcess> {\r\n    this.kill();\r\n    if (options?.delay) {\r\n      await new Promise(r => setTimeout(r, options.delay));\r\n    }\r\n    return this.spawn(options?.timeout);\r\n  }\r\n\r\n  /**\r\n   * Send a message to the shard\r\n   */\r\n  send(message: any): Promise<void> {\r\n    return new Promise((resolve, reject) => {\r\n      if (!this.process) {\r\n        reject(new Error(`Shard ${this.id} has no process`));\r\n        return;\r\n      }\r\n      this.process.send(message, (err) => {\r\n        if (err) reject(err);\r\n        else resolve();\r\n      });\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Evaluate code on the shard\r\n   */\r\n  async eval<T>(script: string | ((client: any) => T)): Promise<T> {\r\n    const _eval = typeof script === 'function' ? `(${script})(this)` : script;\r\n    \r\n    return new Promise((resolve, reject) => {\r\n      const id = Date.now().toString(36) + Math.random().toString(36);\r\n      \r\n      const handler = (message: any) => {\r\n        if (message._evalId !== id) return;\r\n        this.process?.off('message', handler);\r\n        \r\n        if (message._error) {\r\n          reject(new Error(message._error));\r\n        } else {\r\n          resolve(message._result);\r\n        }\r\n      };\r\n      \r\n      this.process?.on('message', handler);\r\n      this.send({ _eval, _evalId: id }).catch(reject);\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Fetch a client property\r\n   */\r\n  async fetchClientValue(prop: string): Promise<any> {\r\n    return this.eval(`this.${prop}`);\r\n  }\r\n\r\n  private _handleMessage(message: any): void {\r\n    if (message._ready) {\r\n      this.ready = true;\r\n      this.status = ShardStatus.Ready;\r\n      this.emit('ready');\r\n      this.manager.emit('shardReady', this.id);\r\n      return;\r\n    }\r\n\r\n    if (message._disconnect) {\r\n      this.ready = false;\r\n      this.status = ShardStatus.Disconnected;\r\n      this.emit('disconnect');\r\n      this.manager.emit('shardDisconnect', this.id);\r\n      return;\r\n    }\r\n\r\n    if (message._reconnecting) {\r\n      this.ready = false;\r\n      this.status = ShardStatus.Reconnecting;\r\n      this.emit('reconnecting');\r\n      this.manager.emit('shardReconnecting', this.id);\r\n      return;\r\n    }\r\n\r\n    this.emit('message', message);\r\n    this.manager.emit('message', this.id, message);\r\n  }\r\n\r\n  private _handleExit(code: number, signal: string): void {\r\n    this.ready = false;\r\n    this.status = ShardStatus.Disconnected;\r\n    this.process = null;\r\n    \r\n    this.emit('death', { code, signal });\r\n    this.manager.emit('shardDeath', this.id, { code, signal });\r\n\r\n    if (this.manager.respawn) {\r\n      this.spawn().catch(err => {\r\n        this.manager.emit('shardError', this.id, err);\r\n      });\r\n    }\r\n  }\r\n\r\n  private _handleError(error: Error): void {\r\n    this.emit('error', error);\r\n    this.manager.emit('shardError', this.id, error);\r\n  }\r\n}\r\n\r\n/**\r\n * Manages multiple shards for large bots\r\n */\r\nexport class ShardingManager extends EventEmitter {\r\n  /** Path to the bot file */\r\n  public file: string;\r\n  /** Total number of shards */\r\n  public totalShards: number | 'auto';\r\n  /** List of shard IDs to spawn */\r\n  public shardList: number[];\r\n  /** Sharding mode */\r\n  public mode: 'process' | 'worker';\r\n  /** Whether to respawn shards */\r\n  public respawn: boolean;\r\n  /** Arguments to pass to shards */\r\n  public shardArgs: string[];\r\n  /** Arguments to pass to node */\r\n  public execArgv: string[];\r\n  /** Bot token */\r\n  public token?: string;\r\n  /** Collection of shards */\r\n  public shards: Map<number, Shard> = new Map();\r\n\r\n  constructor(file: string, options: ShardingManagerOptions = {}) {\r\n    super();\r\n    \r\n    this.file = path.resolve(file);\r\n    this.totalShards = options.totalShards ?? 'auto';\r\n    this.shardList = options.shardList === 'auto' ? [] : (options.shardList ?? []);\r\n    this.mode = options.mode ?? 'process';\r\n    this.respawn = options.respawn ?? true;\r\n    this.shardArgs = options.shardArgs ?? [];\r\n    this.execArgv = options.execArgv ?? [];\r\n    this.token = options.token;\r\n  }\r\n\r\n  /**\r\n   * Spawn all shards\r\n   */\r\n  async spawn(options?: {\r\n    amount?: number | 'auto';\r\n    delay?: number;\r\n    timeout?: number;\r\n  }): Promise<Map<number, Shard>> {\r\n    // Determine shard count\r\n    if (this.totalShards === 'auto' || options?.amount === 'auto') {\r\n      this.totalShards = await this.fetchRecommendedShards();\r\n    } else if (options?.amount) {\r\n      this.totalShards = options.amount;\r\n    }\r\n\r\n    // Build shard list if not specified\r\n    if (this.shardList.length === 0) {\r\n      this.shardList = Array.from({ length: this.totalShards as number }, (_, i) => i);\r\n    }\r\n\r\n    // Spawn shards sequentially with delay\r\n    const delay = options?.delay ?? 5500;\r\n    \r\n    for (const id of this.shardList) {\r\n      const shard = this.createShard(id);\r\n      await shard.spawn(options?.timeout);\r\n      \r\n      if (id !== this.shardList[this.shardList.length - 1]) {\r\n        await new Promise(r => setTimeout(r, delay));\r\n      }\r\n    }\r\n\r\n    return this.shards;\r\n  }\r\n\r\n  /**\r\n   * Create a shard\r\n   */\r\n  createShard(id: number): Shard {\r\n    const shard = new Shard(this, id);\r\n    this.shards.set(id, shard);\r\n    return shard;\r\n  }\r\n\r\n  /**\r\n   * Fetch recommended shard count from API\r\n   */\r\n  async fetchRecommendedShards(): Promise<number> {\r\n    // In a real implementation, this would call the API\r\n    // For now, return a default\r\n    return 1;\r\n  }\r\n\r\n  /**\r\n   * Broadcast a message to all shards\r\n   */\r\n  async broadcast(message: any): Promise<void[]> {\r\n    const promises = [...this.shards.values()].map(shard => shard.send(message));\r\n    return Promise.all(promises);\r\n  }\r\n\r\n  /**\r\n   * Broadcast an eval to all shards\r\n   */\r\n  async broadcastEval<T>(script: string | ((client: any) => T)): Promise<T[]> {\r\n    const promises = [...this.shards.values()].map(shard => shard.eval(script));\r\n    return Promise.all(promises);\r\n  }\r\n\r\n  /**\r\n   * Fetch a client value from all shards\r\n   */\r\n  async fetchClientValues(prop: string): Promise<any[]> {\r\n    return this.broadcastEval(`this.${prop}`);\r\n  }\r\n\r\n  /**\r\n   * Respawn all shards\r\n   */\r\n  async respawnAll(options?: {\r\n    shardDelay?: number;\r\n    respawnDelay?: number;\r\n    timeout?: number;\r\n  }): Promise<Map<number, Shard>> {\r\n    for (const shard of this.shards.values()) {\r\n      await shard.respawn({ delay: options?.respawnDelay, timeout: options?.timeout });\r\n      if (options?.shardDelay) {\r\n        await new Promise(r => setTimeout(r, options.shardDelay));\r\n      }\r\n    }\r\n    return this.shards;\r\n  }\r\n}\r\n\r\n/**\r\n * Shard client utilities - use in bot file\r\n */\r\nexport class ShardClientUtil {\r\n  /** The client */\r\n  public client: any;\r\n  /** The shard ID */\r\n  public id: number;\r\n  /** Total shard count */\r\n  public count: number;\r\n\r\n  constructor(client: any) {\r\n    this.client = client;\r\n    this.id = parseInt(process.env.SHARD_ID ?? '0', 10);\r\n    this.count = parseInt(process.env.SHARD_COUNT ?? '1', 10);\r\n  }\r\n\r\n  /**\r\n   * Send a message to the parent process\r\n   */\r\n  send(message: any): Promise<void> {\r\n    return new Promise((resolve, reject) => {\r\n      process.send?.(message, (err: Error | null) => {\r\n        if (err) reject(err);\r\n        else resolve();\r\n      });\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Fetch a client value from all shards\r\n   */\r\n  async fetchClientValues(prop: string): Promise<any[]> {\r\n    return this.broadcastEval(`this.${prop}`);\r\n  }\r\n\r\n  /**\r\n   * Broadcast an eval to all shards\r\n   */\r\n  async broadcastEval<T>(script: string | ((client: any) => T)): Promise<T[]> {\r\n    const _eval = typeof script === 'function' ? `(${script})(this)` : script;\r\n    \r\n    return new Promise((resolve, reject) => {\r\n      const id = Date.now().toString(36) + Math.random().toString(36);\r\n      \r\n      const handler = (message: any) => {\r\n        if (message._broadcastEvalId !== id) return;\r\n        process.off('message', handler);\r\n        \r\n        if (message._error) {\r\n          reject(new Error(message._error));\r\n        } else {\r\n          resolve(message._results);\r\n        }\r\n      };\r\n      \r\n      process.on('message', handler);\r\n      this.send({ _broadcastEval: _eval, _broadcastEvalId: id }).catch(reject);\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Signal ready to the parent process\r\n   */\r\n  ready(): void {\r\n    process.send?.({ _ready: true });\r\n  }\r\n\r\n  /**\r\n   * Get the shard ID for a guild\r\n   */\r\n  static shardIdForGuildId(guildId: string, shardCount: number): number {\r\n    const id = BigInt(guildId);\r\n    return Number(id >> 22n) % shardCount;\r\n  }\r\n}\r\n\r\nexport default ShardingManager;\r\n"]}

package/dist/sharding/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Sharding exports
+ */
+export * from './ShardingManager';

package/dist/sharding/index.js

@@ -0,0 +1,21 @@
+"use strict";
+/**
+ * Sharding exports
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./ShardingManager"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc2hhcmRpbmcvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOztHQUVHOzs7Ozs7Ozs7Ozs7Ozs7O0FBRUgsb0RBQWtDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXHJcbiAqIFNoYXJkaW5nIGV4cG9ydHNcclxuICovXHJcblxyXG5leHBvcnQgKiBmcm9tICcuL1NoYXJkaW5nTWFuYWdlcic7XHJcbiJdfQ==