lunibee 0.3.2 → 0.3.3

package/dist/sharding/leader.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Leadership between several coordinators, so a standby `ClusterManager` can
+ * take over when the active one dies. Only the holder of the lock runs
+ * clusters; see `ClusterManagerOptions.leader`.
+ */
+export interface LeaderLock {
+    /**
+     * Takes the lock for `ttlMs`, or extends it when this process already
+     * holds it. Resolves `true` while this process is the leader, `false` when
+     * another one holds it. A rejection counts as "unknown".
+     */
+    acquire(ttlMs: number): Promise<boolean>;
+    /** Gives the lock up if this process holds it. */
+    release(): Promise<void>;
+}
+/** The part of a Redis client the lock uses. `Bun.RedisClient` works as it is; for ioredis pass `{ send: (c, a) => redis.call(c, ...a) }`. */
+export interface LeaderRedisClient {
+    send(command: string, args: string[]): Promise<unknown>;
+}
+/** Options for {@link RedisLeaderLock}. */
+export interface RedisLeaderLockOptions {
+    client: LeaderRedisClient;
+    /** The key every coordinator of one deployment shares. Default `lunibee:cluster:leader`. */
+    key?: string;
+    /** This coordinator's identity in the key. Default: a random UUID. Must differ between coordinators. */
+    token?: string;
+}
+/** A {@link LeaderLock} on one Redis key, with an expiry so a dead leader's lock lapses on its own. */
+export declare class RedisLeaderLock implements LeaderLock {
+    #private;
+    constructor(options: RedisLeaderLockOptions);
+    acquire(ttlMs: number): Promise<boolean>;
+    release(): Promise<void>;
+}

package/dist/sharding/remote.d.ts

@@ -62,6 +62,14 @@ export interface RemoteOptions {
     clientAddress?: (request: Request, peer: string | undefined) => string;
     /** Also run clusters on the coordinator's own machine. Default false: clusters run on the hosts only. */
     local?: boolean;
+    /**
+     * When a host is lost, restart its clusters on the connected host (or
+     * `local`) running the fewest, once the lost host has certainly fenced
+     * itself (two leases after the coordinator dropped it). They stay there
+     * when the host comes back. Default true; `false` restarts them on the
+     * same host only, so they wait for it.
+     */
+    moveClusters?: boolean;
 }
 /** A host as the coordinator sees it. */
 export interface HostStatus {
@@ -115,6 +123,16 @@ export declare class RemoteHosts {
     get port(): number | undefined;
     /** Host IDs that are connected now, sorted. */
     connected(): string[];
+    /** Whether `hostId` is connected now. */
+    isConnected(hostId: string): boolean;
+    /**
+     * When workers that ran on a lost host are certainly gone (epoch ms), or 0
+     * for a host that is connected or was never dropped. The host fences
+     * itself one lease after it last heard from the coordinator, checking
+     * every third of a lease; the coordinator sends nothing after the drop,
+     * and two leases leave room for the kill itself.
+     */
+    fencedAt(hostId: string): number;
     /** Opens the listener. Safe to call twice. */
     start(): void;
     /** Closes the listener and every host connection. */

package/dist/sharding/thread.d.ts

@@ -0,0 +1,30 @@
+import type { ChildProcess } from "node:child_process";
+import { type ResourceLimits } from "node:worker_threads";
+/** Options for {@link threadFork}. */
+export interface ThreadForkOptions {
+    /** Heap limits for each cluster thread (`worker_threads` `resourceLimits`). */
+    resourceLimits?: ResourceLimits;
+}
+/**
+ * Runs each cluster as a worker thread of the manager's process instead of a
+ * forked process: pass it as `ClusterManager`'s `fork`. Threads start faster
+ * and use less memory; a crash that takes the process down (an out-of-memory
+ * abort, a native fault) takes every cluster with it. The worker script is the
+ * same: `ShardManager`, `ShardBus` and `ClusterWorker` find the parent through
+ * `parentPort`.
+ */
+export declare function threadFork(options?: ThreadForkOptions): (script: string, env: Record<string, string | undefined>) => ChildProcess;
+/** The parent link of a cluster thread: the part of `process` a worker uses. */
+export interface ThreadEndpoint {
+    send(message: unknown): boolean;
+    on(event: string, listener: (...args: never[]) => void): ThreadEndpoint;
+    off(event: string, listener: (...args: never[]) => void): ThreadEndpoint;
+}
+/** The parent link when this code runs in a cluster thread started by {@link threadFork}, otherwise `undefined`. */
+export declare function threadEndpoint(): ThreadEndpoint | undefined;
+/** Wraps a message port as a worker endpoint. @internal */
+export declare function portEndpoint(port: {
+    postMessage(message: unknown): void;
+    on(event: "message", listener: (frame: unknown) => void): unknown;
+    off(event: "message", listener: (frame: unknown) => void): unknown;
+}): ThreadEndpoint;

package/dist/structures/index.js

@@ -164,7 +164,7 @@ class Channel extends BaseStructure {
   permissionOverwrites;
   partial;
   #context;
-  constructor(data, context, options = {}) {
+  constructor(data, context, options) {
     super(data.id);
     if (!Number.isInteger(data.type) || data.type < 0)
       throw new RangeError("A Discord channel requires a valid channel type.");
@@ -177,7 +177,7 @@ class Channel extends BaseStructure {
     this.rateLimitPerUser = data.rate_limit_per_user;
     this.position = data.position;
     this.permissionOverwrites = (data.permission_overwrites ?? []).map((overwrite) => ({ ...overwrite }));
-    this.partial = options.partial ?? false;
+    this.partial = options?.partial ?? false;
     this.#context = context;
   }
   send(options) {
@@ -2383,4 +2383,4 @@ export {
   stickerURL
 };
 
-//# debugId=E9D552024AFDACBA64756E2164756E21
+//# debugId=AAE5FFB306F1F13364756E2164756E21