lunibee 0.3.1 → 0.3.2

package/dist/rest/webhook.d.ts

@@ -1,10 +1,12 @@
 import { type RESTFileAttachment } from "./index.js";
-import type { APIEmbed, APIMessage, APIMessageComponent } from "@lunibee/types";
+import type { AllowedMentions, APIEmbed, APIMessage, APIMessageComponent } from "@lunibee/types";
+/** Where a `WebhookClient` sends: a Discord webhook `url`, or its `id` and `token`. */
 export interface WebhookClientOptions {
     id?: string;
     token?: string;
     url?: string;
 }
+/** A webhook message for `send()` and `editMessage()`; camelCase aliases (`avatarURL`, `threadId`, `allowedMentions`) are accepted beside the wire names. */
 export interface WebhookMessageOptions {
     content?: string;
     username?: string;
@@ -20,6 +22,13 @@ export interface WebhookMessageOptions {
     files?: RESTFileAttachment[];
     flags?: number;
     thread_id?: string;
+    /** Discord.js-familiar alias of `avatar_url`. */
+    avatarURL?: string;
+    /** Discord.js-familiar alias of `thread_id`. */
+    threadId?: string;
+    /** Discord.js-familiar alias of `allowed_mentions`. */
+    allowedMentions?: AllowedMentions;
+    allowed_mentions?: AllowedMentions;
 }
 /** Standalone client for sending Discord webhooks. */
 export declare class WebhookClient {
@@ -34,11 +43,14 @@ export declare class WebhookClient {
     });
     /** Sends a message to the webhook. */
     send(options: string | WebhookMessageOptions): Promise<APIMessage>;
-    /** Edits a previously sent webhook message. */
-    editMessage(messageId: string, options: string | {
-        content?: string;
-        embeds?: APIEmbed[];
+    /** Fetches a message this webhook sent (`threadId` for a message inside a thread). */
+    fetchMessage(messageId: string, options?: {
+        threadId?: string;
     }): Promise<APIMessage>;
+    /** Edits a previously sent webhook message. Takes the same options as {@link WebhookClient.send}, files included. */
+    editMessage(messageId: string, options: string | WebhookMessageOptions): Promise<APIMessage>;
     /** Deletes a previously sent webhook message. */
-    deleteMessage(messageId: string): Promise<void>;
+    deleteMessage(messageId: string, options?: {
+        threadId?: string;
+    }): Promise<void>;
 }

package/dist/sharding/bus.d.ts

@@ -55,7 +55,7 @@ export declare class ShardBus {
     /** Registers a message handler. @param type Message type. @param handler Handler callback. @returns This bus. @throws {TypeError} If type or handler is invalid. */
     on<T>(type: string, handler: ShardMessageHandler<T>): this;
     /** Removes a message handler. @param type Message type. @param handler Handler callback. @returns This bus. */
-    off<T>(type: string, handler: ShardMessageHandler<T>): this;
+    off<T>(type: string, handler: ShardMessageHandler<T> | ((data: T, message: ShardMessage<T>) => unknown)): this;
     /** Registers a listener for errors thrown or rejected by message handlers. Without one, handler errors are isolated and dropped. @param handler Error listener. @returns This bus. @throws {TypeError} If handler is invalid. */
     onError(handler: ShardBusErrorHandler): this;
     /** Removes a handler error listener. @param handler Error listener. @returns This bus. */
@@ -78,7 +78,9 @@ export declare class ShardBus {
     request<R = unknown, T = unknown>(target: number, type: string, data: T, timeoutMs?: number): Promise<R>;
     /**
      * Sends a request to every other shard and collects replies until
-     * `expected` have arrived or `timeoutMs` elapses (never rejects).
+     * `expected` have arrived or `timeoutMs` elapses. A timeout or a shard
+     * going away does not reject; a closed bus, a blank type or too many
+     * pending requests does.
      */
     broadcastRequest<R = unknown, T = unknown>(type: string, data: T, options?: {
         timeoutMs?: number;

package/dist/sharding/cluster.d.ts

@@ -287,6 +287,6 @@ export declare class ClusterManager {
      * @param timeoutMs Grace period per child before force-kill. Defaults to the configured `shutdownTimeout` (5000 ms).
      */
     shutdownAll(timeoutMs?: number): Promise<void>;
-    /** Immediately force-kills all active cluster processes and clears the cluster map. Prefer {@link shutdownAll} for a graceful stop. */
+    /** Immediately sends SIGTERM to every cluster process (no grace period, no SIGKILL escalation) and clears the cluster map. Prefer {@link shutdownAll} for a graceful stop. */
     killAll(): void;
 }

package/dist/sharding/health.d.ts

@@ -78,7 +78,7 @@ export interface ClusterHealth {
     lastReadyAt?: number;
     /** Per-shard health from the worker's last report. Empty until it reports. */
     shards: ShardHealth[];
-    /** Present when requested with `health({ metrics: true })` and the worker answered. */
+    /** Present when requested with `refreshHealth({ metrics: true })` and the worker answered. */
     metrics?: WorkerMetrics;
     /** When `shards` and `metrics` were reported (epoch ms). */
     reportedAt?: number;

package/dist/sharding/host.d.ts

@@ -20,6 +20,12 @@ export interface ClusterHostOptions {
     reconnectDelay?: number;
     /** Longest delay between reconnect attempts, in ms. Default 30,000. */
     maxReconnectDelay?: number;
+    /**
+     * Attempts `connect()` makes while the coordinator is busy (it answers
+     * "too many connections" or the hello timed out) before it gives up.
+     * Default 10. A refusal (bad secret, unknown or duplicate id) is final.
+     */
+    connectAttempts?: number;
 }
 /** What a {@link ClusterHost} emits. */
 export interface ClusterHostEvents {

package/dist/sharding/identify.d.ts

@@ -6,6 +6,8 @@ export interface IdentifyBudget {
     remaining: number;
     /** Milliseconds until `remaining` resets, counted from construction. */
     resetAfter: number;
+    /** Milliseconds between resets after that one. Discord resets the budget every 24 hours (the default). */
+    period?: number;
 }
 /** Options for an {@link IdentifyCoordinator}. */
 export interface IdentifyCoordinatorOptions {

package/dist/sharding/index.d.ts

@@ -91,6 +91,12 @@ export interface ShardManagerEvents {
     shardError: [shardId: number, error: Error];
     /** Every shard this manager owns is ready. Emitted again after a shard drops and recovers. */
     ready: [];
+    /**
+     * A shard's `Gateway` was created and has not connected yet: attach dispatch
+     * listeners here so none of its events are missed. Fires again for the new
+     * Gateways after `destroy()` + `connect()` or `reshard()`.
+     */
+    shardCreate: [shardId: number, gateway: Gateway];
     /** A shard reconnected too often too fast and is backing off (see `Gateway` `unstable`). */
     shardUnstable: [
         shardId: number,