@wolfstar/http-framework 6.2.2 → 6.3.0-next-20261007181329

package/dist/esm/index.js

@@ -35,19 +35,29 @@ let Events = /* @__PURE__ */ function(Events) {
 	Events["CommandNameMissing"] = "commandNameMissing";
 	Events["CommandNameUnknown"] = "commandNameUnknown";
 	Events["CommandMethodUnknown"] = "commandMethodUnknown";
+	Events["PreChatInputCommandRun"] = "preChatInputCommandRun";
+	Events["PreContextMenuCommandRun"] = "preContextMenuCommandRun";
+	Events["ChatInputCommandAccepted"] = "chatInputCommandAccepted";
+	Events["ContextMenuCommandAccepted"] = "contextMenuCommandAccepted";
 	Events["CommandRun"] = "commandRun";
 	Events["CommandSuccess"] = "commandSuccess";
 	Events["CommandError"] = "commandError";
+	Events["ChatInputCommandDenied"] = "chatInputCommandDenied";
+	Events["ContextMenuCommandDenied"] = "contextMenuCommandDenied";
 	Events["CommandFinish"] = "commandFinish";
+	Events["AutocompleteAccepted"] = "autocompleteAccepted";
 	Events["AutocompleteRun"] = "autocompleteRun";
 	Events["AutocompleteSuccess"] = "autocompleteSuccess";
 	Events["AutocompleteError"] = "autocompleteError";
+	Events["AutocompleteDenied"] = "autocompleteDenied";
 	Events["AutocompleteFinish"] = "autocompleteFinish";
 	Events["InteractionHandlerNameInvalid"] = "interactionHandlerNameInvalid";
 	Events["InteractionHandlerNameUnknown"] = "interactionHandlerNameUnknown";
+	Events["InteractionHandlerAccepted"] = "interactionHandlerAccepted";
 	Events["InteractionHandlerRun"] = "interactionHandlerRun";
 	Events["InteractionHandlerSuccess"] = "interactionHandlerSuccess";
 	Events["InteractionHandlerError"] = "interactionHandlerError";
+	Events["InteractionHandlerDenied"] = "interactionHandlerDenied";
 	Events["InteractionHandlerFinish"] = "interactionHandlerFinish";
 	Events["HmrStart"] = "hmrStart";
 	Events["HmrStop"] = "hmrStop";
@@ -884,6 +894,62 @@ function _useLegacy(plugin) {
 	}
 }
 
+//#endregion
+//#region src/lib/errors/UserError.ts
+/**
+* The UserError class to be thrown and emitted by the pieces of the framework.
+*
+* @remarks
+* This class is the root of every framework-thrown error, allowing consumers to distinguish
+* errors that are meant to be shown to the user from unexpected, internal ones.
+*
+* When a command, an autocomplete handler, or an interaction handler throws a `UserError` (or any subclass), the
+* client emits the matching `*Denied` event ({@link Events.ChatInputCommandDenied}, {@link Events.ContextMenuCommandDenied},
+* {@link Events.AutocompleteDenied}, or {@link Events.InteractionHandlerDenied}) instead of the `*Error` one, so listeners
+* can reply to the user without reporting an expected failure as a bug. Use {@link isUserError} to apply the same check.
+*
+* @property name This will be `'UserError'` and can be used to distinguish the type of error when any error gets thrown.
+* @since 3.2.0
+* @example
+* ```typescript
+* throw new UserError({
+* 	identifier: Identifiers.ArgumentIntegerTooSmall,
+* 	message: 'The number you provided is too small.',
+* 	context: { received: 2, minimum: 3 }
+* });
+* ```
+*/
+var UserError = class extends Error {
+	/**
+	* Constructs an UserError.
+	* @param options The UserError options
+	*/
+	constructor(options) {
+		super(options.message);
+		_defineProperty(this, "identifier", void 0);
+		_defineProperty(this, "context", void 0);
+		this.identifier = options.identifier;
+		this.context = options.context ?? null;
+	}
+	get name() {
+		return "UserError";
+	}
+};
+/**
+* Checks whether a value is a {@link UserError}, which is how the client tells an expected failure from an unexpected
+* one.
+*
+* @remarks `instanceof` is tried first. A bundle that inlines the framework, or a second installed copy of it, has its
+* own `UserError` class that `instanceof` does not recognise, so any `Error` with a string `identifier` and a `context`
+* property is accepted too.
+* @param error The value to check.
+* @returns Whether the value is a `UserError`.
+* @since 6.3.0
+*/
+function isUserError(error) {
+	return error instanceof UserError || error instanceof Error && typeof error.identifier === "string" && "context" in error;
+}
+
 //#endregion
 //#region src/lib/utils/decorators.ts
 /**
@@ -3078,6 +3144,8 @@ let Identifiers = /* @__PURE__ */ function(Identifiers) {
 	Identifiers["PreconditionClientPermissionsNoPermissions"] = "preconditionClientPermissionsNoPermissions";
 	Identifiers["PreconditionCooldown"] = "preconditionCooldown";
 	Identifiers["PreconditionGuildIds"] = "preconditionGuildIds";
+	Identifiers["PreconditionMissingChatInputHandler"] = "preconditionMissingChatInputHandler";
+	Identifiers["PreconditionMissingContextMenuHandler"] = "preconditionMissingContextMenuHandler";
 	Identifiers["PreconditionNSFW"] = "preconditionNsfw";
 	Identifiers["PreconditionRunIn"] = "preconditionRunIn";
 	Identifiers["PreconditionUnavailable"] = "preconditionUnavailable";
@@ -3091,41 +3159,134 @@ let Identifiers = /* @__PURE__ */ function(Identifiers) {
 }({});
 
 //#endregion
-//#region src/lib/errors/UserError.ts
+//#region src/lib/utils/preconditions.ts
 /**
-* The UserError class to be thrown and emitted by the pieces of the framework.
+* How the entries of an array of preconditions are run.
 *
-* @remarks
-* This class is the root of every framework-thrown error, allowing consumers to distinguish
-* errors that are meant to be shown to the user from unexpected, internal ones.
+* @since 6.3.0
+*/
+let PreconditionRunMode = /* @__PURE__ */ function(PreconditionRunMode) {
+	/**
+	* The entries are run one after the other. This is the default, and it stops as soon as the result is known.
+	* @since 6.3.0
+	*/
+	PreconditionRunMode[PreconditionRunMode["Sequential"] = 0] = "Sequential";
+	/**
+	* Every entry is started at once and awaited with `Promise.all`, then the results are read. It is faster when the
+	* checks are slow, but none of them is skipped once another one has settled the result.
+	* @since 6.3.0
+	*/
+	PreconditionRunMode[PreconditionRunMode["Parallel"] = 1] = "Parallel";
+	return PreconditionRunMode;
+}({});
+/**
+* How the results of the entries of an array of preconditions are combined.
 *
-* @property name This will be `'UserError'` and can be used to distinguish the type of error when any error gets thrown.
-* @since 3.2.0
-* @example
-* ```typescript
-* throw new UserError({
-* 	identifier: Identifiers.ArgumentIntegerTooSmall,
-* 	message: 'The number you provided is too small.',
-* 	context: { received: 2, minimum: 3 }
-* });
-* ```
+* @since 6.3.0
 */
-var UserError = class extends Error {
+let PreconditionRunCondition = /* @__PURE__ */ function(PreconditionRunCondition) {
 	/**
-	* Constructs an UserError.
-	* @param options The UserError options
+	* Every entry has to pass: the first `Err` is the result.
+	* @since 6.3.0
 	*/
-	constructor(options) {
-		super(options.message);
-		_defineProperty(this, "identifier", void 0);
-		_defineProperty(this, "context", void 0);
-		this.identifier = options.identifier;
-		this.context = options.context ?? null;
-	}
-	get name() {
-		return "UserError";
+	PreconditionRunCondition[PreconditionRunCondition["And"] = 0] = "And";
+	/**
+	* One entry has to pass: the first `Ok` is the result, and when none does, the last `Err`.
+	* @since 6.3.0
+	*/
+	PreconditionRunCondition[PreconditionRunCondition["Or"] = 1] = "Or";
+	return PreconditionRunCondition;
+}({});
+/**
+* Runs a {@link Precondition} piece for the given kind of interaction.
+*
+* @param precondition The precondition to run.
+* @param kind What is being run.
+* @param interaction The interaction being handled.
+* @param target The command or interaction handler being run.
+* @param context The context of the check.
+* @returns The result of the precondition. A chat input or context menu command is denied when the piece has no method
+* for it, an autocomplete or an interaction handler is let through.
+* @since 6.3.0
+*/
+function runPrecondition(precondition, kind, interaction, target, context = {}) {
+	return checkPrecondition(precondition, kind, interaction, target, context) ?? precondition.ok();
+}
+/**
+* Like {@link runPrecondition}, but `null` when the piece does not apply: it has no method for an autocomplete or an
+* interaction handler.
+*/
+function checkPrecondition(precondition, kind, interaction, target, context) {
+	switch (kind) {
+		case "chatInput": return precondition.chatInputRun ? precondition.chatInputRun(interaction, target, context) : precondition.error({
+			identifier: "preconditionMissingChatInputHandler",
+			message: `The precondition "${precondition.name}" is missing a "chatInputRun" handler, but it was requested for the "${target.name}" command.`
+		});
+		case "contextMenu": return precondition.contextMenuRun ? precondition.contextMenuRun(interaction, target, context) : precondition.error({
+			identifier: "preconditionMissingContextMenuHandler",
+			message: `The precondition "${precondition.name}" is missing a "contextMenuRun" handler, but it was requested for the "${target.name}" command.`
+		});
+		case "autocomplete": return precondition.autocompleteRun ? precondition.autocompleteRun(interaction, target, context) : null;
+		case "interactionHandler": return precondition.interactionHandlerRun ? precondition.interactionHandlerRun(interaction, target, context) : null;
 	}
-};
+}
+/**
+* Runs the preconditions of a command or an interaction handler: first the global ones of the `preconditions` store,
+* then the entries of its `preconditions` option, stopping at the first denial.
+*
+* @remarks
+* - The `preconditions` option is an array that runs with {@link PreconditionRunCondition.And}: every entry has to pass.
+*   An array nested in it runs with `Or`, one nested in that with `And` again, and so on, so
+*   `['Connect', ['Moderator', ['DJ', 'SongAuthor']]]` is `Connect && (Moderator || (DJ && SongAuthor))`.
+* - The {@link PreconditionRunMode} is `Sequential`, or the `mode` of the array written as `{ entries, mode }`, which the
+*   arrays nested in it inherit.
+* - An entry that names a precondition missing from the store denies the interaction with
+*   {@linkcode Identifiers.PreconditionUnavailable}.
+* - An entry that does not apply to the interaction, such as a function for an autocomplete or a piece with no method for
+*   it, is left out of the result. An array in which no entry applies is left out as well.
+* @param target The command or interaction handler being run.
+* @param kind What is being run.
+* @param interaction The interaction being handled.
+* @returns The first `Err`, or `Result.ok()` when every precondition lets it run.
+* @since 6.3.0
+*/
+async function runPreconditions(target, kind, interaction) {
+	const global = await container$1.stores.get("preconditions").run(kind, interaction, target);
+	if (global.isErr()) return global;
+	return await runArray(target.options.preconditions ?? [], 0, 0, kind, interaction, target) ?? Result.ok();
+}
+async function runArray(array, condition, inheritedMode, kind, interaction, target) {
+	const entries = Array.isArray(array) ? array : array.entries;
+	const mode = Array.isArray(array) ? inheritedMode : array.mode;
+	const nested = condition === 0 ? 1 : 0;
+	const run = (entry) => isSingle(entry) ? runSingle(entry, kind, interaction, target) : runArray(entry, nested, mode, kind, interaction, target);
+	const outcomes = mode === 1 ? await Promise.all(entries.map(run)) : null;
+	let applied = false;
+	let error = null;
+	for (const [index, entry] of entries.entries()) {
+		const outcome = outcomes ? outcomes[index] : await run(entry);
+		if (outcome === null) continue;
+		applied = true;
+		if (condition === 0) {
+			if (outcome.isErr()) return outcome;
+		} else if (outcome.isOk()) return outcome;
+		else error = outcome;
+	}
+	return error ?? (applied ? Result.ok() : null);
+}
+function isSingle(entry) {
+	return typeof entry === "string" || typeof entry === "function" || !Array.isArray(entry) && "name" in entry;
+}
+async function runSingle(entry, kind, interaction, target) {
+	if (typeof entry === "function") return kind === "autocomplete" ? null : entry(interaction, target);
+	const name = typeof entry === "string" ? entry : entry.name;
+	const precondition = container$1.stores.get("preconditions").get(name);
+	if (!precondition) return Result.err(new UserError({
+		identifier: "preconditionUnavailable",
+		message: `The precondition "${name}" is not available.`
+	}));
+	return checkPrecondition(precondition, kind, interaction, target, typeof entry === "string" ? {} : entry.context ?? {});
+}
 
 //#endregion
 //#region src/lib/errors/ChatInputRouterError.ts
@@ -3644,8 +3805,26 @@ var CommandStore = class extends Store$1 {
 			response.statusCode = 501;
 			return response.end(ErrorMessages.UnknownCommandHandler);
 		}
+		const kind = interaction.data.type === ApplicationCommandType.ChatInput ? "chatInput" : "contextMenu";
+		if (kind === "chatInput") container$1.client.emit("preChatInputCommandRun", context);
+		else container$1.client.emit("preContextMenuCommandRun", context);
+		const checked = await Result.fromAsync(async () => {
+			const commandInteraction = makeInteraction(response, interaction);
+			const preconditions = await runPreconditions(command, kind, commandInteraction);
+			if (preconditions.isErr()) throw preconditions.unwrapErr();
+			return commandInteraction;
+		});
+		if (checked.isErr()) {
+			const error = checked.unwrapErr();
+			_assertClassBrand(_CommandStore_brand, this, _emitCommandFailure).call(this, error, context);
+			handleError(response, error);
+			container$1.client.emit("commandFinish", context);
+			return response;
+		}
+		if (kind === "chatInput") container$1.client.emit("chatInputCommandAccepted", context);
+		else container$1.client.emit("contextMenuCommandAccepted", context);
 		container$1.client.emit("commandRun", context);
-		(await Result.fromAsync(() => _assertClassBrand(_CommandStore_brand, this, _runCommandMethod).call(this, command, method, makeInteraction(response, interaction)))).inspect((value) => container$1.client.emit("commandSuccess", context, value)).inspectErr((error) => (container$1.client.emit("commandError", error, context), handleError(response, error)));
+		(await Result.fromAsync(() => _assertClassBrand(_CommandStore_brand, this, _runCommandMethod).call(this, command, method, checked.unwrap()))).inspect((value) => container$1.client.emit("commandSuccess", context, value)).inspectErr((error) => (_assertClassBrand(_CommandStore_brand, this, _emitCommandFailure).call(this, error, context), handleError(response, error)));
 		container$1.client.emit("commandFinish", context);
 		return response;
 	}
@@ -3675,13 +3854,49 @@ var CommandStore = class extends Store$1 {
 			response
 		};
 		const options = transformAutocompleteInteraction(interaction.data.resolved ?? {}, interaction.data.options);
+		const checked = await Result.fromAsync(async () => {
+			const autocompleteInteraction = makeInteraction(response, interaction);
+			const preconditions = await runPreconditions(command, "autocomplete", autocompleteInteraction);
+			if (preconditions.isErr()) throw preconditions.unwrapErr();
+			return autocompleteInteraction;
+		});
+		if (checked.isErr()) {
+			_assertClassBrand(_CommandStore_brand, this, _emitAutocompleteFailure).call(this, checked.unwrapErr(), context, response);
+			container$1.client.emit("autocompleteFinish", context);
+			return response;
+		}
+		container$1.client.emit("autocompleteAccepted", context);
 		container$1.client.emit("autocompleteRun", context);
-		(await Result.fromAsync(() => command.autocompleteRun(makeInteraction(response, interaction), options))).inspect((value) => container$1.client.emit("autocompleteSuccess", context, value)).inspectErr((error) => (container$1.client.emit("autocompleteError", error, context), handleError(response, error)));
+		(await Result.fromAsync(() => command.autocompleteRun(checked.unwrap(), options))).inspect((value) => container$1.client.emit("autocompleteSuccess", context, value)).inspectErr((error) => _assertClassBrand(_CommandStore_brand, this, _emitAutocompleteFailure).call(this, error, context, response));
 		container$1.client.emit("autocompleteFinish", context);
 		return response;
 	}
 };
 /**
+* Emits `autocompleteDenied` for a {@link UserError} and `autocompleteError` otherwise, then replies as for any
+* other thrown error.
+*
+* @param error - The value that was thrown.
+* @param context - The context of the run.
+* @param response - The server response object.
+*/
+function _emitAutocompleteFailure(error, context, response) {
+	if (isUserError(error)) container$1.client.emit("autocompleteDenied", error, context);
+	else container$1.client.emit("autocompleteError", error, context);
+	handleError(response, error);
+}
+/**
+* Emits the event matching a failed command run: a `*Denied` one for a {@link UserError}, `commandError` otherwise.
+*
+* @param error - The value the command threw.
+* @param context - The context of the run.
+*/
+function _emitCommandFailure(error, context) {
+	if (!isUserError(error)) container$1.client.emit("commandError", error, context);
+	else if (context.interaction.data.type === ApplicationCommandType.ChatInput) container$1.client.emit("chatInputCommandDenied", error, context);
+	else container$1.client.emit("contextMenuCommandDenied", error, context);
+}
+/**
 * Executes a command method on a command object.
 *
 * @since 1.0.0
@@ -3737,9 +3952,11 @@ var InteractionHandler = class extends Piece$1 {
 
 //#endregion
 //#region src/lib/structures/InteractionHandlerStore.ts
+var _InteractionHandlerStore_brand = /* @__PURE__ */ new WeakSet();
 var InteractionHandlerStore = class extends Store$1 {
 	constructor() {
 		super(InteractionHandler, { name: "interaction-handlers" });
+		_classPrivateMethodInitSpec(this, _InteractionHandlerStore_brand);
 	}
 	async runHandler(response, interaction) {
 		const parsed = container$1.idParser.run(interaction.data.custom_id);
@@ -3759,12 +3976,37 @@ var InteractionHandlerStore = class extends Store$1 {
 			interaction,
 			response
 		};
+		const checked = await Result.fromAsync(async () => {
+			const handlerInteraction = makeInteraction(response, interaction);
+			const preconditions = await runPreconditions(handler, "interactionHandler", handlerInteraction);
+			if (preconditions.isErr()) throw preconditions.unwrapErr();
+			return handlerInteraction;
+		});
+		if (checked.isErr()) {
+			_assertClassBrand(_InteractionHandlerStore_brand, this, _emitFailure).call(this, checked.unwrapErr(), context, response);
+			container$1.client.emit("interactionHandlerFinish", context);
+			return response;
+		}
+		container$1.client.emit("interactionHandlerAccepted", context);
 		container$1.client.emit("interactionHandlerRun", context);
-		(await Result.fromAsync(() => handler.run(makeInteraction(response, interaction), parsed.content))).inspect((value) => container$1.client.emit("interactionHandlerSuccess", context, value)).inspectErr((error) => (container$1.client.emit("interactionHandlerError", error, context), handleError(response, error)));
+		(await Result.fromAsync(() => handler.run(checked.unwrap(), parsed.content))).inspect((value) => container$1.client.emit("interactionHandlerSuccess", context, value)).inspectErr((error) => _assertClassBrand(_InteractionHandlerStore_brand, this, _emitFailure).call(this, error, context, response));
 		container$1.client.emit("interactionHandlerFinish", context);
 		return response;
 	}
 };
+/**
+* Emits `interactionHandlerDenied` for a {@link UserError} and `interactionHandlerError` otherwise, then replies as
+* for any other thrown error.
+*
+* @param error - The value that was thrown.
+* @param context - The context of the run.
+* @param response - The server response object.
+*/
+function _emitFailure(error, context, response) {
+	if (isUserError(error)) container$1.client.emit("interactionHandlerDenied", error, context);
+	else container$1.client.emit("interactionHandlerError", error, context);
+	handleError(response, error);
+}
 
 //#endregion
 //#region src/lib/structures/Listener.ts
@@ -3829,6 +4071,152 @@ var ListenerStore = class extends Store$1 {
 	}
 };
 
+//#endregion
+//#region src/lib/errors/PreconditionError.ts
+/**
+* Errors thrown by preconditions, that is, any check that runs before a command or an interaction
+* handler is executed, such as the guild restrictions applied by
+* {@link RestrictGuildIds}.
+*
+* @remarks Being a {@link UserError}, it is emitted as a `*Denied` event when thrown from a command, an autocomplete
+* handler, or an interaction handler, and not as `commandError`. The framework has no precondition store: the
+* decorators of `@wolfstar/decorators` are what throws it.
+*
+* @property name This will be `'PreconditionError'` and can be used to distinguish the type of error when any error gets thrown.
+* @since 3.2.0
+* @example
+* ```typescript
+* throw new PreconditionError({
+* 	precondition: 'GuildIds',
+* 	identifier: Identifiers.PreconditionGuildIds,
+* 	message: 'This command can only be used in specific guilds.',
+* 	context: { guildIds: ['737141877803057244'] }
+* });
+* ```
+*/
+var PreconditionError = class extends UserError {
+	constructor(options) {
+		super({
+			...options,
+			identifier: options.identifier ?? options.precondition
+		});
+		_defineProperty(this, "precondition", void 0);
+		this.precondition = options.precondition;
+	}
+	get name() {
+		return "PreconditionError";
+	}
+};
+
+//#endregion
+//#region src/lib/structures/Precondition.ts
+/**
+* A check that runs before a command method does, loaded from the `preconditions` directory into the
+* `preconditions` store.
+*
+* @remarks A precondition with a `position` is global: it runs, in ascending order of `position`, before the
+* preconditions of every chat input and context menu command, and of every autocomplete and interaction handler that
+* it has a method for. Any other one runs only for the commands that list its
+* name in the `preconditions` option. The method it needs depends on the command, and a precondition that is asked to
+* run for a kind of command it has no method for denies the command with
+* {@linkcode Identifiers.PreconditionMissingChatInputHandler} or
+* {@linkcode Identifiers.PreconditionMissingContextMenuHandler}.
+* @since 6.3.0
+* @example
+* ```typescript
+* import { Precondition } from '@wolfstar/http-framework';
+*
+* export class UserPrecondition extends Precondition {
+* 	public override chatInputRun(interaction: Precondition.ChatInputInteraction) {
+* 		return interaction.user.id === process.env.OWNER_ID ? this.ok() : this.error({ message: 'Only the owner can use this command.' });
+* 	}
+* }
+* ```
+*/
+var Precondition = class extends Piece$1 {
+	constructor(context, options = {}) {
+		super(context, options);
+		_defineProperty(this, "position", void 0);
+		this.position = options.position ?? null;
+	}
+	/**
+	* Lets the command run.
+	* @since 6.3.0
+	*/
+	ok() {
+		return Result.ok();
+	}
+	/**
+	* Denies the command with a {@link PreconditionError} whose `precondition` is the name of this piece.
+	*
+	* @param options The message, identifier and context of the error.
+	* @since 6.3.0
+	*/
+	error(options = {}) {
+		return Result.err(new PreconditionError({
+			precondition: this.name,
+			...options
+		}));
+	}
+};
+/**
+* A {@link Precondition} that has to implement the check for every kind of command.
+*
+* @since 6.3.0
+*/
+var AllFlowsPrecondition = class extends Precondition {};
+
+//#endregion
+//#region src/lib/structures/PreconditionStore.ts
+var _globalPreconditions = /* @__PURE__ */ new WeakMap();
+var _PreconditionStore_brand = /* @__PURE__ */ new WeakSet();
+var PreconditionStore = class extends Store$1 {
+	constructor() {
+		super(Precondition, { name: "preconditions" });
+		_classPrivateMethodInitSpec(this, _PreconditionStore_brand);
+		_classPrivateFieldInitSpec(this, _globalPreconditions, []);
+	}
+	/**
+	* Runs the global preconditions, the ones with a `position`, in ascending order of it, stopping at the first one
+	* that denies the interaction.
+	*
+	* @since 6.3.0
+	* @param kind What is being run.
+	* @param interaction The interaction being handled.
+	* @param target The command or interaction handler being run.
+	* @param context The context of the checks.
+	* @returns The first `Err`, or `Result.ok()` when every global precondition lets the command run.
+	*/
+	async run(kind, interaction, target, context = {}) {
+		for (const precondition of _classPrivateFieldGet2(_globalPreconditions, this)) {
+			const result = await runPrecondition(precondition, kind, interaction, target, context);
+			if (result.isErr()) return result;
+		}
+		return Result.ok();
+	}
+	set(key, value) {
+		_assertClassBrand(_PreconditionStore_brand, this, _removeGlobal).call(this, key);
+		if (value.position !== null) {
+			const index = _classPrivateFieldGet2(_globalPreconditions, this).findIndex((precondition) => precondition.position >= value.position);
+			if (index === -1) _classPrivateFieldGet2(_globalPreconditions, this).push(value);
+			else _classPrivateFieldGet2(_globalPreconditions, this).splice(index, 0, value);
+		}
+		return super.set(key, value);
+	}
+	delete(key) {
+		_assertClassBrand(_PreconditionStore_brand, this, _removeGlobal).call(this, key);
+		return super.delete(key);
+	}
+	clear() {
+		_classPrivateFieldGet2(_globalPreconditions, this).length = 0;
+		return super.clear();
+	}
+};
+function _removeGlobal(key) {
+	const index = _classPrivateFieldGet2(_globalPreconditions, this).findIndex((precondition) => precondition.name === key);
+	if (index !== -1) _classPrivateFieldGet2(_globalPreconditions, this).splice(index, 1);
+}
+
 //#endregion
 //#region src/lib/utils/fetch-bridge.ts
 function toIncomingMessage(request) {
@@ -4029,6 +4417,7 @@ async function getSafeTextBody(request) {
 container$1.stores.register(new CommandStore());
 container$1.stores.register(new InteractionHandlerStore());
 container$1.stores.register(new ListenerStore());
+container$1.stores.register(new PreconditionStore());
 container$1.logger ??= new Logger();
 var _discordPublicKey = /* @__PURE__ */ new WeakMap();
 var _fetchKey = /* @__PURE__ */ new WeakMap();
@@ -4218,6 +4607,10 @@ _defineProperty(Client, "plugins", new PluginManager());
 /**
 * Errors thrown while resolving the options (arguments) of an interaction.
 *
+* @remarks The framework never throws this error by itself: Discord validates the type and the bounds of the options
+* before sending the interaction. It is meant to be thrown from a command that rejects a value, and, being a
+* {@link UserError}, it is emitted as a `*Denied` event.
+*
 * @property name This will be `'ArgumentError'` and can be used to distinguish the type of error when any error gets thrown.
 * @since 3.2.0
 * @example
@@ -4249,39 +4642,6 @@ var ArgumentError = class extends UserError {
 	}
 };
 
-//#endregion
-//#region src/lib/errors/PreconditionError.ts
-/**
-* Errors thrown by preconditions, that is, any check that runs before a command or an interaction
-* handler is executed, such as the guild restrictions applied by
-* {@link RestrictGuildIds}.
-*
-* @property name This will be `'PreconditionError'` and can be used to distinguish the type of error when any error gets thrown.
-* @since 3.2.0
-* @example
-* ```typescript
-* throw new PreconditionError({
-* 	precondition: 'GuildIds',
-* 	identifier: Identifiers.PreconditionGuildIds,
-* 	message: 'This command can only be used in specific guilds.',
-* 	context: { guildIds: ['737141877803057244'] }
-* });
-* ```
-*/
-var PreconditionError = class extends UserError {
-	constructor(options) {
-		super({
-			...options,
-			identifier: options.identifier ?? options.precondition
-		});
-		_defineProperty(this, "precondition", void 0);
-		this.precondition = options.precondition;
-	}
-	get name() {
-		return "PreconditionError";
-	}
-};
-
 //#endregion
 //#region src/lib/plugins/Plugin.ts
 /**
@@ -4348,5 +4708,5 @@ function toPermissionNames(bits) {
 }
 
 //#endregion
-export { AliasPiece, AliasStore, ApplicationCommandRegistry, ApplicationCommandRegistryEntry, ArgumentError, AutocompleteInteraction, BaseInteraction, ChatInputCommandInteraction, ChatInputRouterError, ChatInputRouterErrors, Client, Command, CommandInteraction, CommandLoaderStrategy, CommandRegistry, CommandRouter, CommandStore, CommandStoreRouter, Events, HotModuleReloader, HttpCodes, Identifiers, InteractionHandler, InteractionHandlerStore, Listener, ListenerLoaderStrategy, ListenerStore, LoaderError, LogLevel, Logger, Message, MessageComponentButtonInteraction, MessageComponentChannelSelectInteraction, MessageComponentInteraction, MessageComponentMentionableSelectInteraction, MessageComponentRoleSelectInteraction, MessageComponentStringSelectInteraction as MessageComponentSelectMenuInteraction, MessageComponentStringSelectInteraction, MessageComponentUserSelectInteraction, MessageContextMenuCommandInteraction, MissingExportsError, ModalSubmitInteraction, PartialMessage, Piece, Plugin, PluginHook, PluginHookError, PluginManager, PreconditionError, RegisterCommand, RegisterMessageCommand, RegisterSubcommand, RegisterSubcommandGroup, RegisterUserCommand, RestrictGuildIds, Store, StoreRegistry, StringIdParser, UserContextMenuCommandInteraction, UserError, applicationCommandRegistry, container, definePlugin, extractTopLevelOptions, getMissingPermissions, makeInteraction, postInitialization, postListen, preGenericsInitialization, preInitialization, preLoad, resolvePermissions, restrictedGuildIdRegistry, toPermissionNames, toPluginEntries, transformAutocompleteInteraction, transformInteraction, transformMessageInteraction, transformUserInteraction };
+export { AliasPiece, AliasStore, AllFlowsPrecondition, ApplicationCommandRegistry, ApplicationCommandRegistryEntry, ArgumentError, AutocompleteInteraction, BaseInteraction, ChatInputCommandInteraction, ChatInputRouterError, ChatInputRouterErrors, Client, Command, CommandInteraction, CommandLoaderStrategy, CommandRegistry, CommandRouter, CommandStore, CommandStoreRouter, Events, HotModuleReloader, HttpCodes, Identifiers, InteractionHandler, InteractionHandlerStore, Listener, ListenerLoaderStrategy, ListenerStore, LoaderError, LogLevel, Logger, Message, MessageComponentButtonInteraction, MessageComponentChannelSelectInteraction, MessageComponentInteraction, MessageComponentMentionableSelectInteraction, MessageComponentRoleSelectInteraction, MessageComponentStringSelectInteraction as MessageComponentSelectMenuInteraction, MessageComponentStringSelectInteraction, MessageComponentUserSelectInteraction, MessageContextMenuCommandInteraction, MissingExportsError, ModalSubmitInteraction, PartialMessage, Piece, Plugin, PluginHook, PluginHookError, PluginManager, Precondition, PreconditionError, PreconditionRunCondition, PreconditionRunMode, PreconditionStore, RegisterCommand, RegisterMessageCommand, RegisterSubcommand, RegisterSubcommandGroup, RegisterUserCommand, RestrictGuildIds, Store, StoreRegistry, StringIdParser, UserContextMenuCommandInteraction, UserError, applicationCommandRegistry, container, definePlugin, extractTopLevelOptions, getMissingPermissions, isUserError, makeInteraction, postInitialization, postListen, preGenericsInitialization, preInitialization, preLoad, resolvePermissions, restrictedGuildIdRegistry, runPrecondition, runPreconditions, toPermissionNames, toPluginEntries, transformAutocompleteInteraction, transformInteraction, transformMessageInteraction, transformUserInteraction };
 //# sourceMappingURL=index.js.map