@wolfstar/plugin-sharder 0.0.0

package/dist/esm/index.js

@@ -0,0 +1,3491 @@
+import { Result, Result as Result$1 } from "@sapphire/result";
+import { EventEmitter } from "node:events";
+import { Worker, isMainThread, parentPort, threadId, workerData } from "node:worker_threads";
+import { deserialize, serialize } from "node:v8";
+import { promisify } from "node:util";
+import { brotliCompress, brotliDecompress, gunzip, gzip } from "node:zlib";
+import { availableParallelism, hostname } from "node:os";
+import { setTimeout as setTimeout$1 } from "node:timers/promises";
+import cluster from "node:cluster";
+import { fileURLToPath } from "node:url";
+import { fork } from "node:child_process";
+import { createHash, randomUUID, timingSafeEqual } from "node:crypto";
+import { connect, createServer } from "node:net";
+import { connect as connect$1, createServer as createServer$1 } from "node:tls";
+
+//#region src/ShardPing.ts
+/**
+* Pings a shard, measures its latency, and notices when it stops answering.
+*/
+var ShardPing = class {
+	/**
+	* When the last ping was sent, `-1` before the first one.
+	*/
+	lastSentTimestamp = -1;
+	/**
+	* When the last answer came, `-1` before the first one.
+	*/
+	lastReceivedTimestamp = -1;
+	/**
+	* The round trip of the last ping, in milliseconds; `-1` before the first answer.
+	*/
+	latency = -1;
+	interval;
+	timeout;
+	delaySinceReceived;
+	#send;
+	#onTimeout;
+	#timer = null;
+	#watchdog = null;
+	/**
+	* @internal
+	*/
+	constructor(options, send, onTimeout) {
+		this.interval = options.interval ?? 45e3;
+		this.timeout = options.timeout ?? 6e4;
+		this.delaySinceReceived = options.delaySinceReceived ?? false;
+		this.#send = send;
+		this.#onTimeout = onTimeout;
+	}
+	/**
+	* Whether the pings are running.
+	*/
+	get running() {
+		return this.#watchdog !== null;
+	}
+	/**
+	* Whether the last ping was answered.
+	*/
+	get hasReceivedResponse() {
+		return this.lastReceivedTimestamp >= this.lastSentTimestamp;
+	}
+	get lastSentAt() {
+		return this.lastSentTimestamp === -1 ? null : new Date(this.lastSentTimestamp);
+	}
+	get lastReceivedAt() {
+		return this.lastReceivedTimestamp === -1 ? null : new Date(this.lastReceivedTimestamp);
+	}
+	/**
+	* When the next ping is due, or `null` when the pings are not running.
+	*/
+	get nextPingTimestamp() {
+		if (!this.running || !this.enabled) return null;
+		const from = this.delaySinceReceived ? this.lastReceivedTimestamp : this.lastSentTimestamp;
+		return (from === -1 ? Date.now() : from) + this.interval;
+	}
+	/**
+	* @internal
+	*/
+	start() {
+		if (this.running || !this.enabled) return;
+		this.#watchdog = setTimeout(() => {
+			this.stop();
+			this.#onTimeout();
+		}, this.timeout);
+		this.#watchdog.unref();
+		this.#schedule();
+	}
+	/**
+	* @internal
+	*/
+	stop() {
+		if (this.#timer) clearTimeout(this.#timer);
+		if (this.#watchdog) clearTimeout(this.#watchdog);
+		this.#timer = null;
+		this.#watchdog = null;
+	}
+	/**
+	* @internal
+	*/
+	receive(sentAt) {
+		this.lastReceivedTimestamp = Date.now();
+		this.latency = this.lastReceivedTimestamp - sentAt;
+		this.#watchdog?.refresh();
+		if (this.delaySinceReceived && this.running) this.#schedule();
+	}
+	/**
+	* Whether the manager pings at all.
+	*/
+	get enabled() {
+		return this.interval !== -1 && this.interval !== Number.POSITIVE_INFINITY;
+	}
+	#schedule() {
+		if (!this.enabled) return;
+		if (this.#timer) clearTimeout(this.#timer);
+		this.#timer = setTimeout(() => {
+			this.#timer = null;
+			this.lastSentTimestamp = Date.now();
+			this.#send(this.lastSentTimestamp).catch(() => void 0);
+			if (!this.delaySinceReceived) this.#schedule();
+		}, this.interval);
+		this.#timer.unref();
+	}
+};
+
+//#endregion
+//#region src/messages/protocol.ts
+/**
+* The lifecycle status of a shard, as it signals it to its manager.
+*/
+const ShardStatus = {
+	/**
+	* Not spawned yet, or stopped.
+	*/
+	Idle: "Idle",
+	/**
+	* Spawned, and not ready to answer yet.
+	*/
+	Starting: "Starting",
+	/**
+	* Fully operative.
+	*/
+	Ready: "Ready",
+	/**
+	* Running, but disconnected from what it serves, e.g. the gateway.
+	*/
+	Disconnected: "Disconnected",
+	/**
+	* Running, and reconnecting to what it serves.
+	*/
+	Reconnecting: "Reconnecting",
+	/**
+	* Shutting down, not to be restarted.
+	*/
+	Exiting: "Exiting",
+	/**
+	* Shutting down, to be restarted.
+	*/
+	Restarting: "Restarting"
+};
+/**
+* The operation of a packet.
+*
+* @internal
+*/
+const Op = {
+	Signal: 0,
+	Ping: 1,
+	Pong: 2,
+	Message: 3,
+	Request: 4,
+	Reply: 5,
+	Abort: 6,
+	Close: 7
+};
+const Ops = new Set(Object.values(Op));
+/**
+* Serializes packets with a {@link MessageHandler}, then runs them through the {@link MessageTransformer}s, and the
+* other way around.
+*
+* @internal
+*/
+var PacketCodec = class {
+	handler;
+	transformers;
+	constructor(handler, transformers) {
+		this.handler = handler;
+		this.transformers = transformers;
+	}
+	async encode(packet, context) {
+		let data = this.handler.serialize(packet);
+		for (const transformer of this.transformers) data = await transformer.write(assertChannelData(data), context);
+		return data;
+	}
+	async decode(data, context) {
+		for (let index = this.transformers.length - 1; index >= 0; --index) data = await this.transformers[index].read(assertChannelData(data), context);
+		const packet = this.handler.deserialize(data);
+		if (!isPacket(packet)) throw new TypeError("The message is not a sharder packet");
+		return packet;
+	}
+};
+function assertChannelData(data) {
+	if (typeof data === "string" || data instanceof Uint8Array) return data;
+	throw new TypeError("Transformers need a message handler serializing to strings or bytes");
+}
+function isPacket(value) {
+	return typeof value === "object" && value !== null && Ops.has(value.op);
+}
+/**
+* Serializes an error to send it over the channel.
+*
+* @internal
+*/
+function serializeError(error) {
+	return error instanceof Error ? {
+		name: error.name,
+		message: error.message
+	} : {
+		name: "Error",
+		message: String(error)
+	};
+}
+
+//#endregion
+//#region src/util/errors.ts
+/**
+* The handler of a request threw, or there was none: the error is the remote one, rebuilt.
+*/
+var ShardRequestError = class extends Error {
+	/**
+	* The name of the remote error, e.g. `TypeError`.
+	*/
+	remoteName;
+	constructor(remoteName, message) {
+		super(message);
+		this.name = "ShardRequestError";
+		this.remoteName = remoteName;
+	}
+};
+/**
+* A request got no reply in time. The other side was told to abort it.
+*/
+var ShardRequestTimeoutError = class extends Error {
+	timeout;
+	constructor(timeout) {
+		super(`The request got no reply within ${timeout}ms`);
+		this.name = "ShardRequestTimeoutError";
+		this.timeout = timeout;
+	}
+};
+/**
+* A shard stopped, is not ready in time, or does not exist.
+*/
+var ShardUnavailableError = class extends Error {
+	channelId;
+	constructor(channelId, reason) {
+		super(`Shard ${channelId} is unavailable: ${reason}`);
+		this.name = "ShardUnavailableError";
+		this.channelId = channelId;
+	}
+};
+/**
+* A shard failed before it was ready: its process exited, or its worker could not start. The sharder RFC's `error`
+* signal.
+*/
+var ShardSpawnError = class extends Error {
+	channelId;
+	/**
+	* The exit code, when the shard exited.
+	*/
+	code;
+	constructor(channelId, code, cause) {
+		super(cause instanceof Error ? `Shard ${channelId} failed to start: ${cause.message}` : `Shard ${channelId} exited with code ${code} before it was ready`, { cause });
+		this.name = "ShardSpawnError";
+		this.channelId = channelId;
+		this.code = code;
+	}
+};
+
+//#endregion
+//#region src/util/requests.ts
+/**
+* Tracks the requests sent on a channel until their reply comes, they time out, or they are aborted.
+*
+* @internal
+*/
+var OutgoingRequests = class {
+	#pending = /* @__PURE__ */ new Map();
+	#step;
+	#nonce = 0;
+	/**
+	* @param negative Whether to count nonces down from -1, so two senders on one channel never collide.
+	*/
+	constructor(negative = false) {
+		this.#step = negative ? -1 : 1;
+	}
+	/**
+	* Sends a request.
+	*
+	* @param send Writes the request.
+	* @param fields The request.
+	* @param timeout How long to wait for the reply.
+	* @param signal Aborts the request.
+	* @param owner What the request was sent to, to reject it with {@link OutgoingRequests.rejectOwner}.
+	*/
+	request(send, fields, timeout, signal, owner) {
+		if (signal?.aborted) return Promise.reject(signal.reason);
+		this.#nonce += this.#step;
+		const nonce = this.#nonce;
+		return new Promise((resolve, reject) => {
+			const abort = (error) => {
+				if (!this.#pending.has(nonce)) return;
+				settle();
+				reject(error);
+				send({
+					op: Op.Abort,
+					nonce
+				}).catch(() => void 0);
+			};
+			const timer = setTimeout(() => abort(new ShardRequestTimeoutError(timeout)), timeout);
+			const onAbort = () => abort(signal.reason);
+			signal?.addEventListener("abort", onAbort, { once: true });
+			const settle = () => {
+				clearTimeout(timer);
+				signal?.removeEventListener("abort", onAbort);
+				this.#pending.delete(nonce);
+			};
+			this.#pending.set(nonce, {
+				owner,
+				resolve: (value) => {
+					settle();
+					resolve(value);
+				},
+				reject: (error) => {
+					settle();
+					reject(error);
+				}
+			});
+			send({
+				op: Op.Request,
+				nonce,
+				...fields,
+				timeout
+			}).catch((error) => {
+				this.#pending.get(nonce)?.reject(error);
+			});
+		});
+	}
+	/**
+	* Settles the request a reply answers. Returns whether it answered one of these requests.
+	*/
+	settle(packet) {
+		const pending = this.#pending.get(packet.nonce);
+		if (!pending) return false;
+		if (packet.error) pending.reject(new ShardRequestError(packet.error.name, packet.error.message));
+		else pending.resolve(packet.body);
+		return true;
+	}
+	rejectOwner(owner, error) {
+		for (const pending of this.#pending.values()) if (pending.owner === owner) pending.reject(error);
+	}
+	rejectAll(error) {
+		for (const pending of this.#pending.values()) pending.reject(error);
+	}
+};
+/**
+* Runs the requests received on a channel, and aborts them when the other side does.
+*
+* @internal
+*/
+var IncomingRequests = class {
+	#controllers = /* @__PURE__ */ new Map();
+	async handle(send, packet, handler, context) {
+		const controller = new AbortController();
+		this.#controllers.set(packet.nonce, controller);
+		let reply;
+		try {
+			if (!handler) throw new Error("There is no request handler");
+			let body = await handler(packet.body, {
+				...context,
+				signal: controller.signal
+			});
+			if (Result$1.isResult(body)) {
+				if (body.isErr()) throw body.unwrapErr();
+				body = body.unwrap();
+			}
+			reply = {
+				op: Op.Reply,
+				nonce: packet.nonce,
+				body
+			};
+		} catch (error) {
+			reply = {
+				op: Op.Reply,
+				nonce: packet.nonce,
+				error: serializeError(error)
+			};
+		} finally {
+			this.#controllers.delete(packet.nonce);
+		}
+		if (!controller.signal.aborted) await send(reply).catch(() => void 0);
+	}
+	abort(nonce) {
+		this.#controllers.get(nonce)?.abort(/* @__PURE__ */ new Error("The request was aborted by its sender"));
+	}
+	abortAll() {
+		for (const nonce of this.#controllers.keys()) this.abort(nonce);
+	}
+};
+/**
+* Turns an operation into a `Result`, for the `try*` methods.
+*
+* @internal
+*/
+async function toResult(operation) {
+	return Result$1.fromAsync(operation);
+}
+/**
+* Turns the outcomes of a partial broadcast into `Result`s.
+*
+* @internal
+*/
+function settledToResults(results) {
+	return results.map((result) => result.status === "fulfilled" ? Result$1.ok(result.value) : Result$1.err(result.reason));
+}
+/**
+* Serializes the outcomes of a partial broadcast.
+*
+* @internal
+*/
+function serializeSettled(results) {
+	return results.map((result) => result.status === "fulfilled" ? {
+		status: "fulfilled",
+		value: result.value
+	} : {
+		status: "rejected",
+		reason: serializeError(result.reason)
+	});
+}
+/**
+* Rebuilds the outcomes of a partial broadcast.
+*
+* @internal
+*/
+function deserializeSettled(results) {
+	return results.map((result) => result.status === "fulfilled" ? {
+		status: "fulfilled",
+		value: result.value
+	} : {
+		status: "rejected",
+		reason: new ShardRequestError(result.reason.name, result.reason.message)
+	});
+}
+
+//#endregion
+//#region src/ShardChannel.ts
+/**
+* The manager's channel to one shard: a process, cluster worker, worker thread, or remote process, connecting some
+* gateway shards.
+*
+* @remarks
+* Named after discord.js's sharder: a "shard" is the client a manager spawns, and the channel is how the manager
+* talks to it, whatever the channel strategy.
+*/
+var ShardChannel = class extends EventEmitter {
+	/**
+	* The ID of the channel, its index in {@link ShardManager.channels}.
+	*/
+	id;
+	/**
+	* The IDs of the gateway shards the shard connects.
+	*/
+	shards;
+	/**
+	* The total number of gateway shards the shard is told about.
+	*/
+	shardCount;
+	manager;
+	/**
+	* The pings of the shard.
+	*/
+	ping;
+	/**
+	* The status of the running shard, `Idle` when none runs.
+	*/
+	status = ShardStatus.Idle;
+	#active = null;
+	#replacement = null;
+	#stopped = false;
+	#waiters = /* @__PURE__ */ new Set();
+	#outgoing = new OutgoingRequests();
+	/**
+	* @internal
+	*/
+	constructor(manager, id, shards, shardCount) {
+		super();
+		this.manager = manager;
+		this.id = id;
+		this.shards = shards;
+		this.shardCount = shardCount;
+		this.ping = new ShardPing(manager.pingOptions, (sentAt) => this.#write(this.#active, {
+			op: Op.Ping,
+			sentAt
+		}), () => this.#unresponsive());
+	}
+	/**
+	* Whether the shard is running and signalled that it is ready.
+	*/
+	get ready() {
+		return this.status === ShardStatus.Ready;
+	}
+	/**
+	* Whether a shard is running: spawned, and not stopped yet.
+	*/
+	get running() {
+		return this.#active !== null;
+	}
+	/**
+	* Whether the channel was stopped for good: closed, exited, or given up on.
+	*/
+	get stopped() {
+		return this.#stopped;
+	}
+	/**
+	* The ID of the shard's process.
+	*/
+	get pid() {
+		return this.#active?.transport?.pid ?? null;
+	}
+	/**
+	* The ID of the shard's worker thread, for {@link WorkerStrategy}.
+	*/
+	get threadId() {
+		return this.#active?.transport?.threadId ?? null;
+	}
+	/**
+	* The host running the shard, for strategies spawning shards elsewhere.
+	*/
+	get host() {
+		return this.#active?.transport?.host ?? null;
+	}
+	/**
+	* When the running shard was spawned.
+	*/
+	get startedTimestamp() {
+		return this.#active?.startedAt ?? null;
+	}
+	/**
+	* Spawns the shard, and waits for it to signal that it is ready.
+	*
+	* @param timeout How long to wait for it, in milliseconds. Past it, the shard is killed and the promise rejects.
+	*/
+	async start(timeout = this.manager.spawnTimeout) {
+		if (this.#active) throw new Error(`Shard ${this.id} is already running`);
+		this.#stopped = false;
+		const instance = this.#spawn();
+		this.#active = instance;
+		this.#setStatus(ShardStatus.Starting);
+		await this.#awaitReady(instance, timeout);
+	}
+	/**
+	* Stops the shard for good. It is first asked to close, which runs its close handler, and is killed if it did not
+	* exit within the timeout.
+	*
+	* @param timeout How long to wait for the shard to exit by itself, in milliseconds.
+	*/
+	async close(timeout = this.manager.requestTimeout) {
+		this.#stopped = true;
+		this.#rejectWaiters(new ShardUnavailableError(this.id, "it was closed"));
+		const instances = [this.#replacement, this.#active].filter((instance) => instance !== null);
+		if (instances.length === 0) return;
+		await Promise.all(instances.map((instance) => this.#stop(instance, timeout)));
+		this.emit("destroy");
+		this.manager.emit("shardDestroy", this);
+	}
+	/**
+	* Restarts the shard through its manager, see {@link ShardManager.restart}.
+	*
+	* @param options Whether to restart it rolling, and the timeout.
+	*/
+	restart(options) {
+		return this.manager.restart(this.id, options);
+	}
+	/**
+	* Waits for the shard to be ready.
+	*
+	* @param timeout How long to wait, in milliseconds.
+	* @param signal Aborts the wait.
+	* @throws A {@link ShardUnavailableError} when the shard is stopped for good, not ready in time, or expected to be
+	* ready past the timeout (see `spawn.readyHint`).
+	*/
+	waitForReady(timeout = this.manager.requestTimeout, signal) {
+		if (this.ready) return Promise.resolve();
+		if (this.#stopped) return Promise.reject(new ShardUnavailableError(this.id, "it is stopped"));
+		signal?.throwIfAborted();
+		const remaining = this.#estimatedRemaining();
+		if (remaining !== null && remaining > timeout) return Promise.reject(new ShardUnavailableError(this.id, `it is expected to be ready in ${remaining}ms`));
+		return new Promise((resolve, reject) => {
+			const settle = () => {
+				clearTimeout(timer);
+				signal?.removeEventListener("abort", onAbort);
+				this.#waiters.delete(waiter);
+			};
+			const waiter = {
+				resolve: () => {
+					settle();
+					resolve();
+				},
+				reject: (error) => {
+					settle();
+					reject(error);
+				}
+			};
+			const onAbort = () => waiter.reject(signal.reason);
+			const timer = setTimeout(() => waiter.reject(new ShardUnavailableError(this.id, `not ready within ${timeout}ms`)), timeout);
+			signal?.addEventListener("abort", onAbort, { once: true });
+			this.#waiters.add(waiter);
+		});
+	}
+	/**
+	* Sends a message to the shard, emitted as `message` by its {@link ShardClient}. Waits for the shard to be ready.
+	*
+	* @param body The message.
+	* @param options How long to wait for the shard to be ready, and an abort signal.
+	* @param from The shard the message comes from, `null` for the manager.
+	*/
+	async send(body, options = {}, from = null) {
+		await this.waitForReady(options.timeout, options.signal);
+		await this.#write(this.#active, {
+			op: Op.Message,
+			body,
+			from
+		});
+	}
+	/**
+	* Sends a request to the shard, answered by its {@link ShardClient}'s request handler. Waits for the shard to be
+	* ready.
+	*
+	* @param body The request.
+	* @param options The timeout and abort signal of the request.
+	* @param from The shard the request comes from, `null` for the manager.
+	*/
+	async request(body, options = {}, from = null) {
+		return this.#request(body, options, { from });
+	}
+	/**
+	* {@link ShardChannel.send}, resolving with a `Result` rather than rejecting.
+	*/
+	trySend(body, options) {
+		return toResult(() => this.send(body, options));
+	}
+	/**
+	* {@link ShardChannel.request}, resolving with a `Result` rather than rejecting.
+	*/
+	tryRequest(body, options) {
+		return toResult(() => this.request(body, options));
+	}
+	/**
+	* Asks the shard to start one of its gateway shards, through its shard handler.
+	*
+	* @param shardId The ID of the gateway shard.
+	* @param options The timeout and abort signal of the request.
+	*/
+	async startShard(shardId, options) {
+		await this.#system("startShard", shardId, options);
+	}
+	/**
+	* Asks the shard to close one of its gateway shards, through its shard handler.
+	*
+	* @param shardId The ID of the gateway shard.
+	* @param options The timeout and abort signal of the request.
+	*/
+	async closeShard(shardId, options) {
+		await this.#system("closeShard", shardId, options);
+	}
+	/**
+	* Restarts the shard, keeping the old one until the new one is ready.
+	*
+	* @internal
+	*/
+	async rollingRestart(timeout = this.manager.spawnTimeout) {
+		if (!this.#active) {
+			await this.start(timeout);
+			return;
+		}
+		this.#stopped = false;
+		const replacement = this.#spawn();
+		this.#replacement = replacement;
+		try {
+			await this.#awaitReady(replacement, timeout);
+		} finally {
+			if (this.#replacement === replacement) this.#replacement = null;
+		}
+		const previous = this.#active;
+		this.#active = replacement;
+		this.ping.stop();
+		this.status = ShardStatus.Starting;
+		this.#setStatus(replacement.status);
+		if (previous) await this.#stop(previous, timeout);
+	}
+	/**
+	* Stops the channel for good without closing anything, when its shard exited or was given up on.
+	*
+	* @internal
+	*/
+	markStopped(reason) {
+		this.#stopped = true;
+		this.#rejectWaiters(new ShardUnavailableError(this.id, reason));
+	}
+	async #request(body, options, fields) {
+		const timeout = options.timeout ?? this.manager.requestTimeout;
+		const started = Date.now();
+		await this.waitForReady(timeout, options.signal);
+		const active = this.#active;
+		return this.#outgoing.request((packet) => this.#write(active, packet), {
+			body,
+			...fields
+		}, Math.max(timeout - (Date.now() - started), 1), options.signal, active);
+	}
+	#system(call, body, options = {}) {
+		return this.#request(body, options, { system: call });
+	}
+	#spawn() {
+		let resolveExit;
+		let resolveReady;
+		const instance = {
+			transport: null,
+			status: ShardStatus.Starting,
+			startedAt: Date.now(),
+			everReady: false,
+			exited: false,
+			exit: new Promise((resolve) => {
+				resolveExit = resolve;
+			}),
+			resolveExit: (code) => resolveExit(code),
+			ready: new Promise((resolve) => {
+				resolveReady = resolve;
+			}),
+			resolveReady: () => resolveReady(),
+			stopping: false,
+			awaited: true,
+			incoming: new IncomingRequests(),
+			slowStart: null
+		};
+		const context = {
+			id: this.id,
+			shards: this.shards,
+			shardCount: this.shardCount,
+			pingTimeout: this.ping.enabled ? this.ping.timeout + this.ping.interval : null,
+			requestTimeout: this.manager.requestTimeout,
+			messageHandler: this.manager.codec.handler.name,
+			transformers: this.manager.codec.transformers.map((transformer) => transformer.name)
+		};
+		instance.transport = this.manager.strategy.spawn(context, {
+			message: (data) => void this.#receive(instance, data),
+			exit: (code) => this.#exited(instance, code),
+			error: (error) => this.#failed(instance, error)
+		}, { env: this.manager.spawnEnv });
+		const estimate = this.manager.readyEstimate;
+		if (estimate !== null) {
+			instance.slowStart = setTimeout(() => {
+				instance.slowStart = null;
+				if (instance.everReady || instance.exited) return;
+				const elapsed = Date.now() - instance.startedAt;
+				this.emit("slowStart", elapsed, estimate);
+				this.manager.emit("shardSlowStart", this, elapsed, estimate);
+			}, estimate * (1 + this.manager.readyHintMargin));
+			instance.slowStart.unref();
+		}
+		this.emit("spawn");
+		this.manager.emit("shardCreate", this);
+		return instance;
+	}
+	async #awaitReady(instance, timeout) {
+		let timer;
+		try {
+			await Promise.race([
+				instance.ready,
+				instance.exit.then((code) => {
+					throw new ShardSpawnError(this.id, code);
+				}),
+				new Promise((_resolve, reject) => {
+					timer = setTimeout(() => reject(new ShardUnavailableError(this.id, `not ready within ${timeout}ms`)), timeout);
+				})
+			]);
+			this.manager.recordReadyTime(Date.now() - instance.startedAt);
+		} catch (error) {
+			instance.stopping = true;
+			await this.#kill(instance);
+			if (this.#active === instance) this.#active = null;
+			throw error;
+		} finally {
+			clearTimeout(timer);
+			instance.awaited = false;
+		}
+	}
+	async #write(instance, packet) {
+		const transport = instance?.transport;
+		if (!transport || instance.exited) throw new ShardUnavailableError(this.id, "it is not running");
+		await transport.send(await this.manager.codec.encode(packet, { channelId: this.id }));
+	}
+	async #receive(instance, data) {
+		let packet;
+		try {
+			packet = await this.manager.codec.decode(data, { channelId: this.id });
+		} catch (error) {
+			this.manager.reportInvalidMessage(this, error);
+			return;
+		}
+		const write = (reply) => this.#write(instance, reply);
+		switch (packet.op) {
+			case Op.Signal:
+				instance.status = packet.status;
+				if (packet.status === ShardStatus.Ready && !instance.everReady) {
+					instance.everReady = true;
+					instance.awaited = false;
+					if (instance.slowStart) clearTimeout(instance.slowStart);
+					instance.resolveReady();
+				}
+				if (instance === this.#active) this.#setStatus(packet.status);
+				break;
+			case Op.Pong:
+				if (instance === this.#active) {
+					this.ping.receive(packet.sentAt);
+					this.emit("ping", this.ping.latency);
+					this.manager.emit("shardPing", this, this.ping.latency);
+				}
+				break;
+			case Op.Message:
+				if (packet.to === void 0) {
+					this.emit("message", packet.body);
+					this.manager.emit("message", packet.body, this);
+				} else await this.manager.route(packet.body, packet.to, this.id).catch((error) => this.manager.reportError(error));
+				break;
+			case Op.Request: {
+				const { to, timeout, partial, system } = packet;
+				const handler = system ? (body, { signal }) => this.manager.handleSystem(system, body, this, signal) : to === void 0 ? this.manager.requestHandler : (body, { signal }) => this.manager.forward(body, to, this.id, {
+					timeout,
+					signal,
+					partial
+				});
+				await instance.incoming.handle(write, packet, handler, { channel: this });
+				break;
+			}
+			case Op.Reply:
+				this.#outgoing.settle(packet);
+				break;
+			case Op.Abort:
+				instance.incoming.abort(packet.nonce);
+				break;
+			default: this.manager.reportInvalidMessage(this, /* @__PURE__ */ new TypeError(`Unexpected packet ${packet.op}`));
+		}
+	}
+	#setStatus(status) {
+		if (this.status === status) return;
+		this.status = status;
+		this.emit("status", status);
+		this.manager.emit("shardStatus", this, status);
+		switch (status) {
+			case ShardStatus.Ready:
+				this.manager.supervisor.ready(this.id);
+				this.ping.start();
+				for (const waiter of this.#waiters) waiter.resolve();
+				this.emit("ready");
+				this.manager.emit("shardReady", this);
+				break;
+			case ShardStatus.Disconnected:
+				this.emit("disconnect");
+				this.manager.emit("shardDisconnect", this);
+				break;
+			case ShardStatus.Reconnecting:
+				this.emit("reconnecting");
+				this.manager.emit("shardReconnecting", this);
+				break;
+			case ShardStatus.Idle: this.ping.stop();
+		}
+	}
+	#estimatedRemaining() {
+		const estimate = this.manager.readyEstimate;
+		const active = this.#active;
+		if (estimate === null || !active || this.status !== ShardStatus.Starting) return null;
+		const remaining = estimate - (Date.now() - active.startedAt) - estimate * this.manager.readyHintMargin;
+		return remaining > 0 ? Math.round(remaining) : null;
+	}
+	#unresponsive() {
+		if (this.listenerCount("unresponsive") > 0 || this.manager.listenerCount("shardUnresponsive") > 0) {
+			this.emit("unresponsive");
+			this.manager.emit("shardUnresponsive", this);
+		} else this.restart().catch((error) => this.manager.reportError(error));
+	}
+	async #stop(instance, timeout) {
+		instance.stopping = true;
+		if (instance.exited) return;
+		const asked = await this.#write(instance, { op: Op.Close }).then(() => true, () => false);
+		const timer = setTimeout(() => void this.#kill(instance), asked ? timeout : 0);
+		await instance.exit;
+		clearTimeout(timer);
+	}
+	async #kill(instance) {
+		instance.stopping = true;
+		if (!instance.exited) await instance.transport?.kill();
+	}
+	#failed(instance, error) {
+		const spawnError = new ShardSpawnError(this.id, null, error);
+		if (instance.everReady) this.manager.reportShardError(this, error);
+		else this.manager.reportShardError(this, spawnError);
+	}
+	#exited(instance, code) {
+		if (instance.exited) return;
+		instance.exited = true;
+		if (instance.slowStart) clearTimeout(instance.slowStart);
+		instance.incoming.abortAll();
+		this.#outgoing.rejectOwner(instance, new ShardUnavailableError(this.id, "it stopped"));
+		instance.resolveExit(code);
+		if (instance !== this.#active) return;
+		this.#active = null;
+		const previous = instance.status;
+		this.#setStatus(ShardStatus.Idle);
+		this.emit("exit", code);
+		this.manager.emit("shardExit", this, code);
+		if (!instance.everReady && !instance.stopping && code !== 0) this.manager.reportShardError(this, new ShardSpawnError(this.id, code));
+		if (instance.stopping || instance.awaited) return;
+		this.manager.supervise(this, previous);
+	}
+	#rejectWaiters(error) {
+		for (const waiter of this.#waiters) waiter.reject(error);
+	}
+};
+
+//#endregion
+//#region src/messages/MessageHandler.ts
+/**
+* Serializes packets as JSON: every body must be JSON-serializable. The default.
+*/
+var JsonMessageHandler = class {
+	name = "json";
+	serialize(packet) {
+		return JSON.stringify(packet);
+	}
+	deserialize(data) {
+		return JSON.parse(typeof data === "string" ? data : new TextDecoder().decode(data));
+	}
+};
+/**
+* Serializes packets with `node:v8`, which keeps `Map`s, `Set`s, `Date`s, `BigInt`s, typed arrays, and circular
+* references.
+*/
+var V8MessageHandler = class {
+	name = "v8";
+	serialize(packet) {
+		return serialize(packet);
+	}
+	deserialize(data) {
+		if (!(data instanceof Uint8Array)) throw new TypeError("V8MessageHandler can only read binary data");
+		return deserialize(data);
+	}
+};
+/**
+* Passes packets as they are, for channels that clone values themselves: worker threads, and processes with the
+* `advanced` IPC serialization. It cannot be combined with transformers, nor cross the network.
+*/
+var RawMessageHandler = class {
+	name = "raw";
+	serialize(packet) {
+		return packet;
+	}
+	deserialize(data) {
+		return data;
+	}
+};
+const handlers = /* @__PURE__ */ new Map([
+	["json", () => new JsonMessageHandler()],
+	["v8", () => new V8MessageHandler()],
+	["raw", () => new RawMessageHandler()]
+]);
+/**
+* Registers a message handler under its name, so managers and shards can refer to it by name.
+*
+* @param name The name of the handler, the same as its `name`.
+* @param factory Builds the handler.
+*/
+function registerMessageHandler(name, factory) {
+	handlers.set(name, factory);
+}
+/**
+* Resolves a message handler, or the name of a registered one.
+*
+* @param handler The handler, or its name.
+*/
+function resolveMessageHandler(handler) {
+	if (typeof handler !== "string") return handler;
+	const factory = handlers.get(handler);
+	if (!factory) throw new RangeError(`There is no message handler named "${handler}"`);
+	return factory();
+}
+
+//#endregion
+//#region src/messages/MessageTransformer.ts
+const gzipAsync = promisify(gzip);
+const gunzipAsync = promisify(gunzip);
+const brotliCompressAsync = promisify(brotliCompress);
+const brotliDecompressAsync = promisify(brotliDecompress);
+/**
+* Compresses messages with gzip.
+*/
+var GzipTransformer = class {
+	name = "gzip";
+	options;
+	/**
+	* @param options The compression options, e.g. its `level`.
+	*/
+	constructor(options = {}) {
+		this.options = options;
+	}
+	write(data) {
+		return gzipAsync(data, this.options);
+	}
+	read(data) {
+		return gunzipAsync(data);
+	}
+};
+/**
+* Compresses messages with Brotli, smaller than gzip at a higher CPU cost.
+*/
+var BrotliTransformer = class {
+	name = "brotli";
+	write(data) {
+		return brotliCompressAsync(data);
+	}
+	read(data) {
+		return brotliDecompressAsync(data);
+	}
+};
+const transformers = /* @__PURE__ */ new Map([["gzip", () => new GzipTransformer()], ["brotli", () => new BrotliTransformer()]]);
+/**
+* Registers a message transformer under its name, so managers and shards can refer to it by name.
+*
+* @param name The name of the transformer, the same as its `name`.
+* @param factory Builds the transformer, e.g. with a key read from the environment.
+*/
+function registerMessageTransformer(name, factory) {
+	transformers.set(name, factory);
+}
+/**
+* Resolves a message transformer, or the name of a registered one.
+*
+* @param transformer The transformer, or its name.
+*/
+function resolveMessageTransformer(transformer) {
+	if (typeof transformer !== "string") return transformer;
+	const factory = transformers.get(transformer);
+	if (!factory) throw new RangeError(`There is no message transformer named "${transformer}"`);
+	return factory();
+}
+
+//#endregion
+//#region src/strategies/ChannelStrategy.ts
+/**
+* The environment variable carrying the {@link ShardContext} of a shard.
+*/
+const ShardContextVariable = "WOLFSTAR_SHARDER";
+/**
+* Serializes a shard's context for its environment or worker data.
+*
+* @internal
+*/
+function encodeContext(context) {
+	return JSON.stringify(context);
+}
+
+//#endregion
+//#region src/ShardClient.ts
+const MaxTimeout = 2147483647;
+/**
+* The shard's side of the sharder: it tells the manager its status, and messages the manager and the other shards.
+*
+* @example
+* ```ts
+* const shard = new ShardClient();
+* const client = new GatewayClient({
+*   ...options,
+*   ...shard.gatewayOptions,
+*   gateway: { buildIdentifyThrottler: () => shard.identifyThrottler },
+* });
+* // Reuse the manager's `GET /gateway/bot` rather than requesting it again.
+* client.gateway.fetchGatewayInformation = () => shard.fetchGatewayInformation();
+* shard.setRequestHandler((body) => ...);
+* ```
+*/
+var ShardClient = class ShardClient extends EventEmitter {
+	/**
+	* The context of this process or thread, when a {@link ShardManager} spawned it; `null` otherwise.
+	*/
+	static get context() {
+		const raw = isMainThread ? process.env[ShardContextVariable] : workerData?.[ShardContextVariable];
+		return typeof raw === "string" ? JSON.parse(raw) : null;
+	}
+	/**
+	* Registers a message handler the manager can refer to by name. The sharder RFC's API.
+	*
+	* @param name The name of the handler.
+	* @param factory Builds the handler.
+	*/
+	static registerMessageHandler(name, factory) {
+		registerMessageHandler(name, factory);
+		return ShardClient;
+	}
+	/**
+	* Registers a message transformer the manager can refer to by name. The sharder RFC's API.
+	*
+	* @param name The name of the transformer.
+	* @param factory Builds the transformer.
+	*/
+	static registerMessageTransformer(name, factory) {
+		registerMessageTransformer(name, factory);
+		return ShardClient;
+	}
+	/**
+	* The ID of the shard, its channel's in the manager.
+	*/
+	id;
+	/**
+	* The IDs of the gateway shards the shard connects.
+	*/
+	shards;
+	/**
+	* The total number of gateway shards, across every shard.
+	*/
+	shardCount;
+	requestTimeout;
+	/**
+	* The last status signalled to the manager.
+	*/
+	status = ShardStatus.Starting;
+	/**
+	* When the manager last pinged the shard, `null` before its first ping.
+	*/
+	lastPingTimestamp = null;
+	#transport;
+	#codec;
+	#outgoing = new OutgoingRequests();
+	#incoming = new IncomingRequests();
+	#pingTimeout;
+	#watchdog = null;
+	#requestHandler = null;
+	#closeHandler = null;
+	#shardHandler = null;
+	constructor(options = {}) {
+		super();
+		const context = options.context ?? ShardClient.context;
+		if (!context) throw new Error("This process or thread was not spawned by a ShardManager");
+		this.id = context.id;
+		this.shards = context.shards;
+		this.shardCount = context.shardCount;
+		this.requestTimeout = context.requestTimeout;
+		this.#codec = new PacketCodec(resolveMessageHandler(options.messageHandler ?? context.messageHandler), (options.transformers ?? context.transformers).map(resolveMessageTransformer));
+		this.#transport = options.transport ?? defaultTransport(context);
+		this.#transport.onMessage((data) => void this.#receive(data));
+		this.#transport.onDisconnect(() => {
+			this.#stopWatchdog();
+			if (this.listenerCount("disconnect") > 0) this.emit("disconnect");
+			else this.#transport.exit(0);
+		});
+		this.#pingTimeout = context.pingTimeout;
+		this.#signal(ShardStatus.Starting).catch((error) => this.#report(error));
+	}
+	/**
+	* The ID of the shard's process.
+	*/
+	get pid() {
+		return process.pid;
+	}
+	/**
+	* The ID of the shard's thread, `0` for a process's main thread.
+	*/
+	get threadId() {
+		return threadId;
+	}
+	/**
+	* The gateway shards to connect, to spread into `GatewayClient`'s (or `@discordjs/ws`'s) options.
+	*/
+	get gatewayOptions() {
+		return {
+			shardIds: [...this.shards],
+			shardCount: this.shardCount
+		};
+	}
+	/**
+	* Paces the identifies of the gateway shards across every shard, through the manager: pass it as `@discordjs/ws`'s
+	* `buildIdentifyThrottler`. The manager then needs no spawn delay.
+	*/
+	get identifyThrottler() {
+		return { waitForIdentify: async (shardId, signal) => {
+			await this.#system("identify", shardId, {
+				timeout: MaxTimeout,
+				signal
+			});
+		} };
+	}
+	/**
+	* Gets `GET /gateway/bot` from the manager, fetched once for every shard, e.g. to replace `@discordjs/ws`'s
+	* `WebSocketManager#fetchGatewayInformation`.
+	*/
+	fetchGatewayInformation() {
+		return this.#system("gatewayInformation", null);
+	}
+	/**
+	* Tells the manager that the shard is ready, e.g. once its gateway shards are. The manager spawns the next shard
+	* only then.
+	*/
+	ready() {
+		if (!this.#watchdog && this.#pingTimeout !== null) {
+			this.#watchdog = setTimeout(() => {
+				this.#watchdog = null;
+				this.emit("managerUnresponsive");
+			}, this.#pingTimeout);
+			this.#watchdog.unref();
+		}
+		return this.#signal(ShardStatus.Ready);
+	}
+	/**
+	* Tells the manager that the shard lost what it serves, e.g. the gateway. Messages for it wait until it is ready
+	* again.
+	*/
+	disconnected() {
+		return this.#signal(ShardStatus.Disconnected);
+	}
+	/**
+	* Tells the manager that the shard is reconnecting to what it serves.
+	*/
+	reconnecting() {
+		return this.#signal(ShardStatus.Reconnecting);
+	}
+	/**
+	* Stops the shard for good: the manager does not respawn it.
+	*
+	* @param code The exit code.
+	*/
+	async exit(code = 0) {
+		await this.#stop(ShardStatus.Exiting, code);
+	}
+	/**
+	* Stops the shard, for the manager to spawn it again.
+	*/
+	async restart() {
+		await this.#stop(ShardStatus.Restarting, 0);
+	}
+	/**
+	* Sends a message to the manager, emitted as its `message` event, or to other shards.
+	*
+	* @param body The message.
+	* @param to The ID of the shard to send it to, or `"all"`. Left out, it goes to the manager.
+	*/
+	send(body, to) {
+		return this.#write({
+			op: Op.Message,
+			body,
+			to
+		});
+	}
+	/**
+	* Sends a request to the manager or to another shard.
+	*
+	* @param body The request.
+	* @param options Where it goes (the manager by default), its timeout, and its abort signal.
+	*/
+	request(body, options = {}) {
+		return this.#outgoing.request((packet) => this.#write(packet), {
+			body,
+			to: options.to
+		}, options.timeout ?? this.requestTimeout, options.signal);
+	}
+	async broadcastRequest(body, options = {}) {
+		const reply = await this.#outgoing.request((packet) => this.#write(packet), {
+			body,
+			to: "all",
+			partial: options.partial
+		}, options.timeout ?? this.requestTimeout, options.signal);
+		return options.partial ? deserializeSettled(reply) : reply;
+	}
+	/**
+	* {@link ShardClient.send}, resolving with a `Result` rather than rejecting.
+	*/
+	trySend(body, to) {
+		return toResult(() => this.send(body, to));
+	}
+	/**
+	* {@link ShardClient.request}, resolving with a `Result` rather than rejecting.
+	*/
+	tryRequest(body, options) {
+		return toResult(() => this.request(body, options));
+	}
+	/**
+	* {@link ShardClient.broadcastRequest}, with one `Result` per shard, by shard ID. The broadcast itself failing
+	* (e.g. the manager not answering) is the outer `Err`.
+	*/
+	tryBroadcastRequest(body, options) {
+		return toResult(async () => settledToResults(await this.broadcastRequest(body, {
+			...options,
+			partial: true
+		})));
+	}
+	/**
+	* {@link ShardClient.control}, resolving with a `Result` rather than rejecting.
+	*/
+	tryControl(request, options) {
+		return toResult(() => this.control(request, options));
+	}
+	/**
+	* Asks the manager to start, close, or restart shards or gateway shards.
+	*
+	* @param request What to do, and to what.
+	* @param options The timeout and abort signal of the request.
+	* @example
+	* ```ts
+	* await shard.control({ action: "restart", target: { channel: "all" } });
+	* await shard.control({ action: "restart", target: { shard: 12 } });
+	* ```
+	*/
+	async control(request, options) {
+		await this.#system("control", request, options);
+	}
+	/**
+	* Sets the handler answering the requests of the manager and of the other shards.
+	*
+	* @param handler The handler; its return value is the reply. `from` is the shard asking, `null` for the manager.
+	*/
+	setRequestHandler(handler) {
+		this.#requestHandler = handler;
+		return this;
+	}
+	/**
+	* Sets what to do when the manager closes the shard, e.g. disconnect from the gateway. The shard exits once it
+	* resolves; without a handler, it exits right away.
+	*
+	* @param handler The handler.
+	*/
+	setCloseHandler(handler) {
+		this.#closeHandler = handler;
+		return this;
+	}
+	/**
+	* Sets how the manager starts and closes the gateway shards of this shard, for `manager.startShard` & co.
+	*
+	* @param handler Starts or closes a gateway shard, resolving once done.
+	*/
+	setShardHandler(handler) {
+		this.#shardHandler = handler;
+		return this;
+	}
+	#system(call, body, options = {}) {
+		return this.#outgoing.request((packet) => this.#write(packet), {
+			body,
+			system: call
+		}, options.timeout ?? this.requestTimeout, options.signal);
+	}
+	async #signal(status) {
+		this.status = status;
+		await this.#write({
+			op: Op.Signal,
+			status
+		});
+	}
+	#stopWatchdog() {
+		if (this.#watchdog) clearTimeout(this.#watchdog);
+		this.#watchdog = null;
+	}
+	async #stop(status, code) {
+		this.#stopWatchdog();
+		await this.#signal(status).catch(() => void 0);
+		this.#transport.exit(code);
+	}
+	async #write(packet) {
+		await this.#transport.send(await this.#codec.encode(packet, { channelId: this.id }));
+	}
+	async #receive(data) {
+		let packet;
+		try {
+			packet = await this.#codec.decode(data, { channelId: this.id });
+		} catch (error) {
+			if (this.listenerCount("invalidMessage") > 0) this.emit("invalidMessage", error);
+			else console.error("The shard manager sent an invalid message:", error);
+			return;
+		}
+		switch (packet.op) {
+			case Op.Ping:
+				this.lastPingTimestamp = Date.now();
+				this.#watchdog?.refresh();
+				await this.#write({
+					op: Op.Pong,
+					sentAt: packet.sentAt
+				}).catch(() => void 0);
+				break;
+			case Op.Message:
+				this.emit("message", packet.body, packet.from ?? null);
+				break;
+			case Op.Request: {
+				const { system } = packet;
+				const handler = system ? (body, { signal }) => this.#handleSystem(system, body, signal) : this.#requestHandler;
+				await this.#incoming.handle((reply) => this.#write(reply), packet, handler, { from: packet.from ?? null });
+				break;
+			}
+			case Op.Reply:
+				this.#outgoing.settle(packet);
+				break;
+			case Op.Abort:
+				this.#incoming.abort(packet.nonce);
+				break;
+			case Op.Close:
+				try {
+					await this.#closeHandler?.();
+				} catch (error) {
+					this.#report(error);
+				}
+				await this.exit(0);
+		}
+	}
+	async #handleSystem(call, shardId, signal) {
+		const action = call === "startShard" ? this.#shardHandler?.start : call === "closeShard" ? this.#shardHandler?.close : null;
+		if (call !== "startShard" && call !== "closeShard") throw new Error(`The manager cannot send the ${call} system request`);
+		if (!this.shards.includes(shardId)) throw new RangeError(`This shard does not connect the gateway shard ${shardId}`);
+		if (!action) throw new Error(`There is no shard handler to ${call === "startShard" ? "start" : "close"} gateway shards`);
+		await action.call(this.#shardHandler, shardId, { signal });
+		return null;
+	}
+	#report(error) {
+		if (this.listenerCount("error") > 0) this.emit("error", error);
+		else console.error(error);
+	}
+};
+function defaultTransport(context) {
+	if (context.transport === "worker") {
+		if (!parentPort) throw new Error("The shard is not running in a worker thread");
+		const port = parentPort;
+		return {
+			send: async (data) => port.postMessage(data),
+			onMessage: (listener) => port.on("message", listener),
+			onDisconnect: () => void 0,
+			exit: (code) => process.exit(code)
+		};
+	}
+	if (!process.send) throw new Error("The shard has no IPC channel to its manager");
+	return {
+		send: (data) => new Promise((resolve, reject) => {
+			if (!process.connected) {
+				reject(/* @__PURE__ */ new Error("The IPC channel to the manager is closed"));
+				return;
+			}
+			process.send(data, void 0, void 0, (error) => error ? reject(error) : resolve());
+		}),
+		onMessage: (listener) => process.on("message", listener),
+		onDisconnect: (listener) => process.once("disconnect", listener),
+		exit: (code) => process.exit(code)
+	};
+}
+
+//#endregion
+//#region src/strategies/ProcessStrategy.ts
+/**
+* The base of {@link ForkStrategy} and {@link ClusterStrategy}: a shard is a process with an IPC channel, using the
+* `advanced` serialization so binary data (and {@link RawMessageHandler}'s values) survive it.
+*/
+var ProcessStrategy = class {
+	spawn(context, events, options) {
+		const child = this.createProcess({
+			...context,
+			transport: "process"
+		}, options);
+		const process = "process" in child ? child.process : child;
+		process.on("message", (data) => events.message(data));
+		process.on("error", (error) => events.error(error));
+		let exited = false;
+		const exit = new Promise((resolve) => {
+			process.once("exit", (code) => {
+				exited = true;
+				events.exit(code);
+				resolve();
+			});
+		});
+		return {
+			pid: process.pid ?? null,
+			send: (data) => new Promise((resolve, reject) => {
+				if (!process.connected) {
+					reject(/* @__PURE__ */ new Error("The shard's IPC channel is closed"));
+					return;
+				}
+				process.send(data, void 0, void 0, (error) => error ? reject(error) : resolve());
+			}),
+			kill: async () => {
+				if (!exited) process.kill();
+				await exit;
+			}
+		};
+	}
+};
+
+//#endregion
+//#region src/strategies/ClusterStrategy.ts
+/**
+* Spawns every shard as a `node:cluster` worker. Unlike {@link ForkStrategy}, the shards share the ports they listen
+* on, and the primary balances the connections between them.
+*/
+var ClusterStrategy = class extends ProcessStrategy {
+	name = "cluster";
+	options;
+	constructor(options = {}) {
+		super();
+		this.options = options;
+	}
+	createProcess(context, options) {
+		const { path, args, execArgv, env } = this.options;
+		cluster.setupPrimary({
+			exec: path instanceof URL ? fileURLToPath(path) : path,
+			args: args ? [...args] : void 0,
+			execArgv: execArgv ? [...execArgv] : void 0,
+			serialization: "advanced"
+		});
+		return cluster.fork({
+			...env,
+			...options.env,
+			[ShardContextVariable]: encodeContext(context)
+		});
+	}
+};
+
+//#endregion
+//#region src/strategies/ForkStrategy.ts
+/**
+* Spawns every shard as a child process with `child_process.fork`. The default strategy.
+*
+* @remarks
+* Every shard is its own process: ports opened by the shards (e.g. an HTTP interactions server) must differ.
+*/
+var ForkStrategy = class extends ProcessStrategy {
+	name = "fork";
+	options;
+	constructor(options = {}) {
+		super();
+		this.options = options;
+	}
+	createProcess(context, options) {
+		const { path = process.argv[1], args = [], execArgv, env } = this.options;
+		return fork(path instanceof URL ? fileURLToPath(path) : path, args, {
+			env: {
+				...process.env,
+				...env,
+				...options.env,
+				[ShardContextVariable]: encodeContext(context)
+			},
+			execArgv: execArgv ? [...execArgv] : void 0,
+			serialization: "advanced"
+		});
+	}
+};
+
+//#endregion
+//#region src/network/Connection.ts
+/**
+* The frames exchanged between a manager and its proxies, and between proxies.
+*
+* @internal
+*/
+const FrameType = {
+	/**
+	* Proxy → manager, JSON {@link HelloFrame}: authenticates, and lists the shards still running.
+	*/
+	Hello: 0,
+	/**
+	* Manager → proxy, JSON {@link WelcomeFrame}: accepts the proxy, and lists the running shards to kill.
+	*/
+	Welcome: 1,
+	/**
+	* Manager → proxy, JSON `{ reason }`: rejects the proxy.
+	*/
+	Reject: 2,
+	/**
+	* Manager → proxy, JSON {@link SpawnFrame}.
+	*/
+	Spawn: 3,
+	/**
+	* Proxy → manager, JSON `{ spawnId, pid, threadId }`: the shard was spawned.
+	*/
+	Spawned: 4,
+	/**
+	* Manager → proxy, JSON `{ spawnId }`.
+	*/
+	Kill: 5,
+	/**
+	* Proxy → manager, JSON `{ spawnId, code }`.
+	*/
+	Exit: 6,
+	/**
+	* Proxy → manager, JSON `{ spawnId, message }`.
+	*/
+	Error: 7,
+	/**
+	* Both ways: a spawn ID (u32), then the string data.
+	*/
+	StringData: 8,
+	/**
+	* Both ways: a spawn ID (u32), then the binary data.
+	*/
+	BinaryData: 9,
+	Heartbeat: 10,
+	/**
+	* Proxy → manager, JSON `{ available }`: how many more shards the proxy takes, across all its managers.
+	*/
+	Load: 11,
+	/**
+	* Proxy → manager, JSON `{ spawnId, ready }`: whether a shard is ready, for the peer directory.
+	*/
+	Status: 12,
+	/**
+	* Manager → proxy, JSON {@link DirectoryFrame}: which proxy runs which ready shard, for peer routing.
+	*/
+	Directory: 13,
+	/**
+	* Proxy → proxy, JSON `{ token, name }`: opens a peer connection.
+	*/
+	PeerHello: 20,
+	/**
+	* Proxy → proxy, empty: accepts a peer connection.
+	*/
+	PeerWelcome: 21,
+	/**
+	* Proxy → proxy: a {@link PeerHeader} (length-prefixed JSON), then the packet as a shard encoded it.
+	*/
+	PeerPacket: 22
+};
+/**
+* Carries length-prefixed frames over a socket, with heartbeats.
+*
+* @internal
+*/
+var Connection = class extends EventEmitter {
+	socket;
+	#buffer = Buffer.alloc(0);
+	#closed = false;
+	#heartbeat;
+	#watchdog;
+	constructor(socket, heartbeat) {
+		super();
+		this.socket = socket;
+		socket.setNoDelay(true);
+		socket.on("data", (chunk) => this.#read(chunk));
+		socket.on("error", (error) => this.close(error));
+		socket.on("close", () => this.close());
+		this.#heartbeat = setInterval(() => void this.send(FrameType.Heartbeat).catch(() => void 0), heartbeat.interval);
+		this.#heartbeat.unref();
+		this.#watchdog = setTimeout(() => this.close(/* @__PURE__ */ new Error(`No heartbeat for ${heartbeat.timeout}ms`)), heartbeat.timeout);
+		this.#watchdog.unref();
+	}
+	get closed() {
+		return this.#closed;
+	}
+	send(type, payload = Buffer.alloc(0)) {
+		if (this.#closed) return Promise.reject(/* @__PURE__ */ new Error("The connection is closed"));
+		const header = Buffer.allocUnsafe(5);
+		header.writeUInt32BE(payload.length + 1, 0);
+		header.writeUInt8(type, 4);
+		return new Promise((resolve, reject) => {
+			this.socket.write(Buffer.concat([header, payload]), (error) => error ? reject(error) : resolve());
+		});
+	}
+	sendJson(type, value) {
+		return this.send(type, Buffer.from(JSON.stringify(value)));
+	}
+	sendPeer(header, data) {
+		const json = Buffer.from(JSON.stringify(header));
+		const length = Buffer.allocUnsafe(4);
+		length.writeUInt32BE(json.length, 0);
+		const body = typeof data === "string" ? Buffer.from(data) : data;
+		return this.send(FrameType.PeerPacket, Buffer.concat([
+			length,
+			json,
+			body
+		]));
+	}
+	sendData(spawnId, data) {
+		const prefix = Buffer.allocUnsafe(4);
+		prefix.writeUInt32BE(spawnId, 0);
+		if (typeof data === "string") return this.send(FrameType.StringData, Buffer.concat([prefix, Buffer.from(data)]));
+		if (data instanceof Uint8Array) return this.send(FrameType.BinaryData, Buffer.concat([prefix, data]));
+		return Promise.reject(/* @__PURE__ */ new TypeError("Only string or binary data crosses the network: the raw message handler cannot"));
+	}
+	close(error) {
+		if (this.#closed) return;
+		this.#closed = true;
+		clearInterval(this.#heartbeat);
+		clearTimeout(this.#watchdog);
+		this.socket.destroy();
+		this.emit("close", error);
+	}
+	#read(chunk) {
+		this.#watchdog.refresh();
+		this.#buffer = this.#buffer.length === 0 ? chunk : Buffer.concat([this.#buffer, chunk]);
+		while (this.#buffer.length >= 4) {
+			const length = this.#buffer.readUInt32BE(0);
+			if (this.#buffer.length < 4 + length) return;
+			const type = this.#buffer.readUInt8(4);
+			const payload = this.#buffer.subarray(5, 4 + length);
+			this.#buffer = this.#buffer.subarray(4 + length);
+			if (type !== FrameType.Heartbeat) this.emit("frame", type, payload);
+		}
+	}
+};
+/**
+* Reads the spawn ID and the data of a data frame.
+*
+* @internal
+*/
+function readData(type, payload) {
+	const spawnId = payload.readUInt32BE(0);
+	const body = payload.subarray(4);
+	return {
+		spawnId,
+		data: type === FrameType.StringData ? body.toString() : new Uint8Array(body)
+	};
+}
+/**
+* Reads the header and the data of a peer packet.
+*
+* @internal
+*/
+function readPeer(payload) {
+	const length = payload.readUInt32BE(0);
+	const header = JSON.parse(payload.subarray(4, 4 + length).toString());
+	const body = payload.subarray(4 + length);
+	return {
+		header,
+		data: header.binary ? new Uint8Array(body) : body.toString()
+	};
+}
+/**
+* Compares two tokens in constant time.
+*
+* @internal
+*/
+function tokensMatch(expected, actual) {
+	if (typeof actual !== "string") return false;
+	return timingSafeEqual(sha256(expected), sha256(actual));
+}
+function sha256(value) {
+	return createHash("sha256").update(value).digest();
+}
+
+//#endregion
+//#region src/strategies/NetworkStrategy.ts
+/**
+* Spawns shards on other machines, through {@link ShardManagerProxy}s connecting to the manager: the sharder RFC's
+* network strategy.
+*
+* @remarks
+* Each spawn goes to the connected proxy with the most room, as the proxies report it across all the managers they
+* serve; without room, it waits for a proxy, or for the spawn timeout. A proxy losing its connection has
+* `reconnectGrace` to come back with its shards, after which they are spawned elsewhere; its stale shards are killed
+* when it comes back later. Proxies coming back are not rebalanced: they take the next spawns.
+*
+* The strategy keeps the proxies accepting peers informed of which proxy runs which ready shard, so they carry the
+* messages between their shards directly.
+*/
+var NetworkStrategy = class {
+	name = "network";
+	options;
+	/**
+	* The ID of the manager, see {@link NetworkStrategyOptions.id}.
+	*/
+	id;
+	#proxies = /* @__PURE__ */ new Map();
+	#spawns = /* @__PURE__ */ new Map();
+	#pending = [];
+	#server = null;
+	#nextSpawnId = 1;
+	#directoryQueued = false;
+	constructor(options) {
+		this.options = options;
+		this.id = options.id ?? randomUUID();
+	}
+	/**
+	* The proxies, connected or within their reconnect grace.
+	*/
+	get proxies() {
+		return [...this.#proxies.values()].map((proxy) => ({
+			name: proxy.name,
+			host: proxy.host,
+			capacity: proxy.capacity,
+			available: proxy.available,
+			load: proxy.spawns.size,
+			peer: proxy.peer
+		}));
+	}
+	/**
+	* The port the strategy listens on, once initialized.
+	*/
+	get port() {
+		const address = this.#server?.address();
+		return typeof address === "object" && address ? address.port : null;
+	}
+	/**
+	* Drops the connection of a proxy, which reconnects: its shards are kept if it comes back within the grace.
+	*
+	* @param name The name of the proxy.
+	* @returns Whether a proxy of that name was connected.
+	*/
+	disconnectProxy(name) {
+		const connection = this.#proxies.get(name)?.connection;
+		connection?.close();
+		return connection !== void 0 && connection !== null;
+	}
+	async init() {
+		if (this.#server) return;
+		const onSocket = (socket) => this.#accept(socket);
+		const server = this.options.tls ? createServer$1(this.options.tls, onSocket) : createServer(onSocket);
+		await new Promise((resolve, reject) => {
+			server.once("error", reject);
+			server.listen(this.options.port, this.options.host, () => {
+				server.off("error", reject);
+				resolve();
+			});
+		});
+		this.#server = server;
+	}
+	async destroy() {
+		for (const proxy of this.#proxies.values()) proxy.connection?.close();
+		this.#proxies.clear();
+		const server = this.#server;
+		this.#server = null;
+		if (server) await new Promise((resolve) => server.close(() => resolve()));
+	}
+	spawn(context, events, options) {
+		if (context.messageHandler === "raw") throw new TypeError("The raw message handler cannot cross the network");
+		let resolveExit;
+		const spawn = {
+			id: this.#nextSpawnId++,
+			context,
+			env: options.env,
+			events,
+			proxy: null,
+			pid: null,
+			threadId: null,
+			ready: false,
+			exited: false,
+			exit: new Promise((resolve) => {
+				resolveExit = resolve;
+			}),
+			resolveExit: () => resolveExit(),
+			grace: null
+		};
+		this.#spawns.set(spawn.id, spawn);
+		this.#place(spawn);
+		return {
+			get pid() {
+				return spawn.pid;
+			},
+			get threadId() {
+				return spawn.threadId;
+			},
+			get host() {
+				return spawn.proxy?.name ?? null;
+			},
+			send: async (data) => {
+				const connection = spawn.proxy?.connection;
+				if (!connection || connection.closed) throw new Error("The shard's proxy is not connected");
+				await connection.sendData(spawn.id, data);
+			},
+			kill: async () => {
+				if (spawn.exited) return;
+				const connection = spawn.proxy?.connection;
+				if (connection && !connection.closed) {
+					await connection.sendJson(FrameType.Kill, { spawnId: spawn.id }).catch(() => void 0);
+					await Promise.race([spawn.exit, new Promise((resolve) => setTimeout(resolve, 1e4).unref())]);
+				}
+				this.#exit(spawn, null);
+			}
+		};
+	}
+	#place(spawn) {
+		let best = null;
+		for (const proxy of this.#proxies.values()) {
+			if (!proxy.connection || proxy.available <= 0) continue;
+			if (!best || proxy.available / proxy.capacity > best.available / best.capacity) best = proxy;
+		}
+		if (!best) {
+			this.#pending.push(spawn);
+			return;
+		}
+		spawn.proxy = best;
+		best.spawns.add(spawn);
+		best.available--;
+		const frame = {
+			spawnId: spawn.id,
+			context: spawn.context,
+			env: spawn.env
+		};
+		best.connection.sendJson(FrameType.Spawn, frame).catch(() => void 0);
+	}
+	#drain() {
+		const pending = this.#pending.splice(0);
+		for (const spawn of pending) if (!spawn.exited) this.#place(spawn);
+	}
+	#exit(spawn, code) {
+		if (spawn.exited) return;
+		spawn.exited = true;
+		if (spawn.grace) clearTimeout(spawn.grace);
+		const { proxy } = spawn;
+		proxy?.spawns.delete(spawn);
+		if (proxy && !proxy.connection && proxy.spawns.size === 0) this.#proxies.delete(proxy.name);
+		this.#spawns.delete(spawn.id);
+		const index = this.#pending.indexOf(spawn);
+		if (index !== -1) this.#pending.splice(index, 1);
+		spawn.resolveExit();
+		spawn.events.exit(code);
+		if (spawn.ready) this.#queueDirectory();
+		this.#drain();
+	}
+	#accept(socket) {
+		const heartbeat = {
+			interval: this.options.heartbeat?.interval ?? 15e3,
+			timeout: this.options.heartbeat?.timeout ?? 45e3
+		};
+		const connection = new Connection(socket, heartbeat);
+		let proxy = null;
+		connection.on("frame", (type, payload) => {
+			if (!proxy) {
+				proxy = this.#hello(connection, type, payload);
+				return;
+			}
+			this.#frame(proxy, type, payload);
+		});
+		connection.on("close", () => {
+			if (proxy?.connection === connection) this.#lost(proxy);
+		});
+	}
+	#hello(connection, type, payload) {
+		let hello;
+		try {
+			hello = JSON.parse(payload.toString());
+		} catch {
+			connection.close();
+			return null;
+		}
+		if (type !== FrameType.Hello || !tokensMatch(this.options.token, hello.token)) {
+			connection.sendJson(FrameType.Reject, { reason: "Unauthorized" }).finally(() => connection.close());
+			return null;
+		}
+		const known = this.#proxies.get(hello.name);
+		if (known?.connection && !known.connection.closed) {
+			connection.sendJson(FrameType.Reject, { reason: `A proxy named ${hello.name} is connected` }).finally(() => connection.close());
+			return null;
+		}
+		const proxy = known ?? {
+			name: hello.name,
+			host: null,
+			capacity: hello.capacity,
+			available: hello.available,
+			peer: null,
+			connection: null,
+			spawns: /* @__PURE__ */ new Set()
+		};
+		proxy.connection = connection;
+		proxy.capacity = hello.capacity;
+		proxy.available = hello.available;
+		proxy.peer = hello.peer;
+		proxy.host = connection.socket.remoteAddress ?? null;
+		this.#proxies.set(proxy.name, proxy);
+		const running = new Set(hello.running);
+		for (const spawn of proxy.spawns) if (running.has(spawn.id)) {
+			if (spawn.grace) clearTimeout(spawn.grace);
+			spawn.grace = null;
+		} else this.#exit(spawn, null);
+		const welcome = {
+			kill: hello.running.filter((spawnId) => this.#spawns.get(spawnId)?.proxy !== proxy),
+			managerId: this.id
+		};
+		connection.sendJson(FrameType.Welcome, welcome).catch(() => void 0);
+		this.#queueDirectory();
+		this.#drain();
+		return proxy;
+	}
+	#frame(proxy, type, payload) {
+		if (type === FrameType.StringData || type === FrameType.BinaryData) {
+			const { spawnId, data } = readData(type, payload);
+			const spawn = this.#spawns.get(spawnId);
+			if (spawn?.proxy === proxy) spawn.events.message(data);
+			return;
+		}
+		const body = JSON.parse(payload.toString());
+		if (type === FrameType.Load) {
+			proxy.available = body.available ?? proxy.available;
+			this.#drain();
+			return;
+		}
+		const spawn = this.#spawns.get(body.spawnId);
+		if (spawn?.proxy !== proxy) return;
+		switch (type) {
+			case FrameType.Spawned:
+				spawn.pid = body.pid ?? null;
+				spawn.threadId = body.threadId ?? null;
+				break;
+			case FrameType.Status:
+				spawn.ready = body.ready ?? false;
+				this.#queueDirectory();
+				break;
+			case FrameType.Exit:
+				this.#exit(spawn, body.code ?? null);
+				break;
+			case FrameType.Error: spawn.events.error(new Error(body.message));
+		}
+	}
+	#lost(proxy) {
+		proxy.connection = null;
+		const grace = this.options.reconnectGrace ?? 3e4;
+		for (const spawn of proxy.spawns) {
+			spawn.grace = setTimeout(() => this.#exit(spawn, null), grace);
+			spawn.grace.unref();
+		}
+		if (proxy.spawns.size === 0) this.#proxies.delete(proxy.name);
+		this.#queueDirectory();
+	}
+	#queueDirectory() {
+		if (this.#directoryQueued) return;
+		this.#directoryQueued = true;
+		queueMicrotask(() => {
+			this.#directoryQueued = false;
+			this.#sendDirectory();
+		});
+	}
+	#sendDirectory() {
+		const byChannel = /* @__PURE__ */ new Map();
+		for (const spawn of this.#spawns.values()) {
+			if (!spawn.ready || !spawn.proxy?.connection || !spawn.proxy.peer) continue;
+			const current = byChannel.get(spawn.context.id);
+			if (!current || current.id < spawn.id) byChannel.set(spawn.context.id, spawn);
+		}
+		const directory = { entries: [...byChannel.values()].map((spawn) => ({
+			channel: spawn.context.id,
+			proxy: spawn.proxy.name,
+			host: spawn.proxy.peer.host,
+			port: spawn.proxy.peer.port
+		})) };
+		for (const proxy of this.#proxies.values()) if (proxy.connection?.closed === false && proxy.peer) proxy.connection.sendJson(FrameType.Directory, directory).catch(() => void 0);
+	}
+};
+
+//#endregion
+//#region src/strategies/WorkerStrategy.ts
+/**
+* Spawns every shard as a worker thread of the manager's process. Messages are the fastest, but the shards share the
+* process: a crash of the process stops them all.
+*/
+var WorkerStrategy = class {
+	name = "worker";
+	options;
+	constructor(options) {
+		this.options = options;
+	}
+	spawn(context, events, options) {
+		const worker = new Worker(this.options.path, {
+			name: `shard ${context.id}`,
+			...this.options.worker,
+			env: {
+				...process.env,
+				...options.env
+			},
+			workerData: { [ShardContextVariable]: encodeContext({
+				...context,
+				transport: "worker"
+			}) }
+		});
+		worker.on("message", (data) => events.message(data));
+		worker.on("error", (error) => events.error(error));
+		const exit = new Promise((resolve) => {
+			worker.once("exit", (code) => {
+				events.exit(code);
+				resolve();
+			});
+		});
+		return {
+			pid: process.pid,
+			threadId: worker.threadId,
+			send: async (data) => {
+				worker.postMessage(data);
+			},
+			kill: async () => {
+				await worker.terminate();
+				await exit;
+			}
+		};
+	}
+};
+
+//#endregion
+//#region src/strategies/registry.ts
+const strategies = /* @__PURE__ */ new Map([
+	["fork", (options) => new ForkStrategy(options)],
+	["cluster", (options) => new ClusterStrategy(options)],
+	["worker", (options) => new WorkerStrategy(options)],
+	["network", (options) => new NetworkStrategy(options)]
+]);
+/**
+* Registers a strategy under a name, so managers and proxies can be given its name, like the built-in `"fork"`,
+* `"cluster"`, `"worker"`, and `"network"`.
+*
+* @param name The name of the strategy.
+* @param factory Builds the strategy from the `strategyOptions`.
+*/
+function registerStrategy(name, factory) {
+	strategies.set(name, factory);
+}
+/**
+* Resolves a strategy, or the name of a registered one.
+*
+* @param strategy The strategy, or its name.
+* @param options The options of a named strategy.
+*/
+function resolveStrategy(strategy, options) {
+	if (typeof strategy !== "string") return strategy;
+	const factory = strategies.get(strategy);
+	if (!factory) throw new RangeError(`There is no strategy named "${strategy}"`);
+	return factory(options ?? {});
+}
+
+//#endregion
+//#region src/util/gateway.ts
+/**
+* Fetches `GET /gateway/bot`.
+*
+* @param token The bot token.
+*/
+async function fetchGatewayInformation(token) {
+	const response = await fetch("https://discord.com/api/v10/gateway/bot", { headers: { Authorization: `Bot ${token.replace(/^Bot\s*/i, "")}` } });
+	if (!response.ok) throw new Error(`Could not fetch the gateway information: ${response.status} ${response.statusText}`);
+	return await response.json();
+}
+/**
+* Turns Discord's recommended shard count into the one to spawn.
+*
+* @param recommended The `shards` of `GET /gateway/bot`.
+* @param options How many guilds per gateway shard, and what to round the count up to.
+*/
+function resolveRecommendedShardCount(recommended, options = {}) {
+	const { guildsPerShard = 1e3, multipleOf = 1 } = options;
+	return Math.ceil(recommended * (1e3 / guildsPerShard) / multipleOf) * multipleOf;
+}
+/**
+* Fetches how many gateway shards Discord recommends for the bot, like discord.js's `fetchRecommendedShardCount`.
+*
+* @param token The bot token.
+* @param options How many guilds per gateway shard, and what to round the count up to.
+*/
+async function fetchRecommendedShardCount(token, options) {
+	const { shards } = await fetchGatewayInformation(token);
+	return resolveRecommendedShardCount(shards, options);
+}
+/**
+* Gets the gateway shard receiving the events of a guild.
+*
+* @param guildId The ID of the guild.
+* @param shardCount The total number of gateway shards.
+*/
+function shardIdForGuild(guildId, shardCount) {
+	return Number((BigInt(guildId) >> 22n) % BigInt(shardCount));
+}
+/**
+* Caches `GET /gateway/bot`, so the shards share one request instead of each sending theirs, and keeps its session
+* start limit up to date with the identifies it grants.
+*
+* @internal
+*/
+var GatewayInformationCache = class {
+	#fetch;
+	#ttl;
+	#value = null;
+	#fetchedAt = 0;
+	#resetAt = 0;
+	#pending = null;
+	constructor(fetcher, ttl) {
+		this.#fetch = fetcher;
+		this.#ttl = ttl;
+	}
+	async get(force = false) {
+		const now = Date.now();
+		if (!force && this.#value && now - this.#fetchedAt < this.#ttl) return this.#current(now);
+		this.#pending ??= this.#fetch().then((value) => {
+			this.#value = structuredClone(value);
+			this.#fetchedAt = Date.now();
+			this.#resetAt = this.#fetchedAt + value.session_start_limit.reset_after;
+			return value;
+		}).finally(() => {
+			this.#pending = null;
+		});
+		await this.#pending;
+		return this.#current(Date.now());
+	}
+	/**
+	* Counts an identify against the session start limit.
+	*/
+	consume() {
+		if (!this.#value) return;
+		this.#current(Date.now());
+		this.#value.session_start_limit.remaining = Math.max(this.#value.session_start_limit.remaining - 1, 0);
+	}
+	#current(now) {
+		const value = this.#value;
+		const limit = value.session_start_limit;
+		if (now >= this.#resetAt) {
+			limit.remaining = limit.total;
+			this.#resetAt = now + 864e5;
+		}
+		limit.reset_after = Math.max(this.#resetAt - now, 0);
+		return structuredClone(value);
+	}
+};
+
+//#endregion
+//#region src/util/IdentifyQueue.ts
+/**
+* Hands out the turns of gateway shards to identify, across every process: Discord allows one identify per
+* `max_concurrency` bucket (`shardId % max_concurrency`) every 5 seconds.
+*
+* @internal
+*/
+var IdentifyQueue = class {
+	#delay;
+	#buckets = /* @__PURE__ */ new Map();
+	#concurrency;
+	constructor(concurrency, delay) {
+		this.#concurrency = concurrency;
+		this.#delay = delay;
+	}
+	set concurrency(value) {
+		this.#concurrency = Math.max(1, value);
+	}
+	get concurrency() {
+		return this.#concurrency;
+	}
+	/**
+	* Resolves once the gateway shard may identify. Aborting it drops it from the queue.
+	*
+	* @param shardId The ID of the gateway shard.
+	* @param signal Aborts the wait.
+	*/
+	wait(shardId, signal) {
+		const bucket = shardId % this.#concurrency;
+		const previous = this.#buckets.get(bucket) ?? Promise.resolve();
+		let release;
+		const released = new Promise((resolve) => {
+			release = resolve;
+		});
+		this.#buckets.set(bucket, previous.then(() => released));
+		return new Promise((resolve, reject) => {
+			const onAbort = () => {
+				release();
+				reject(signal.reason);
+			};
+			signal?.addEventListener("abort", onAbort, { once: true });
+			previous.then(() => {
+				signal?.removeEventListener("abort", onAbort);
+				if (signal?.aborted) return;
+				resolve();
+				setTimeout$1(this.#delay, void 0, { ref: false }).then(release);
+			});
+		});
+	}
+};
+
+//#endregion
+//#region src/util/Supervisor.ts
+/**
+* Counts the crashes of each shard against the supervisor's intensity.
+*
+* @internal
+*/
+var Supervisor = class {
+	intensity;
+	period;
+	strategy;
+	#crashes = /* @__PURE__ */ new Map();
+	constructor(options = {}) {
+		const { intensity = -1, period = 0, strategy = "one-for-one" } = options;
+		if (intensity !== -1 && intensity !== Number.POSITIVE_INFINITY) {
+			if (!Number.isSafeInteger(intensity) || intensity < 0) throw new RangeError("supervisor.intensity must be a non-negative integer, -1, or Infinity");
+		}
+		this.intensity = intensity === Number.POSITIVE_INFINITY ? -1 : intensity;
+		this.period = period;
+		this.strategy = strategy;
+	}
+	/**
+	* Counts a crash. Returns how many crashes count, and whether the shard may be restarted.
+	*
+	* @param channelId The ID of the crashed shard.
+	*/
+	crash(channelId) {
+		const now = Date.now();
+		const crashes = (this.#crashes.get(channelId) ?? []).filter((timestamp) => this.period === 0 || now - timestamp < this.period);
+		crashes.push(now);
+		this.#crashes.set(channelId, crashes);
+		return {
+			crashes: crashes.length,
+			restart: this.intensity === -1 || crashes.length <= this.intensity
+		};
+	}
+	/**
+	* Forgets the crashes of a shard that is ready again, when they are counted in a row.
+	*
+	* @param channelId The ID of the shard.
+	*/
+	ready(channelId) {
+		if (this.period === 0) this.#crashes.delete(channelId);
+	}
+};
+
+//#endregion
+//#region src/ShardManager.ts
+/**
+* Spawns shards, keeps them alive, and carries messages between them.
+*
+* @remarks
+* Follows discord.js's sharder RFC (discordjs/discord.js#8084): a "shard" is a process, cluster worker, worker
+* thread, or remote process, which may connect several gateway shards, and the manager talks to each through a
+* {@link ShardChannel}. The manager is agnostic of the bot: a shard runs any script using {@link ShardClient}.
+*
+* @example
+* ```ts
+* const manager = new ShardManager({ strategy: new ForkStrategy({ path: "./bot.js" }), clusters: 4 });
+* manager.setRequestHandler((body, { channel }) => ...);
+* await manager.spawn();
+* const guilds = await manager.broadcastRequest({ type: "guildCount" });
+* ```
+*/
+var ShardManager = class extends EventEmitter {
+	strategy;
+	/**
+	* The channels to the shards, by ID. Empty until {@link ShardManager.spawn} for `"auto"` layouts.
+	*/
+	channels = [];
+	/**
+	* The total number of gateway shards, `0` until resolved for `"auto"` layouts.
+	*/
+	shardCount = 0;
+	spawnDelay;
+	spawnTimeout;
+	readyHint;
+	readyHintMargin;
+	requestTimeout;
+	pingOptions;
+	/**
+	* @internal
+	*/
+	codec;
+	/**
+	* @internal
+	*/
+	supervisor;
+	/**
+	* @internal
+	*/
+	spawnEnv;
+	/**
+	* @internal
+	*/
+	requestHandler = null;
+	#layout;
+	#token;
+	#gateway;
+	#identify;
+	#identifyConcurrency;
+	#readyTimes = [];
+	#queue = Promise.resolve();
+	#initialized = false;
+	constructor(options = {}) {
+		super();
+		this.strategy = resolveStrategy(options.strategy ?? "fork", options.strategyOptions);
+		this.supervisor = new Supervisor(options.supervisor);
+		this.spawnDelay = options.spawn?.delay ?? 5e3;
+		this.spawnTimeout = options.spawn?.timeout ?? 3e4;
+		this.readyHint = options.spawn?.readyHint ?? null;
+		this.readyHintMargin = options.spawn?.readyHintMargin ?? .1;
+		this.pingOptions = {
+			interval: options.ping?.interval ?? 45e3,
+			timeout: options.ping?.timeout ?? 6e4,
+			delaySinceReceived: options.ping?.delaySinceReceived ?? false
+		};
+		this.requestTimeout = options.requestTimeout ?? this.pingOptions.timeout;
+		this.codec = new PacketCodec(resolveMessageHandler(options.messageHandler ?? "json"), (options.transformers ?? []).map(resolveMessageTransformer));
+		if (this.codec.handler.name === "raw" && this.codec.transformers.length > 0) throw new TypeError("The raw message handler cannot be combined with transformers");
+		this.#token = options.token ?? process.env.DISCORD_TOKEN ?? null;
+		this.spawnEnv = options.token ? { DISCORD_TOKEN: options.token } : {};
+		const fetcher = options.gatewayInformation?.fetch ?? (this.#token ? () => fetchGatewayInformation(this.#token) : null);
+		this.#gateway = fetcher ? new GatewayInformationCache(fetcher, options.gatewayInformation?.ttl ?? 864e5) : null;
+		this.#identifyConcurrency = options.identify?.concurrency ?? "auto";
+		this.#identify = new IdentifyQueue(this.#identifyConcurrency === "auto" ? 1 : this.#identifyConcurrency, options.identify?.delay ?? 5e3);
+		this.#layout = {
+			shards: options.shards,
+			totalShards: options.totalShards,
+			shardList: options.shardList,
+			clusters: options.clusters,
+			recommended: options.recommended
+		};
+		if (!needsGateway(this.#layout)) this.#apply(resolveLayout(this.#layout, null));
+	}
+	/**
+	* How long a shard is expected to take to be ready: `spawn.readyHint`, or the average of the shards so far.
+	*/
+	get readyEstimate() {
+		if (this.readyHint !== null) return this.readyHint;
+		if (this.#readyTimes.length === 0) return null;
+		return this.#readyTimes.reduce((sum, time) => sum + time, 0) / this.#readyTimes.length;
+	}
+	/**
+	* Spawns every shard, one after the other, each waiting for the previous one to be ready plus the spawn delay. A
+	* shard not ready in time is killed and tried again at the end of the queue, as long as the supervisor allows.
+	*/
+	async spawn() {
+		if (this.channels.length === 0) {
+			const info = needsGateway(this.#layout) ? await this.fetchGatewayInformation() : null;
+			this.#apply(resolveLayout(this.#layout, info));
+		}
+		await this.#init();
+		await Promise.all(this.channels.map((channel) => this.#startWithRetries(channel)));
+	}
+	/**
+	* Fetches `GET /gateway/bot`, cached for every shard, with its session start limit kept up to date.
+	*
+	* @param force Whether to skip the cache.
+	*/
+	async fetchGatewayInformation(force = false) {
+		if (!this.#gateway) throw new Error("Fetching the gateway information needs a token, or gatewayInformation.fetch");
+		return this.#gateway.get(force);
+	}
+	/**
+	* Gets the channel to the shard connecting a gateway shard.
+	*
+	* @param shardId The ID of the gateway shard.
+	*/
+	channelFor(shardId) {
+		return this.channels.find((channel) => channel.shards.includes(shardId));
+	}
+	/**
+	* Gets the channel to the shard receiving the events of a guild.
+	*
+	* @param guildId The ID of the guild.
+	*/
+	channelForGuild(guildId) {
+		return this.channelFor(shardIdForGuild(guildId, this.shardCount));
+	}
+	/**
+	* Sets the handler answering the requests the shards send to the manager.
+	*
+	* @param handler The handler; its return value is the reply.
+	*/
+	setRequestHandler(handler) {
+		this.requestHandler = handler;
+		return this;
+	}
+	/**
+	* Sends a message to a shard, emitted as `message` by its {@link ShardClient}.
+	*
+	* @param channelId The ID of the shard.
+	* @param body The message.
+	* @param options How long to wait for the shard to be ready, and an abort signal.
+	*/
+	send(channelId, body, options) {
+		return this.#channel(channelId).send(body, options);
+	}
+	/**
+	* Sends a request to a shard, answered by its {@link ShardClient}'s request handler.
+	*
+	* @param channelId The ID of the shard.
+	* @param body The request.
+	* @param options The timeout and abort signal of the request.
+	*/
+	request(channelId, body, options) {
+		return this.#channel(channelId).request(body, options);
+	}
+	/**
+	* Sends a message to every shard.
+	*
+	* @param body The message.
+	* @param options How long to wait for the shards to be ready, and an abort signal.
+	*/
+	async broadcast(body, options) {
+		await Promise.all(this.channels.map((channel) => channel.send(body, options)));
+	}
+	broadcastRequest(body, options = {}) {
+		const requests = this.channels.map((channel) => channel.request(body, options));
+		return options.partial ? Promise.allSettled(requests) : Promise.all(requests);
+	}
+	/**
+	* {@link ShardManager.send}, resolving with a `Result` rather than rejecting.
+	*/
+	trySend(channelId, body, options) {
+		return toResult(() => this.send(channelId, body, options));
+	}
+	/**
+	* {@link ShardManager.request}, resolving with a `Result` rather than rejecting.
+	*/
+	tryRequest(channelId, body, options) {
+		return toResult(() => this.request(channelId, body, options));
+	}
+	/**
+	* {@link ShardManager.broadcastRequest}, resolving with one `Result` per shard, by shard ID.
+	*/
+	async tryBroadcastRequest(body, options) {
+		return settledToResults(await this.broadcastRequest(body, {
+			...options,
+			partial: true
+		}));
+	}
+	/**
+	* Restarts a shard: closes it then spawns it again, or with `rolling`, spawns the new one first and closes the old
+	* one once the new one is ready.
+	*
+	* @param channelId The ID of the shard.
+	* @param options Whether to restart it rolling, and the timeout.
+	*/
+	async restart(channelId, options = {}) {
+		const channel = this.#channel(channelId);
+		this.emit("shardRestart", channel);
+		if (options.rolling) {
+			await this.#enqueue(() => channel.rollingRestart(options.timeout));
+			return;
+		}
+		await channel.close(options.timeout);
+		await this.#startWithRetries(channel, true);
+	}
+	/**
+	* Restarts every shard, one after the other, with the spawn delay between them.
+	*
+	* @param options Whether to restart them rolling, and the timeout.
+	*/
+	async restartAll(options) {
+		for (const channel of this.channels) await this.restart(channel.id, options);
+	}
+	/**
+	* Reshards with close to no downtime: spawns the shards of a new layout while the current ones keep running, then
+	* closes the current ones once every new one is ready.
+	*
+	* @param layout The new layout. Left out, Discord's recommendation split across `clusters`.
+	*/
+	async reshard(layout = { shards: "auto" }) {
+		const resolved = resolveLayout(layout, needsGateway(layout) ? await this.fetchGatewayInformation(true) : null);
+		const channels = resolved.channels.map((shards, id) => new ShardChannel(this, id, shards, resolved.shardCount));
+		try {
+			await Promise.all(channels.map((channel) => this.#startWithRetries(channel)));
+		} catch (error) {
+			await Promise.all(channels.map((channel) => channel.close()));
+			throw error;
+		}
+		const previous = this.channels;
+		this.channels = channels;
+		this.shardCount = resolved.shardCount;
+		await Promise.all(previous.map((channel) => channel.close()));
+	}
+	/**
+	* Asks the shard connecting a gateway shard to start it, through its {@link ShardClient.setShardHandler}.
+	*
+	* @param shardId The ID of the gateway shard.
+	* @param options The timeout and abort signal of the request.
+	*/
+	startShard(shardId, options) {
+		return this.#channelForShard(shardId).startShard(shardId, options);
+	}
+	/**
+	* Asks the shard connecting a gateway shard to close it, through its {@link ShardClient.setShardHandler}.
+	*
+	* @param shardId The ID of the gateway shard.
+	* @param options The timeout and abort signal of the request.
+	*/
+	closeShard(shardId, options) {
+		return this.#channelForShard(shardId).closeShard(shardId, options);
+	}
+	/**
+	* Closes then starts a gateway shard, see {@link ShardManager.startShard}.
+	*
+	* @param shardId The ID of the gateway shard.
+	* @param options The timeout and abort signal of each request.
+	*/
+	async restartShard(shardId, options) {
+		await this.closeShard(shardId, options);
+		await this.startShard(shardId, options);
+	}
+	/**
+	* Waits for a gateway shard's turn to identify, like {@link ShardClient.identifyThrottler} does from a shard.
+	*
+	* @param shardId The ID of the gateway shard.
+	* @param signal Aborts the wait.
+	*/
+	async waitForIdentify(shardId, signal) {
+		if (this.#identifyConcurrency === "auto" && this.#gateway) {
+			const info = await this.fetchGatewayInformation();
+			this.#identify.concurrency = info.session_start_limit.max_concurrency;
+		}
+		await this.#identify.wait(shardId, signal);
+		this.#gateway?.consume();
+	}
+	/**
+	* Closes every shard for good, and releases the strategy.
+	*/
+	async destroy() {
+		await Promise.all(this.channels.map((channel) => channel.close()));
+		if (this.#initialized) await this.strategy.destroy?.();
+		this.#initialized = false;
+	}
+	/**
+	* Carries a message a shard sends to another shard, or to every shard.
+	*
+	* @internal
+	*/
+	async route(body, to, from) {
+		if (to === "all") await Promise.all(this.channels.map((channel) => channel.send(body, {}, from)));
+		else await this.#channel(to).send(body, {}, from);
+	}
+	/**
+	* Carries a request a shard sends to another shard, or to every shard.
+	*
+	* @internal
+	*/
+	async forward(body, to, from, options) {
+		const forwarded = {
+			timeout: options.timeout === void 0 ? void 0 : Math.max(Math.floor(options.timeout * .95), 1),
+			signal: options.signal
+		};
+		if (to !== "all") return this.#channel(to).request(body, forwarded, from);
+		const requests = this.channels.map((channel) => channel.request(body, forwarded, from));
+		return options.partial ? serializeSettled(await Promise.allSettled(requests)) : Promise.all(requests);
+	}
+	/**
+	* Answers the requests the sharder itself sends.
+	*
+	* @internal
+	*/
+	async handleSystem(call, body, channel, signal) {
+		switch (call) {
+			case "identify":
+				await this.waitForIdentify(body, signal);
+				return null;
+			case "gatewayInformation": return this.fetchGatewayInformation();
+			case "control": return this.#control(body, channel);
+			default: throw new Error(`Shards cannot send the ${call} system request`);
+		}
+	}
+	/**
+	* Decides what happens to a shard that stopped on its own.
+	*
+	* @internal
+	*/
+	supervise(channel, previous) {
+		if (previous === "Exiting") {
+			channel.markStopped("it exited");
+			return;
+		}
+		if (previous !== "Restarting") {
+			const { crashes, restart } = this.supervisor.crash(channel.id);
+			if (!restart) {
+				channel.markStopped("it crashed too often");
+				if (this.listenerCount("shardGiveUp") > 0) this.emit("shardGiveUp", channel, crashes);
+				else this.reportError(new ShardUnavailableError(channel.id, `it crashed ${crashes} times`));
+				return;
+			}
+			const others = this.supervisor.strategy === "one-for-all" ? this.channels.filter((other) => other !== channel) : this.supervisor.strategy === "rest-for-one" ? this.channels.filter((other) => other.id > channel.id) : [];
+			for (const other of others) if (!other.stopped) this.restart(other.id).catch((error) => this.reportError(error));
+		}
+		this.emit("shardRestart", channel);
+		this.#startWithRetries(channel).catch((error) => this.reportError(error));
+	}
+	/**
+	* @internal
+	*/
+	recordReadyTime(time) {
+		this.#readyTimes.push(time);
+		if (this.#readyTimes.length > 20) this.#readyTimes.shift();
+	}
+	/**
+	* @internal
+	*/
+	reportError(error) {
+		if (this.listenerCount("error") > 0) this.emit("error", error);
+		else console.error(error);
+	}
+	/**
+	* @internal
+	*/
+	reportShardError(channel, error) {
+		if (channel.listenerCount("error") > 0) channel.emit("error", error);
+		if (this.listenerCount("shardError") > 0) this.emit("shardError", channel, error);
+		else if (channel.listenerCount("error") === 0) this.reportError(error);
+	}
+	/**
+	* @internal
+	*/
+	reportInvalidMessage(channel, error) {
+		if (this.listenerCount("shardInvalidMessage") > 0) this.emit("shardInvalidMessage", channel, error);
+		else console.error(`Shard ${channel.id} sent an invalid message:`, error);
+	}
+	async #control(request, from) {
+		const { action, target } = request;
+		if ("shard" in target) {
+			if (action === "start") await this.startShard(target.shard);
+			else if (action === "close") await this.closeShard(target.shard);
+			else await this.restartShard(target.shard);
+			return null;
+		}
+		const channels = target.channel === "all" ? this.channels : [this.#channel(target.channel)];
+		const run = async () => {
+			for (const channel of channels) if (action === "restart") await this.restart(channel.id);
+			else if (action === "close") await channel.close();
+			else if (!channel.running) await this.#startWithRetries(channel, true);
+		};
+		if (action !== "start" && channels.includes(from)) setImmediate(() => void run().catch((error) => this.reportError(error)));
+		else await run();
+		return null;
+	}
+	async #init() {
+		if (this.#initialized) return;
+		await this.strategy.init?.();
+		this.#initialized = true;
+	}
+	async #startWithRetries(channel, force = false) {
+		await this.#init();
+		for (;;) try {
+			await this.#enqueue(async () => {
+				if (!force && channel.stopped || channel.running) return;
+				await channel.start();
+			});
+			return;
+		} catch (error) {
+			if (channel.stopped) throw error;
+			const { restart } = this.supervisor.crash(channel.id);
+			if (!restart) {
+				channel.markStopped("it failed to start too often");
+				throw error;
+			}
+		}
+	}
+	#enqueue(task) {
+		const run = this.#queue.then(task);
+		this.#queue = run.then(() => setTimeout$1(this.spawnDelay), () => setTimeout$1(this.spawnDelay));
+		return run;
+	}
+	#apply(layout) {
+		this.shardCount = layout.shardCount;
+		this.channels = layout.channels.map((shards, id) => new ShardChannel(this, id, shards, layout.shardCount));
+	}
+	#channel(channelId) {
+		const channel = this.channels[channelId];
+		if (!channel) throw new ShardUnavailableError(channelId, "there is no such shard");
+		return channel;
+	}
+	#channelForShard(shardId) {
+		const channel = this.channelFor(shardId);
+		if (!channel) throw new RangeError(`No shard connects the gateway shard ${shardId}`);
+		return channel;
+	}
+};
+function needsGateway(layout) {
+	return layout.totalShards === "auto" || layout.totalShards === void 0 && (layout.shards ?? "auto") === "auto" && !layout.shardList;
+}
+function resolveLayout(layout, info) {
+	const { shards = "auto", shardList, clusters = availableParallelism() } = layout;
+	const recommended = info ? resolveRecommendedShardCount(info.shards, layout.recommended) : null;
+	const sizes = Array.isArray(shards) ? shards : null;
+	if (sizes?.some((size) => !Number.isSafeInteger(size) || size < 1) || sizes?.length === 0) throw new RangeError("shards must list positive integers");
+	const declared = typeof shards === "number" ? shards : sizes ? sizes.reduce((sum, size) => sum + size, 0) : null;
+	const totalShards = layout.totalShards === "auto" ? recommended : layout.totalShards ?? declared ?? shardList?.length ?? recommended;
+	if (!Number.isSafeInteger(totalShards) || totalShards < 1) throw new RangeError("The total number of gateway shards must be a positive integer");
+	const ids = shardList ? [...shardList] : range(declared ?? totalShards);
+	if (new Set(ids).size !== ids.length || ids.some((id) => id < 0 || id >= totalShards)) throw new RangeError(`shardList must list distinct gateway shards below ${totalShards}`);
+	let channels;
+	if (sizes) {
+		if (ids.length !== declared) throw new RangeError("shards must add up to the shardList's length");
+		let offset = 0;
+		channels = sizes.map((size) => ids.slice(offset, offset += size));
+	} else if (typeof shards === "number") {
+		if (ids.length !== shards) throw new RangeError("shards must be the shardList's length");
+		channels = ids.map((id) => [id]);
+	} else {
+		if (!Number.isSafeInteger(clusters) || clusters < 1) throw new RangeError("clusters must be a positive integer");
+		const size = Math.ceil(ids.length / clusters);
+		channels = [];
+		for (let index = 0; index < ids.length; index += size) channels.push(ids.slice(index, index + size));
+	}
+	return {
+		shardCount: totalShards,
+		channels
+	};
+}
+function range(length) {
+	return Array.from({ length }, (_, index) => index);
+}
+
+//#endregion
+//#region src/ShardManagerProxy.ts
+/**
+* Runs shards for remote {@link ShardManager}s using a {@link NetworkStrategy}: the sharder RFC's
+* `ShardManagerProxy`. It spawns them locally with its own strategy, carries their messages to their manager, and
+* carries the messages between shards of the same manager directly, locally or through peer proxies.
+*
+* @example
+* ```ts
+* const proxy = new ShardManagerProxy({
+*   managers: ["manager.internal:7000", "manager-backup.internal:7000"],
+*   token: process.env.SHARDER_TOKEN!,
+*   tls: { ca: readFileSync("ca.pem") },
+*   strategy: new ForkStrategy({ path: "./bot.js" }),
+*   capacity: 8,
+*   peer: { port: 7001 },
+* });
+* await proxy.connect();
+* ```
+*/
+var ShardManagerProxy = class extends EventEmitter {
+	name;
+	capacity;
+	strategy;
+	managers;
+	mode;
+	#options;
+	#links;
+	#shards = /* @__PURE__ */ new Map();
+	#byChannel = /* @__PURE__ */ new Map();
+	#routes = /* @__PURE__ */ new Map();
+	#peerRequests = /* @__PURE__ */ new Map();
+	#peers = /* @__PURE__ */ new Map();
+	#connecting = /* @__PURE__ */ new Set();
+	#inbound = /* @__PURE__ */ new Set();
+	#codecs = /* @__PURE__ */ new Map();
+	#peerServer = null;
+	#peerAddress = null;
+	#destroyed = false;
+	#nextNonce = 0;
+	constructor(options) {
+		super();
+		if (options.managers.length === 0) throw new RangeError("A proxy needs at least one manager");
+		if (options.peer && options.localRouting === false) throw new TypeError("Peer routing needs local routing");
+		this.#options = options;
+		this.name = options.name ?? `${hostname()}:${process.pid}`;
+		this.capacity = options.capacity ?? availableParallelism();
+		this.strategy = resolveStrategy(options.strategy ?? "fork", options.strategyOptions);
+		this.managers = options.managers.map(parseAddress);
+		this.mode = options.mode ?? "failover";
+		this.#links = this.mode === "all" ? this.managers.map((address, index) => createLink([address], index)) : [createLink(this.managers, 0)];
+	}
+	/**
+	* The managers the proxy is connected to.
+	*/
+	get connectedManagers() {
+		return this.#links.flatMap((link) => link.connection && link.address ? [link.address] : []);
+	}
+	/**
+	* The manager the proxy is connected to in `"failover"` mode, `null` while it is not.
+	*/
+	get manager() {
+		return this.connectedManagers[0] ?? null;
+	}
+	/**
+	* The contexts of the shards the proxy runs.
+	*/
+	get shards() {
+		return [...this.#shards.values()].map((shard) => shard.context);
+	}
+	/**
+	* Where other proxies reach this one, once connected with `peer`.
+	*/
+	get peerAddress() {
+		return this.#peerAddress;
+	}
+	/**
+	* The names of the proxies this one has a peer connection with.
+	*/
+	get peers() {
+		return [...new Set([...this.#peers.values(), ...this.#inbound].map((peer) => peer.name))];
+	}
+	/**
+	* Connects to the managers, and keeps reconnecting whenever a connection is lost, until
+	* {@link ShardManagerProxy.destroy}. Resolves once connected to a first manager.
+	*/
+	async connect() {
+		await this.strategy.init?.();
+		await this.#listenPeers();
+		await new Promise((resolve) => {
+			this.once("connect", () => resolve());
+			for (const link of this.#links) this.#loop(link);
+		});
+	}
+	/**
+	* Stops every shard, and disconnects for good.
+	*/
+	async destroy() {
+		this.#destroyed = true;
+		for (const link of this.#links) link.connection?.close();
+		await Promise.all([...this.#shards.values()].map((shard) => shard.transport.kill()));
+		for (const peer of [...this.#peers.values(), ...this.#inbound]) peer.connection.close();
+		const server = this.#peerServer;
+		this.#peerServer = null;
+		if (server) await new Promise((resolve) => server.close(() => resolve()));
+		await this.strategy.destroy?.();
+	}
+	async #loop(link) {
+		for (let attempt = 0; !this.#destroyed; ++attempt) {
+			const address = link.addresses[attempt % link.addresses.length];
+			const error = await this.#session(link, address);
+			if (this.#destroyed) return;
+			if (error !== void 0) this.emit("disconnect", address, error ?? void 0);
+			await setTimeout$1(this.#options.reconnectDelay ?? 5e3);
+		}
+	}
+	#session(link, address) {
+		return new Promise((resolve) => {
+			const tls = address.tls ?? this.#options.tls;
+			const socket = tls ? connect$1({
+				...tls === true ? {} : tls,
+				host: address.host,
+				port: address.port
+			}) : connect({
+				host: address.host,
+				port: address.port
+			});
+			socket.once("error", () => resolve(void 0));
+			socket.once(tls ? "secureConnect" : "connect", () => {
+				socket.removeAllListeners("error");
+				const connection = new Connection(socket, this.#heartbeat());
+				let welcomed = false;
+				connection.on("frame", (type, payload) => {
+					if (welcomed) this.#frame(link, type, payload);
+					else if (type === FrameType.Welcome) {
+						welcomed = true;
+						this.#welcome(link, address, connection, JSON.parse(payload.toString()));
+					} else if (type === FrameType.Reject) {
+						const { reason } = JSON.parse(payload.toString());
+						this.emit("reject", address, reason);
+						connection.close();
+					}
+				});
+				connection.on("close", (error) => {
+					if (link.connection === connection) this.#lost(link);
+					resolve(welcomed ? error ?? null : void 0);
+				});
+				const hello = {
+					token: address.token ?? this.#options.token,
+					name: this.name,
+					capacity: this.capacity,
+					available: this.#available(),
+					running: [...this.#shards.values()].filter((shard) => shard.link === link).map((shard) => shard.spawnId),
+					peer: this.#peerAddress
+				};
+				connection.sendJson(FrameType.Hello, hello).catch(() => void 0);
+			});
+		});
+	}
+	#welcome(link, address, connection, welcome) {
+		const kill = new Set(welcome.kill);
+		for (const shard of this.#shards.values()) if (shard.link === link && kill.has(shard.spawnId)) shard.transport.kill();
+		link.connection = connection;
+		link.address = address;
+		link.managerId = welcome.managerId;
+		this.emit("connect", address);
+	}
+	#lost(link) {
+		link.connection = null;
+		link.directory.clear();
+		if (this.#options.managerLoss === "exit") {
+			for (const shard of this.#shards.values()) if (shard.link === link) shard.transport.kill();
+		}
+	}
+	#frame(link, type, payload) {
+		switch (type) {
+			case FrameType.StringData:
+			case FrameType.BinaryData: {
+				const { spawnId, data } = readData(type, payload);
+				this.#shards.get(shardKey(link, spawnId))?.transport.send(data).catch(() => void 0);
+				break;
+			}
+			case FrameType.Spawn:
+				this.#spawn(link, JSON.parse(payload.toString()));
+				break;
+			case FrameType.Kill: {
+				const { spawnId } = JSON.parse(payload.toString());
+				const shard = this.#shards.get(shardKey(link, spawnId));
+				if (shard) shard.transport.kill();
+				else this.#report(link, FrameType.Exit, {
+					spawnId,
+					code: null
+				});
+				break;
+			}
+			case FrameType.Directory: {
+				const { entries } = JSON.parse(payload.toString());
+				link.directory = new Map(entries.map(({ channel, ...entry }) => [channel, entry]));
+				break;
+			}
+		}
+	}
+	#spawn(link, frame) {
+		const context = frame.context;
+		const key = shardKey(link, frame.spawnId);
+		if (this.#shards.size >= this.capacity) {
+			this.#report(link, FrameType.Error, {
+				spawnId: frame.spawnId,
+				message: "The proxy is full"
+			});
+			this.#report(link, FrameType.Exit, {
+				spawnId: frame.spawnId,
+				code: null
+			});
+			return;
+		}
+		let shard = null;
+		try {
+			const transport = this.strategy.spawn(context, {
+				message: (data) => void this.#fromShard(shard, data),
+				exit: (code) => this.#exited(shard, code),
+				error: (error) => {
+					this.#report(link, FrameType.Error, {
+						spawnId: frame.spawnId,
+						message: serializeError(error).message
+					});
+				}
+			}, { env: frame.env });
+			shard = {
+				key,
+				link,
+				scope: link.managerId,
+				spawnId: frame.spawnId,
+				context,
+				transport,
+				ready: false,
+				exited: false
+			};
+		} catch (error) {
+			this.#report(link, FrameType.Error, {
+				spawnId: frame.spawnId,
+				message: serializeError(error).message
+			});
+			this.#report(link, FrameType.Exit, {
+				spawnId: frame.spawnId,
+				code: null
+			});
+			return;
+		}
+		this.#shards.set(key, shard);
+		this.#byChannel.set(channelKey(shard.scope, context.id), shard);
+		this.#report(link, FrameType.Spawned, {
+			spawnId: frame.spawnId,
+			pid: shard.transport.pid ?? null,
+			threadId: shard.transport.threadId ?? null
+		});
+		this.#reportLoad();
+		this.emit("spawn", context);
+	}
+	#exited(shard, code) {
+		shard.exited = true;
+		this.#shards.delete(shard.key);
+		const key = channelKey(shard.scope, shard.context.id);
+		if (this.#byChannel.get(key) === shard) this.#byChannel.delete(key);
+		const stopped = serializeError(new ShardUnavailableError(shard.context.id, "it stopped"));
+		for (const [nonce, route] of this.#routes) if (route.target === shard) {
+			this.#routes.delete(nonce);
+			this.#toEndpoint(route.origin, shard, {
+				op: Op.Reply,
+				nonce: route.originNonce,
+				error: stopped
+			});
+		} else if ("shard" in route.origin && route.origin.shard === shard) {
+			this.#routes.delete(nonce);
+			this.#toShard(route.target, {
+				op: Op.Abort,
+				nonce
+			});
+		}
+		for (const [requestKey, request] of this.#peerRequests) {
+			if (request.origin !== shard) continue;
+			this.#peerRequests.delete(requestKey);
+			const nonce = Number(requestKey.slice(requestKey.lastIndexOf(":") + 1));
+			this.#abortPeerRequest(request, nonce);
+		}
+		this.#report(shard.link, FrameType.Exit, {
+			spawnId: shard.spawnId,
+			code
+		});
+		this.#reportLoad();
+		this.emit("exit", shard.context, code);
+	}
+	async #fromShard(shard, data) {
+		if (this.#options.localRouting !== false) {
+			let packet = null;
+			try {
+				packet = await this.#codec(shard.context).decode(data, { channelId: shard.context.id });
+			} catch {}
+			if (packet?.op === Op.Signal) {
+				const ready = packet.status === ShardStatus.Ready;
+				if (ready !== shard.ready) {
+					shard.ready = ready;
+					this.#report(shard.link, FrameType.Status, {
+						spawnId: shard.spawnId,
+						ready
+					});
+				}
+			} else if (packet && await this.#route(shard, packet, data)) return;
+		}
+		await shard.link.connection?.sendData(shard.spawnId, data).catch(() => void 0);
+	}
+	async #route(origin, packet, data) {
+		switch (packet.op) {
+			case Op.Message:
+			case Op.Request: {
+				if (typeof packet.to !== "number" || packet.op === Op.Request && packet.system) return false;
+				const local = this.#byChannel.get(channelKey(origin.scope, packet.to));
+				if (local?.ready) {
+					await this.#deliver({ shard: origin }, origin.context.id, local, packet);
+					return true;
+				}
+				const entry = origin.link.directory.get(packet.to);
+				if (!entry || entry.proxy === this.name || !isChannelData(data)) return false;
+				const peer = this.#peer(entry);
+				if (!peer) return false;
+				const header = {
+					scope: origin.scope,
+					origin: origin.context.id,
+					target: packet.to,
+					binary: typeof data !== "string"
+				};
+				if (packet.op === Op.Request) this.#peerRequests.set(`${origin.key}:${packet.nonce}`, {
+					origin,
+					peer,
+					header
+				});
+				await peer.connection.sendPeer(header, data).catch(() => void 0);
+				return true;
+			}
+			case Op.Reply: {
+				const route = this.#routes.get(packet.nonce);
+				if (!route || route.target !== origin) return false;
+				this.#routes.delete(packet.nonce);
+				await this.#toEndpoint(route.origin, origin, {
+					...packet,
+					nonce: route.originNonce
+				});
+				return true;
+			}
+			case Op.Abort: {
+				for (const [nonce, route] of this.#routes) {
+					if (!("shard" in route.origin) || route.origin.shard !== origin) continue;
+					if (route.originNonce !== packet.nonce) continue;
+					this.#routes.delete(nonce);
+					await this.#toShard(route.target, {
+						op: Op.Abort,
+						nonce
+					});
+					return true;
+				}
+				const request = this.#peerRequests.get(`${origin.key}:${packet.nonce}`);
+				if (!request || !isChannelData(data)) return false;
+				this.#peerRequests.delete(`${origin.key}:${packet.nonce}`);
+				await request.peer.connection.sendPeer({
+					...request.header,
+					binary: typeof data !== "string"
+				}, data).catch(() => void 0);
+				return true;
+			}
+			default: return false;
+		}
+	}
+	async #deliver(origin, from, target, packet) {
+		if (packet.op === Op.Message) {
+			await this.#toShard(target, {
+				op: Op.Message,
+				body: packet.body,
+				from
+			});
+			return;
+		}
+		if (packet.op !== Op.Request) return;
+		const nonce = --this.#nextNonce;
+		this.#routes.set(nonce, {
+			origin,
+			originNonce: packet.nonce,
+			target
+		});
+		await this.#toShard(target, {
+			op: Op.Request,
+			nonce,
+			body: packet.body,
+			from,
+			timeout: packet.timeout
+		});
+	}
+	async #fromPeer(peer, header, data) {
+		if (header.bounce) {
+			const origin = this.#byChannel.get(channelKey(header.scope, header.origin));
+			if (!origin) return;
+			const packet = await this.#codec(origin.context).decode(data, { channelId: origin.context.id }).catch(() => null);
+			if (packet?.op === Op.Request) this.#peerRequests.delete(`${origin.key}:${packet.nonce}`);
+			await origin.link.connection?.sendData(origin.spawnId, data).catch(() => void 0);
+			return;
+		}
+		const target = this.#byChannel.get(channelKey(header.scope, header.target));
+		let packet = null;
+		if (target) try {
+			packet = await this.#codec(target.context).decode(data, { channelId: header.origin });
+		} catch {
+			packet = null;
+		}
+		if (!target || !packet) {
+			await peer.connection.sendPeer({
+				...header,
+				bounce: true
+			}, data).catch(() => void 0);
+			return;
+		}
+		switch (packet.op) {
+			case Op.Message:
+			case Op.Request:
+				if (!target.ready) {
+					await peer.connection.sendPeer({
+						...header,
+						bounce: true
+					}, data).catch(() => void 0);
+					return;
+				}
+				await this.#deliver({
+					peer,
+					channel: header.origin
+				}, header.origin, target, packet);
+				break;
+			case Op.Abort:
+				for (const [nonce, route] of this.#routes) {
+					if (!("peer" in route.origin) || route.origin.peer !== peer) continue;
+					if (route.origin.channel !== header.origin || route.originNonce !== packet.nonce) continue;
+					this.#routes.delete(nonce);
+					await this.#toShard(route.target, {
+						op: Op.Abort,
+						nonce
+					});
+					break;
+				}
+				break;
+			case Op.Reply:
+				this.#peerRequests.delete(`${target.key}:${packet.nonce}`);
+				await this.#toShard(target, packet);
+		}
+	}
+	async #abortPeerRequest(request, nonce) {
+		const data = await this.#codec(request.origin.context).encode({
+			op: Op.Abort,
+			nonce
+		}, { channelId: request.origin.context.id });
+		if (!isChannelData(data)) return;
+		await request.peer.connection.sendPeer({
+			...request.header,
+			binary: typeof data !== "string"
+		}, data).catch(() => void 0);
+	}
+	async #toEndpoint(endpoint, from, packet) {
+		if ("shard" in endpoint) {
+			await this.#toShard(endpoint.shard, packet);
+			return;
+		}
+		const data = await this.#codec(from.context).encode(packet, { channelId: from.context.id });
+		if (!isChannelData(data)) return;
+		const header = {
+			scope: from.scope,
+			origin: from.context.id,
+			target: endpoint.channel,
+			binary: typeof data !== "string"
+		};
+		await endpoint.peer.connection.sendPeer(header, data).catch(() => void 0);
+	}
+	async #toShard(shard, packet) {
+		if (shard.exited) return;
+		const data = await this.#codec(shard.context).encode(packet, { channelId: shard.context.id });
+		await shard.transport.send(data).catch(() => void 0);
+	}
+	#codec(context) {
+		const key = JSON.stringify([context.messageHandler, context.transformers]);
+		let codec = this.#codecs.get(key);
+		if (!codec) {
+			codec = new PacketCodec(resolveMessageHandler(context.messageHandler), context.transformers.map(resolveMessageTransformer));
+			this.#codecs.set(key, codec);
+		}
+		return codec;
+	}
+	async #listenPeers() {
+		const options = this.#options.peer;
+		if (!options || this.#peerServer) return;
+		const onSocket = (socket) => this.#acceptPeer(socket);
+		const server = options.tls ? createServer$1(options.tls, onSocket) : createServer(onSocket);
+		await new Promise((resolve, reject) => {
+			server.once("error", reject);
+			server.listen(options.port, options.host, () => {
+				server.off("error", reject);
+				resolve();
+			});
+		});
+		const address = server.address();
+		this.#peerServer = server;
+		this.#peerAddress = {
+			host: options.advertise ?? options.host ?? hostname(),
+			port: typeof address === "object" && address ? address.port : options.port
+		};
+	}
+	#acceptPeer(socket) {
+		const connection = new Connection(socket, this.#heartbeat());
+		let peer = null;
+		connection.on("frame", (type, payload) => {
+			if (peer) {
+				if (type === FrameType.PeerPacket) {
+					const { header, data } = readPeer(payload);
+					this.#fromPeer(peer, header, data);
+				}
+				return;
+			}
+			const hello = type === FrameType.PeerHello ? JSON.parse(payload.toString()) : null;
+			if (!hello || !tokensMatch(this.#peerToken(), hello.token)) {
+				connection.close();
+				return;
+			}
+			peer = {
+				name: hello.name,
+				connection
+			};
+			this.#inbound.add(peer);
+			connection.send(FrameType.PeerWelcome).catch(() => void 0);
+			this.emit("peerConnect", peer.name);
+		});
+		connection.on("close", () => {
+			if (!peer) return;
+			this.#inbound.delete(peer);
+			this.#peerLost(peer);
+		});
+	}
+	#peer(entry) {
+		const key = `${entry.host}:${entry.port}`;
+		const peer = this.#peers.get(key);
+		if (peer && !peer.connection.closed) return peer;
+		for (const inbound of this.#inbound) if (inbound.name === entry.proxy && !inbound.connection.closed) return inbound;
+		if (this.#connecting.has(key) || this.#destroyed) return null;
+		this.#connecting.add(key);
+		const tls = this.#options.peer?.connectTls;
+		const socket = tls ? connect$1({
+			...tls === true ? {} : tls,
+			host: entry.host,
+			port: entry.port
+		}) : connect({
+			host: entry.host,
+			port: entry.port
+		});
+		socket.once("error", () => this.#connecting.delete(key));
+		socket.once(tls ? "secureConnect" : "connect", () => {
+			socket.removeAllListeners("error");
+			const connection = new Connection(socket, this.#heartbeat());
+			const opened = {
+				name: entry.proxy,
+				connection
+			};
+			connection.on("frame", (type, payload) => {
+				if (type === FrameType.PeerWelcome) {
+					this.#connecting.delete(key);
+					this.#peers.set(key, opened);
+					this.emit("peerConnect", opened.name);
+				} else if (type === FrameType.PeerPacket) {
+					const { header, data } = readPeer(payload);
+					this.#fromPeer(opened, header, data);
+				}
+			});
+			connection.on("close", () => {
+				this.#connecting.delete(key);
+				if (this.#peers.get(key) === opened) this.#peers.delete(key);
+				this.#peerLost(opened);
+			});
+			connection.sendJson(FrameType.PeerHello, {
+				token: this.#peerToken(),
+				name: this.name
+			}).catch(() => void 0);
+		});
+		return null;
+	}
+	#peerLost(peer) {
+		for (const [key, request] of this.#peerRequests) {
+			if (request.peer !== peer) continue;
+			this.#peerRequests.delete(key);
+			const nonce = Number(key.slice(key.lastIndexOf(":") + 1));
+			const error = serializeError(new ShardUnavailableError(request.header.target, "its proxy is unreachable"));
+			this.#toShard(request.origin, {
+				op: Op.Reply,
+				nonce,
+				error
+			});
+		}
+		for (const [nonce, route] of this.#routes) {
+			if (!("peer" in route.origin) || route.origin.peer !== peer) continue;
+			this.#routes.delete(nonce);
+			this.#toShard(route.target, {
+				op: Op.Abort,
+				nonce
+			});
+		}
+		this.emit("peerDisconnect", peer.name);
+	}
+	#available() {
+		return Math.max(this.capacity - this.#shards.size, 0);
+	}
+	#reportLoad() {
+		for (const link of this.#links) this.#report(link, FrameType.Load, { available: this.#available() });
+	}
+	async #report(link, type, body) {
+		await link.connection?.sendJson(type, body).catch(() => void 0);
+	}
+	#peerToken() {
+		return this.#options.peer?.token ?? this.#options.token;
+	}
+	#heartbeat() {
+		return {
+			interval: this.#options.heartbeat?.interval ?? 15e3,
+			timeout: this.#options.heartbeat?.timeout ?? 45e3
+		};
+	}
+};
+function createLink(addresses, index) {
+	return {
+		index,
+		addresses,
+		address: null,
+		connection: null,
+		managerId: null,
+		directory: /* @__PURE__ */ new Map()
+	};
+}
+function shardKey(link, spawnId) {
+	return `${link.index}:${spawnId}`;
+}
+function channelKey(scope, channel) {
+	return `${scope}:${channel}`;
+}
+function isChannelData(data) {
+	return typeof data === "string" || data instanceof Uint8Array;
+}
+function parseAddress(address) {
+	if (typeof address !== "string") return address;
+	const separator = address.lastIndexOf(":");
+	const port = Number(address.slice(separator + 1));
+	if (separator === -1 || !Number.isInteger(port)) throw new RangeError(`"${address}" is not a host:port address`);
+	return {
+		host: address.slice(0, separator).replace(/^\[|\]$/g, ""),
+		port
+	};
+}
+
+//#endregion
+//#region src/util/commands.ts
+/**
+* Builds a request handler answering {@link CommandRequest}s: the sharder stays raw data (as the RFC settled), and
+* this is the optional, typed layer on top.
+*
+* @param commands The commands, by name.
+* @example
+* ```ts
+* const commands = {
+*   guildCount: () => guilds.size,
+*   guild: (id: string) => guilds.get(id) ?? null,
+* } satisfies Commands;
+*
+* shard.setRequestHandler(createCommandHandler(commands));
+* const counts = await manager.broadcastRequest<CommandReply<typeof commands, "guildCount">>(
+*   command<typeof commands>("guildCount"),
+* );
+* ```
+*/
+function createCommandHandler(commands) {
+	return (body, context) => {
+		const request = body;
+		const run = typeof request?.command === "string" ? commands[request.command] : void 0;
+		if (!run || !Object.hasOwn(commands, request.command)) throw new RangeError(`Unknown command ${String(request?.command)}`);
+		return run(request.data, context);
+	};
+}
+/**
+* Builds a {@link CommandRequest}.
+*
+* @param name The name of the command.
+* @param data Its argument.
+*/
+function command(name, ...data) {
+	return {
+		command: name,
+		data: data[0]
+	};
+}
+
+//#endregion
+export { BrotliTransformer, ClusterStrategy, ForkStrategy, GzipTransformer, JsonMessageHandler, NetworkStrategy, ProcessStrategy, RawMessageHandler, Result, ShardChannel, ShardClient, ShardContextVariable, ShardManager, ShardManagerProxy, ShardPing, ShardRequestError, ShardRequestTimeoutError, ShardSpawnError, ShardStatus, ShardUnavailableError, V8MessageHandler, WorkerStrategy, command, createCommandHandler, encodeContext, fetchGatewayInformation, fetchRecommendedShardCount, registerMessageHandler, registerMessageTransformer, registerStrategy, resolveMessageHandler, resolveMessageTransformer, resolveRecommendedShardCount, resolveStrategy, shardIdForGuild };
+//# sourceMappingURL=index.js.map