lunibee 0.1.8 → 0.2.0

package/dist/sharding/index.js

@@ -1,4 +1,19 @@
 // @bun
+// packages/sharding/package.json
+var package_default = {
+  name: "@lunibee/sharding",
+  version: "0.2.0",
+  type: "module",
+  module: "./src/index.ts",
+  types: "./src/index.ts",
+  exports: {
+    ".": "./src/index.ts"
+  },
+  dependencies: {
+    "@lunibee/ws": "workspace:*"
+  }
+};
+
 // packages/ws/src/session.ts
 class GatewaySession {
   #state = { status: "none" };
@@ -34,6 +49,8 @@ class GatewaySession {
       return false;
     if (!Number.isInteger(sequence))
       return false;
+    if (this.#sequence !== null && sequence < this.#sequence)
+      return false;
     this.#sequence = sequence;
     return true;
   }
@@ -132,8 +149,11 @@ class GatewayHeartbeat {
     this.#clearBeatTimers();
     this.#interval = interval;
     this.#acknowledged = true;
-    this.#initialTimer = setTimeout(() => this.sendHeartbeat(), Math.random() * interval);
-    this.#timer = setInterval(() => this.sendHeartbeat(), interval);
+    this.#initialTimer = setTimeout(() => {
+      this.#initialTimer = undefined;
+      this.sendHeartbeat();
+      this.#timer = setInterval(() => this.sendHeartbeat(), interval);
+    }, Math.random() * interval);
   }
   stop() {
     this.#clearBeatTimers();
@@ -159,6 +179,8 @@ class GatewayHeartbeat {
     }, this.#options.ackTimeout);
   }
   acknowledge() {
+    if (this.#acknowledged)
+      return;
     this.#acknowledged = true;
     this.#latency = this.#now() - this.#sentAt;
     this.#clearAckTimer();
@@ -804,6 +826,7 @@ class SendBudget {
 }
 
 // packages/ws/src/index.ts
+var RESUMABLE_CLOSE_CODE = 4900;
 var DEFAULT_GATEWAY_URL = "wss://gateway.discord.gg/?v=10&encoding=json";
 
 class Gateway {
@@ -889,7 +912,7 @@ class Gateway {
     } else {
       this.#emitError(new GatewayError(`Gateway heartbeat acknowledgement timed out after ${timeout.elapsedMs}ms.`));
     }
-    this.#transport.close(1001, timeout.type === "zombie" ? "Zombie Gateway connection" : "Heartbeat timeout");
+    this.#transport.close(RESUMABLE_CLOSE_CODE, timeout.type === "zombie" ? "Zombie Gateway connection" : "Heartbeat timeout");
   }
   connect(url = DEFAULT_GATEWAY_URL) {
     if (this.state === "CLOSED" /* Closed */)
@@ -1025,7 +1048,7 @@ class Gateway {
         this.#emit("heartbeatAck", action.data);
         return;
       case "reconnect":
-        this.#transport.close(1001, "Server requested reconnect");
+        this.#transport.close(RESUMABLE_CLOSE_CODE, "Server requested reconnect");
         return;
       case "invalid-session": {
         if (!action.resumable)
@@ -1326,7 +1349,7 @@ class ClusterManager {
     const response = await fetch("https://discord.com/api/v10/gateway/bot", {
       headers: {
         Authorization: `Bot ${this.#options.token}`,
-        "User-Agent": "Lunibee/0.1.0"
+        "User-Agent": `Lunibee/${package_default.version}`
       }
     });
     if (!response.ok) {
@@ -1477,6 +1500,34 @@ class ClusterManager {
 
 // packages/sharding/src/index.ts
 var sleep2 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function needsConnection(gateway) {
+  return gateway.state === "CONNECT" /* Connect */ || gateway.state === "RECONNECT" /* Reconnect */ || gateway.state === "CLOSED" /* Closed */;
+}
+var HANDSHAKE_SENT = new Set([
+  "IDENTIFY" /* Identify */,
+  "RESUME" /* Resume */,
+  "READY" /* Ready */,
+  "DISPATCH" /* Dispatch */,
+  "HEARTBEAT" /* Heartbeat */,
+  "CLOSED" /* Closed */
+]);
+function handshakeSent(gateway, timeout) {
+  if (HANDSHAKE_SENT.has(gateway.state))
+    return Promise.resolve();
+  return new Promise((resolve) => {
+    const done = () => {
+      clearTimeout(timer);
+      gateway.off("stateChange", onState);
+      resolve();
+    };
+    const onState = (change) => {
+      if (HANDSHAKE_SENT.has(change.next))
+        done();
+    };
+    const timer = setTimeout(done, timeout);
+    gateway.on("stateChange", onState);
+  });
+}
 
 class ShardManager {
   static IDENTIFY_INTERVAL = 5000;
@@ -1489,6 +1540,7 @@ class ShardManager {
   #destroyed = false;
   #auto;
   #autoScaleTimer;
+  #gatewayInfo;
   constructor(options) {
     if (!options.token?.trim())
       throw new TypeError("A Discord bot token is required.");
@@ -1501,6 +1553,10 @@ class ShardManager {
       throw new RangeError("autoScaleInterval must be an integer of at least 1000 milliseconds.");
     if (options.spawnDelay !== undefined && (!Number.isFinite(options.spawnDelay) || options.spawnDelay < 0))
       throw new RangeError("spawnDelay must be a non-negative finite number of milliseconds.");
+    if (options.maxConcurrency !== undefined && (!Number.isInteger(options.maxConcurrency) || options.maxConcurrency < 1))
+      throw new RangeError("maxConcurrency must be a positive integer.");
+    if (options.handshakeTimeout !== undefined && (!Number.isFinite(options.handshakeTimeout) || options.handshakeTimeout < 0))
+      throw new RangeError("handshakeTimeout must be a non-negative number of milliseconds.");
     this.#auto = options.shardCount === "auto";
     this.#options = {
       spawnDelay: ShardManager.IDENTIFY_INTERVAL,
@@ -1510,10 +1566,13 @@ class ShardManager {
       this.#initialize(count);
   }
   async fetchRecommendedShardCount() {
+    return (await this.fetchGatewayInfo()).shards;
+  }
+  async fetchGatewayInfo() {
     const response = await fetch("https://discord.com/api/v10/gateway/bot", {
       headers: {
         Authorization: `Bot ${this.#options.token}`,
-        "User-Agent": "Lunibee/0.1.0"
+        "User-Agent": `Lunibee/${package_default.version}`
       }
     });
     if (!response.ok)
@@ -1521,7 +1580,17 @@ class ShardManager {
     const data = await response.json();
     if (typeof data.shards !== "number" || !Number.isInteger(data.shards) || data.shards < 1)
       throw new Error("Gateway discovery returned an invalid shard count.");
-    return data.shards;
+    const limit = data.session_start_limit;
+    const info = { shards: data.shards };
+    if (limit && typeof limit.total === "number" && typeof limit.remaining === "number" && typeof limit.reset_after === "number" && typeof limit.max_concurrency === "number")
+      info.sessionStartLimit = {
+        total: limit.total,
+        remaining: limit.remaining,
+        resetAfter: limit.reset_after,
+        maxConcurrency: Math.max(1, limit.max_concurrency)
+      };
+    this.#gatewayInfo = info;
+    return info;
   }
   async connect() {
     if (this.#autoScaleTimer) {
@@ -1529,17 +1598,25 @@ class ShardManager {
       this.#autoScaleTimer = undefined;
     }
     await this.#ensureInitialized();
-    for (const [id, shard] of this.shards) {
-      try {
-        await shard.connect();
-      } catch (error) {
+    const limit = this.#gatewayInfo?.sessionStartLimit;
+    const ids = [...this.shards].filter(([, gateway]) => needsConnection(gateway)).map(([id]) => id);
+    if (limit && limit.remaining < ids.length)
+      throw new Error(`Session start limit exhausted: ${limit.remaining} of ${limit.total} IDENTIFYs left for ${ids.length} shards; resets in ${Math.ceil(limit.resetAfter / 1000)}s.`);
+    const concurrency = Math.min(this.#options.maxConcurrency ?? limit?.maxConcurrency ?? 1, limit?.maxConcurrency ?? Infinity);
+    for (let start = 0;start < ids.length; start += concurrency) {
+      const round = ids.slice(start, start + concurrency);
+      const results = await Promise.allSettled(round.map((id) => this.shards.get(id).connect()));
+      const failed = results.findIndex((result) => result.status === "rejected");
+      if (failed !== -1) {
         this.destroy();
-        throw new Error(`Failed to connect shard ${id}.`, {
-          cause: error
+        throw new Error(`Failed to connect shard ${round[failed]}.`, {
+          cause: results[failed].reason
         });
       }
-      if (id + 1 < this.shardCount && this.#options.spawnDelay && this.#options.spawnDelay > 0)
+      if (start + concurrency < ids.length && this.#options.spawnDelay && this.#options.spawnDelay > 0) {
+        await Promise.all(round.map((id) => handshakeSent(this.shards.get(id), this.#options.handshakeTimeout ?? 15000)));
         await sleep2(this.#options.spawnDelay);
+      }
     }
     if (this.#options.autoScaleInterval && !this.#autoScaleTimer) {
       this.#autoScaleTimer = setInterval(() => {
@@ -1582,6 +1659,13 @@ class ShardManager {
   get(id) {
     return this.shards.get(id);
   }
+  health() {
+    return [...this.shards].map(([id, gateway]) => ({
+      id,
+      state: gateway.state,
+      ping: gateway.ping
+    }));
+  }
   values() {
     return [...this.shards].map(([id, gateway]) => ({ id, gateway }));
   }
@@ -1617,4 +1701,4 @@ export {
   ShardManager as ShardingManager
 };
 
-//# debugId=C1062D33C7999C8E64756E2164756E21
+//# debugId=80E4CAFE56ABED2364756E2164756E21