lunibee 0.3.1 → 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

@@ -40,12 +40,36 @@ export interface RemoteOptions {
      * a shard never runs in two places. Default 15,000.
      */
     lease?: number;
-    /** Milliseconds a new connection has to authenticate before it is closed. Default 10,000. */
+    /** Milliseconds a new connection has to authenticate before it is closed. Default 3,000. */
     helloTimeout?: number;
-    /** Most connections that may be waiting to authenticate at once; more are closed. Default 16. */
+    /**
+     * Most connections that may be waiting to authenticate at once. When full,
+     * the one that has waited longest is closed to make room: a host answers
+     * the challenge within a round trip, a connection that holds a slot idle
+     * does not. Default 16.
+     */
     maxUnauthenticated?: number;
+    /** The same limit for one client address (see `clientAddress`). Default 4. */
+    maxUnauthenticatedPerAddress?: number;
+    /** New connections one client address may open per second; more are refused. Default 10. */
+    connectionsPerSecond?: number;
+    /**
+     * The client address the per-address limits count by. Default: the peer
+     * address of the TCP connection. Behind a TLS proxy every peer is the
+     * proxy, so return the client address the proxy forwards (only from a
+     * header your proxy sets and overwrites).
+     */
+    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 {
@@ -99,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/supervisor.d.ts

@@ -4,7 +4,7 @@ export interface SupervisorOptions {
     restartDelay?: number;
     /** Each further crash in the window multiplies the delay by this (default 1: a fixed delay). */
     backoff?: number;
-    /** The longest delay (default 5 minutes). */
+    /** The longest delay, jitter included (default 5 minutes). */
     maxDelay?: number;
     /** Random spread added to each delay, as a fraction of it (0-1, default 0). */
     jitter?: number;

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/sharding/transport.d.ts

@@ -28,14 +28,15 @@ export interface IpcEndpoint {
     on(event: "message", listener: (message: unknown) => void): unknown;
     off(event: "message", listener: (message: unknown) => void): unknown;
 }
-/**
- * Forked clusters: a worker `send()`s to its parent, and the parent
- * ({@link ClusterManager}) relays to every other worker. Selected
- * automatically in a worker forked by `ClusterManager`.
- */
 export declare class IpcTransport implements ShardBusTransport {
     #private;
     constructor(endpoint?: IpcEndpoint);
+    /**
+     * Sends to the parent, which relays to other clusters, and delivers to the
+     * other buses in this process: the parent never sends a message back to the
+     * cluster it came from, so without this a shard could not reach a shard in
+     * its own worker. Each bus drops what is not addressed to it.
+     */
     post(message: ShardMessage): void;
     onMessage(listener: (message: ShardMessage) => void): void;
     onPeerDown(listener: (shardIds: readonly number[]) => void): void;

package/dist/sharding/worker.d.ts

@@ -27,7 +27,17 @@ export declare class ClusterWorker {
     /** Forgets the process-wide worker (tests). */
     static reset(): void;
     readonly context: ClusterContext;
-    constructor(context: ClusterContext, endpoint?: WorkerEndpoint);
+    constructor(context: ClusterContext, endpoint?: WorkerEndpoint, options?: {
+        /**
+         * Exit when the parent's IPC channel closes. Without a parent
+         * nothing coordinates IDENTIFY or fences this process, and its
+         * Gateway sessions would keep running beside a replacement.
+         * Default: true for the real process, false for an injected endpoint.
+         */
+        exitOnParentLoss?: boolean;
+        /** Replaces `process.exit`; for tests. */
+        exit?: (code: number) => void;
+    });
     /** The gate to use when the parent coordinates IDENTIFY, otherwise `undefined`. */
     get identifyGate(): IdentifyGate | undefined;
     /** Tells the parent every shard of this process finished its handshake. */

package/dist/structures/base.d.ts

@@ -11,6 +11,7 @@ export declare class BaseStructure {
     /** Returns the timestamp this snowflake was created at. */
     get createdAt(): Date;
 }
+/** What a structure uses to act on Discord (send, edit, fetch, compute permissions). `Client` supplies it; tests can supply their own. */
 export interface ResourceContext {
     sendMessage(channelId: string, options: MessageCreateOptions): Promise<import("./index.js").Message>;
     editMessage(channelId: string, messageId: string, options: MessageEditOptions): Promise<import("./index.js").Message>;
@@ -29,7 +30,9 @@ export interface ResourceContext {
      * (with overwrites) when a channel ID is given. Null when the guild (or
      * channel) is not cached.
      */
-    memberPermissions?(guildId: string, memberId: string, roleIds: readonly string[], channelId?: string, timedOutUntil?: Date | null): import("@lunibee/core").PermissionSet | null;
+    /** The cached channel, when the client has a complete one (not a partial placeholder). */
+    cachedChannel?(channelId: string): Channel | undefined;
+    memberPermissions?(guildId: string, memberId: string, roleIds: readonly string[], channelId?: string, timedOutUntil?: Date | null): import("./permissions.js").PermissionSet | null;
     kickMember?(guildId: string, userId: string, reason?: string): Promise<void>;
     banMember?(guildId: string, userId: string, options?: {
         reason?: string;
@@ -49,7 +52,7 @@ export interface ResourceContext {
  * Permissions to change on one overwrite: `true` allows, `false` denies,
  * `null` goes back to inheriting. Permissions not named keep their state.
  */
-export type PermissionOverwriteChanges = Partial<Record<import("@lunibee/core").PermissionName, boolean | null>>;
+export type PermissionOverwriteChanges = Partial<Record<import("./permissions.js").PermissionName, boolean | null>>;
 export declare const CDN_BASE = "https://cdn.discordapp.com";
 /** Options for CDN image URLs. */
 export interface ImageURLOptions {
@@ -94,8 +97,16 @@ export declare class Channel extends BaseStructure {
     position?: number;
     /** Role and member permission overwrites (empty for DMs and when not provided). */
     permissionOverwrites: import("@lunibee/types").APIOverwrite[];
-    /** Creates a channel structure from Discord channel data. */
-    constructor(data: import("@lunibee/types").APIChannel, context?: ResourceContext);
+    /**
+     * A placeholder built from a message's `channel_id`, not from channel
+     * data: its `type`, `name`, `parentId` and `permissionOverwrites` are not
+     * the real channel's, so nothing may decide access from them.
+     */
+    partial: boolean;
+    /** Creates a channel structure from Discord channel data. `options.partial` marks a placeholder. */
+    constructor(data: import("@lunibee/types").APIChannel, context?: ResourceContext, options?: {
+        partial?: boolean;
+    });
     /** Sends a message to this channel. @param options Message payload. @returns The created message. @throws {Error} If the channel is not attached to a client. */
     send(options: MessageCreateOptions): Promise<import("./index.js").Message>;
     /** Edits this channel. @param options Channel fields to change. @returns The updated channel. @throws {Error} If the channel is not attached to a client. */
@@ -125,7 +136,7 @@ export declare class Channel extends BaseStructure {
     get kind(): ChannelKind | UnknownChannelKind;
     /**
      * Whether this channel is one of `kinds`, narrowing its type to match.
-     * @example if (channel.is("text", "announcement")) await channel.send("hi");
+     * @example if (channel.is("text", "announcement")) await channel.send({ content: "hi" });
      */
     is<K extends ChannelKind | UnknownChannelKind>(...kinds: K[]): this is ChannelOfKind<K>;
     /**

package/dist/structures/index.d.ts

@@ -116,4 +116,4 @@ export * from "./interactions.js";
 export { Embed } from "./embed.js";
 export { AuditLog, AuditLogEntry, type AuditLogAutoModInfo, type AuditLogInfo, type AuditLogInfoByType, type AuditLogOverwriteInfo, type AuditLogQuery, } from "./audit-log.js";
 export { Sticker, stickerURL } from "./sticker.js";
-export { PermissionsBitField } from "@lunibee/core";
+export { Permission, Permissions, PermissionFlagsBits, PermissionSet, PermissionsBitField, PermissionOverwriteEnum, computePermissions, type PermissionContext, type PermissionOverwrite, type PermissionRole, type PermissionName, type PermissionResolvable, } from "./permissions.js";

package/dist/structures/index.js

@@ -162,8 +162,9 @@ class Channel extends BaseStructure {
   rateLimitPerUser;
   position;
   permissionOverwrites;
+  partial;
   #context;
-  constructor(data, context) {
+  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.");
@@ -176,6 +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.#context = context;
   }
   send(options) {
@@ -366,7 +368,12 @@ class Guild extends BaseStructure {
   }
 }
 
-// packages/core/src/permissions.ts
+// packages/structures/src/permissions.ts
+var PermissionOverwriteEnum;
+((PermissionOverwriteEnum) => {
+  PermissionOverwriteEnum[PermissionOverwriteEnum["Role"] = 0] = "Role";
+  PermissionOverwriteEnum[PermissionOverwriteEnum["Member"] = 1] = "Member";
+})(PermissionOverwriteEnum ||= {});
 var Permission = {
   createInstantInvite: 1n << 0n,
   kickMembers: 1n << 1n,
@@ -648,6 +655,15 @@ class PermissionSet {
   get useExternalApps() {
     return (this.bitfield & Permission.useExternalApps) === Permission.useExternalApps;
   }
+  get setVoiceChannelStatus() {
+    return (this.bitfield & Permission.setVoiceChannelStatus) === Permission.setVoiceChannelStatus;
+  }
+  get pinMessages() {
+    return (this.bitfield & Permission.pinMessages) === Permission.pinMessages;
+  }
+  get bypassSlowmode() {
+    return (this.bitfield & Permission.bypassSlowmode) === Permission.bypassSlowmode;
+  }
   has(...permissions) {
     if (permissions.length === 1) {
       const p = permissions[0];
@@ -750,94 +766,38 @@ class PermissionsBitField extends PermissionSet {
   }
 }
 var ALL_PERMISSIONS = Object.values(Permission).reduce((bits, bit) => bits | bit, 0n);
-// packages/builders/src/components.ts
-var IS_COMPONENTS_V2 = 1 << 15;
-// packages/builders/src/commands.ts
-var MAX_SAFE = Number.MAX_SAFE_INTEGER;
-// packages/utils/src/args.ts
-var TRUE_WORDS = new Set([
-  "true",
-  "yes",
-  "y",
-  "on",
-  "1",
-  "enable",
-  "enabled"
-]);
-var FALSE_WORDS = new Set([
-  "false",
-  "no",
-  "n",
-  "off",
-  "0",
-  "disable",
-  "disabled"
-]);
-// packages/collection/src/index.ts
-var mapGet = Map.prototype.get;
-var mapHas = Map.prototype.has;
-// packages/rest/package.json
-var package_default = {
-  name: "@lunibee/rest",
-  version: "0.3.1",
-  type: "module",
-  module: "./src/index.ts",
-  types: "./src/index.ts",
-  exports: {
-    ".": "./src/index.ts"
-  },
-  dependencies: {
-    "@lunibee/types": "workspace:*"
-  }
-};
-
-// packages/rest/src/index.ts
-var LIBRARY_VERSION = package_default.version;
-var LIBRARY_URL = "https://github.com/Ekretos/lunibee";
-var USER_AGENT = `DiscordBot (${LIBRARY_URL}, ${LIBRARY_VERSION})`;
-var REQUEST_DATA_KEYS = new Set([
-  "body",
-  "files",
-  "query",
-  "headers",
-  "reason",
-  "auth",
-  "signal"
-]);
-// packages/managers/src/index.ts
-var BULK_DELETE_MAX_AGE_MS = 14 * 24 * 60 * 60000;
-
-// packages/ws/src/close-codes.ts
-var GatewayCloseCodes = {
-  UnknownError: 4000,
-  UnknownOpcode: 4001,
-  DecodeError: 4002,
-  NotAuthenticated: 4003,
-  AuthenticationFailed: 4004,
-  AlreadyAuthenticated: 4005,
-  InvalidSeq: 4007,
-  RateLimited: 4008,
-  SessionTimedOut: 4009,
-  InvalidShard: 4010,
-  ShardingRequired: 4011,
-  InvalidAPIVersion: 4012,
-  InvalidIntents: 4013,
-  DisallowedIntents: 4014
-};
+var bits = (value) => new PermissionSet(value).bitfield;
+function computePermissions(context) {
+  if (context.ownerId !== undefined && context.ownerId === context.memberId)
+    return new PermissionSet(ALL_PERMISSIONS);
+  const roles = new Map(context.roles.map((role) => [role.id, role]));
+  let base = bits(roles.get(context.guildId)?.permissions ?? 0n);
+  for (const id of context.memberRoleIds)
+    base |= bits(roles.get(id)?.permissions ?? 0n);
+  if (base & Permission.administrator)
+    return new PermissionSet(ALL_PERMISSIONS);
+  const overwrites = context.overwrites ?? [];
+  const everyone = overwrites.find((o) => o.id === context.guildId);
+  if (everyone)
+    base = base & ~bits(everyone.deny) | bits(everyone.allow);
+  const memberRoles = new Set(context.memberRoleIds);
+  let allow = 0n;
+  let deny = 0n;
+  for (const overwrite of overwrites)
+    if (overwrite.type === 0 /* Role */ && overwrite.id !== context.guildId && memberRoles.has(overwrite.id)) {
+      allow |= bits(overwrite.allow);
+      deny |= bits(overwrite.deny);
+    }
+  base = base & ~deny | allow;
+  const member = overwrites.find((o) => o.type === 1 /* Member */ && o.id === context.memberId);
+  if (member)
+    base = base & ~bits(member.deny) | bits(member.allow);
+  const until = context.timedOutUntil instanceof Date ? context.timedOutUntil.getTime() : context.timedOutUntil ?? 0;
+  if (until > Date.now())
+    base &= Permission.viewChannel | Permission.readMessageHistory;
+  return new PermissionSet(base);
+}
 
-// packages/ws/src/reconnect.ts
-var FATAL_CLOSE_CODES = [
-  GatewayCloseCodes.AuthenticationFailed,
-  GatewayCloseCodes.InvalidShard,
-  GatewayCloseCodes.ShardingRequired,
-  GatewayCloseCodes.InvalidAPIVersion,
-  GatewayCloseCodes.InvalidIntents,
-  GatewayCloseCodes.DisallowedIntents
-];
-var IDENTIFY_CLOSE_CODES = [
-  GatewayCloseCodes.InvalidSeq,
-  GatewayCloseCodes.SessionTimedOut
-];
 // packages/structures/src/resources.ts
 function toDateOrNull(value) {
   if (!value)
@@ -2243,7 +2203,7 @@ class Message extends BaseStructure {
       user: data.member.user ?? data.author,
       guild_id: data.guild_id
     }, context) : null;
-    this.channel = new Channel({ id: data.channel_id, type: 0, guild_id: data.guild_id }, context);
+    this.channel = context?.cachedChannel?.(data.channel_id) ?? new Channel({ id: data.channel_id, type: 0, guild_id: data.guild_id }, context, { partial: true });
   }
   get embedsSuppressed() {
     return (this.flags & 4) !== 0;
@@ -2400,6 +2360,11 @@ export {
   NewsChannel,
   OnboardingPrompt,
   OnboardingPromptOption,
+  Permission,
+  PermissionFlagsBits,
+  PermissionOverwriteEnum,
+  PermissionSet,
+  Permissions,
   PermissionsBitField,
   Role,
   StageChannel,
@@ -2412,9 +2377,10 @@ export {
   WebhookEnum,
   WelcomeScreenChannel,
   cdnURL,
+  computePermissions,
   createChannel,
   createInteraction,
   stickerURL
 };
 
-//# debugId=1F2A9DC9E180B64C64756E2164756E21
+//# debugId=AAE5FFB306F1F13364756E2164756E21