@seedcord/http 0.4.0 → 0.5.0

package/dist/{edge.index-D9PlLJ9b.mjs → edge.index-DwRPmkh2.mjs}

@@ -1,13 +1,13 @@
 import "reflect-metadata";
-import { SeedcordError, validateDiscordToken } from "@seedcord/errors/internal";
+import { GatedMetadataKey, PublishDefault, RegisterDefaults, RegisterSubscriber, accessorStore, asError, clearStore, decodeComponentRoute, deferFlags, guardedAccessor, isEmojiTuple, outcomeFor, prefixOf, queuedMsFor, reportDispatch, reportedWrite, runHandlerGates, sendFlags, slowGateMonitor } from "@seedcord/core/internal";
+import { SeedcordError, SeedcordTypeError, applicationIdFromToken, validateDiscordToken } from "@seedcord/errors/internal";
+import { Logger } from "@seedcord/logger";
 import { Converters, Envapter } from "envapt";
 import { DiscordAPIError, REST } from "@discordjs/rest";
-import { ArraySource, BaseHandler, Bus, CursorSource, DispatchContext, Fault, Notice, PaginatorBase, RepliableHandler, ResolvedEmoji, Silence, Subscriber, WebhookLog } from "@seedcord/core";
-import { BaseReplySender, GatedMetadataKey, PublishDefault, accessorStore, asError, clearStore, decodeComponentRoute, deferFlags, guardedAccessor, isEmojiTuple, outcomeFor, prefixOf, queuedMsFor, reportDispatch, reportedWrite, runHandlerGates, sendFlags, slowGateMonitor } from "@seedcord/core/internal";
+import { ArraySourceBase, BaseHandler, BaseReplySender, Bus, CursorSourceBase, DispatchContext, Fault, Notice, PaginatorBase, RepliableHandler, ResolvedEmoji, Silence, Subscriber, WebhookLog } from "@seedcord/core";
 import { SeedcordErrorCode, paint } from "@seedcord/errors";
-import { Logger } from "@seedcord/logger";
 import { MemoryRateLimiter } from "@seedcord/rate-limiter";
-import { ApplicationCommandOptionType, ApplicationCommandType, ComponentType, InteractionResponseType, InteractionType, MessageFlags, RESTJSONErrorCodes, Routes } from "discord-api-types/v10";
+import { ApplicationCommandOptionType, ApplicationCommandType, ChannelType, ComponentType, InteractionResponseType, InteractionType, MessageFlags, RESTJSONErrorCodes, Routes } from "discord-api-types/v10";
 import { API } from "@discordjs/core/http-only";
 import { buildSlashRoute } from "@seedcord/utils/internal";
 
@@ -270,11 +270,21 @@ function logger() {
 	dispatchLogger ??= new Logger("Dispatcher", { channel: "interactions" });
 	return dispatchLogger;
 }
+function noLifecycle(accessor) {
+	throw new SeedcordError(SeedcordErrorCode.CoreLifecycleUnavailable, [accessor]);
+}
+const edgeShutdown = { addTask: () => noLifecycle("shutdown") };
+const edgeStartup = { addTask: () => noLifecycle("startup") };
 function createCore(config, token) {
 	const draft = {
 		config,
 		rateLimiter: config.store ?? new MemoryRateLimiter(),
-		rest: new REST().setToken(token)
+		rest: new REST().setToken(token),
+		shutdown: edgeShutdown,
+		startup: edgeStartup,
+		get applicationId() {
+			return applicationIdFromToken(token);
+		}
 	};
 	draft.bus = new Bus(draft);
 	return draft;
@@ -434,7 +444,7 @@ async function dispatchInteraction(args) {
 		core,
 		payload,
 		routeId,
-		sender: handler instanceof RepliableHandler$1 ? handler.getSender() : null
+		sender: handler instanceof RepliableHandler$1 ? handler.sender : null
 	};
 	const refusal = await gateRefusal(ctor, match, payload, core);
 	if (refusal) {
@@ -466,7 +476,7 @@ async function gateRefusal(ctor, match, payload, core) {
 //#endregion
 //#region src/dispatch/registerSubscribers.ts
 function registerSubscribers(bus, manifest) {
-	for (const row of manifest.subscriberRoutes) bus.register({
+	for (const row of manifest.subscriberRoutes) bus[RegisterSubscriber]({
 		keys: row.keys,
 		frequency: row.frequency,
 		resolve: async () => {
@@ -483,7 +493,7 @@ function registerSubscribers(bus, manifest) {
 				row.from
 			]);
 			const exported = module[row.exportName];
-			if (typeof exported !== "function" || !(exported.prototype instanceof Subscriber)) throw new SeedcordError(SeedcordErrorCode.SubscriberRouteNotASubscriber, [
+			if (typeof exported !== "function" || !(exported.prototype instanceof Subscriber)) throw new SeedcordTypeError(SeedcordErrorCode.SubscriberRouteNotASubscriber, [
 				keys,
 				row.exportName,
 				row.from
@@ -620,7 +630,7 @@ var AutocompleteHandler = class extends BaseHandler {
 		const { name, value } = this.focused;
 		const respond = (choices) => this.respond(choices);
 		const arm = Object.hasOwn(arms, name) ? arms[name] : void 0;
-		if (!arm) throw new SeedcordError(SeedcordErrorCode.AutocompleteMatchArmMissing, [name]);
+		if (!arm) throw new SeedcordTypeError(SeedcordErrorCode.AutocompleteMatchArmMissing, [name]);
 		return await arm(value, respond);
 	}
 	/** Send autocomplete suggestions, callback type 8. Prefer {@link match}, which restricts each field's choices to its declared type. */
@@ -842,7 +852,7 @@ var Ed25519Verifier = class {
 	key;
 	constructor(publicKeyHex) {
 		const publicKey = hexToBytes(publicKeyHex, PUBLIC_KEY_BYTES);
-		if (!publicKey) throw new SeedcordError(SeedcordErrorCode.ConfigInvalidEnv, ["DISCORD_PUBLIC_KEY", "64 hex characters"]);
+		if (!publicKey) throw new SeedcordTypeError(SeedcordErrorCode.ConfigInvalidEnv, ["DISCORD_PUBLIC_KEY", "64 hex characters"]);
 		this.key = crypto.subtle.importKey("raw", publicKey, "Ed25519", false, ["verify"]);
 	}
 	async verify(signatureHex, timestamp, body) {
@@ -979,24 +989,191 @@ function buildEngine(core, maps) {
 *
 * Reads `DISCORD_PUBLIC_KEY` and `DISCORD_BOT_TOKEN` from the environment through envapt and throws a
 * `SeedcordError` when either is missing or malformed.
+*
+* Applies `config.logger`. An omitted `logger` resets the level and the sinks to their defaults, the
+* way `installNodeDefaults` does on the node hosts.
 */
 function createSeedcord(config, manifest) {
+	Logger.configure(config.logger ?? {});
 	const token = validateDiscordToken(Envapter.get("DISCORD_BOT_TOKEN"));
 	const core = createCore(config, token);
-	core.bus.registerDefaults();
+	core.bus[RegisterDefaults]();
 	registerSubscribers(core.bus, manifest);
 	return buildEngine(core, buildRouteMaps(manifest)).handle;
 }
 
 //#endregion
-//#region src/applicationId.ts
-async function fetchApplicationId(rest) {
-	try {
-		return (await rest.get(Routes.currentApplication())).id;
-	} catch (error) {
-		throw new SeedcordError(SeedcordErrorCode.CoreApplicationUnavailable, { cause: error });
+//#region src/inputs/pick.ts
+function pick(ids, bucket) {
+	const found = /* @__PURE__ */ new Map();
+	if (!ids || !bucket) return found;
+	for (const id of ids) if (Object.hasOwn(bucket, id)) found.set(id, bucket[id]);
+	return found;
+}
+
+//#endregion
+//#region src/inputs/ModalFields.ts
+const FIELD_KINDS = {
+	[ComponentType.TextInput]: {
+		label: "a text input",
+		getter: "getTextInputValue"
+	},
+	[ComponentType.StringSelect]: {
+		label: "a string select",
+		getter: "getStringSelectValues"
+	},
+	[ComponentType.UserSelect]: {
+		label: "a user select",
+		getter: "getSelectedUsers"
+	},
+	[ComponentType.RoleSelect]: {
+		label: "a role select",
+		getter: "getSelectedRoles"
+	},
+	[ComponentType.MentionableSelect]: {
+		label: "a mentionable select",
+		getter: "getSelectedMentionables"
+	},
+	[ComponentType.ChannelSelect]: {
+		label: "a channel select",
+		getter: "getSelectedChannels"
+	},
+	[ComponentType.FileUpload]: {
+		label: "a file upload",
+		getter: "getUploadedFiles"
+	},
+	[ComponentType.RadioGroup]: {
+		label: "a radio group",
+		getter: "getRadioGroup"
+	},
+	[ComponentType.CheckboxGroup]: {
+		label: "a checkbox group",
+		getter: "getCheckboxGroup"
+	},
+	[ComponentType.Checkbox]: {
+		label: "a checkbox",
+		getter: "getCheckbox"
 	}
+};
+function nameOfChannelType(type) {
+	return ChannelType[type] ?? String(type);
 }
+function listOf(values) {
+	return values ?? [];
+}
+function isKind(entry, kinds) {
+	return kinds.includes(entry.type);
+}
+/**
+* The fields a modal carries, read by custom id.
+*
+* Every getter throws when no field in the modal has that custom id. It also throws when the field holds a
+* kind that getter does not read. The message names the getter that does.
+*
+* A select getter resolves the ids its field picked against the interaction's `resolved` data and returns a
+* `Map` keyed by id. A field that picked nothing returns null. Pass `required` to throw there instead.
+*/
+var ModalFields = class {
+	entries = /* @__PURE__ */ new Map();
+	resolved;
+	constructor(data) {
+		this.resolved = data.resolved;
+		for (const component of data.components ?? []) {
+			if ("components" in component) for (const child of component.components) this.entries.set(child.custom_id, child);
+			if ("component" in component) this.entries.set(component.component.custom_id, component.component);
+		}
+	}
+	entry(customId) {
+		const found = this.entries.get(customId);
+		if (!found) throw new SeedcordTypeError(SeedcordErrorCode.ModalFieldNotFound, [customId]);
+		return found;
+	}
+	field(customId, kinds) {
+		const entry = this.entry(customId);
+		if (!isKind(entry, kinds)) {
+			const known = FIELD_KINDS[entry.type];
+			const args = known ? [
+				customId,
+				known.label,
+				known.getter
+			] : [customId, `component type ${entry.type}`];
+			throw new SeedcordTypeError(SeedcordErrorCode.ModalFieldWrongKind, [...args]);
+		}
+		return entry;
+	}
+	selected(customId, kinds, bucket, required) {
+		const { values } = this.field(customId, kinds);
+		const found = pick(values, bucket);
+		if (found.size > 0) return found;
+		if (required) throw new SeedcordTypeError(SeedcordErrorCode.ModalFieldEmpty, [customId]);
+		return null;
+	}
+	getField(customId, kind) {
+		return kind === void 0 ? this.entry(customId) : this.field(customId, [kind]);
+	}
+	getTextInputValue(customId) {
+		return this.field(customId, [ComponentType.TextInput]).value;
+	}
+	getStringSelectValues(customId) {
+		return listOf(this.field(customId, [ComponentType.StringSelect]).values);
+	}
+	getSelectedUsers(customId, required = false) {
+		const kinds = [ComponentType.UserSelect, ComponentType.MentionableSelect];
+		return this.selected(customId, kinds, this.resolved?.users, required);
+	}
+	/** The guild members behind the picked users. Discord resolves these only inside a guild. */
+	getSelectedMembers(customId) {
+		const kinds = [ComponentType.UserSelect, ComponentType.MentionableSelect];
+		return this.selected(customId, kinds, this.resolved?.members, false);
+	}
+	getSelectedRoles(customId, required = false) {
+		const kinds = [ComponentType.RoleSelect, ComponentType.MentionableSelect];
+		return this.selected(customId, kinds, this.resolved?.roles, required);
+	}
+	getSelectedChannels(customId, required = false, channelTypes = []) {
+		const kinds = [ComponentType.ChannelSelect];
+		const picked = this.selected(customId, kinds, this.resolved?.channels, required);
+		if (!picked || channelTypes.length === 0) return picked;
+		for (const found of picked.values()) {
+			if (channelTypes.includes(found.type)) continue;
+			const allowed = channelTypes.map(nameOfChannelType).join(", ");
+			throw new SeedcordTypeError(SeedcordErrorCode.ModalFieldChannelType, [
+				customId,
+				nameOfChannelType(found.type),
+				allowed
+			]);
+		}
+		return picked;
+	}
+	getSelectedMentionables(customId, required = false) {
+		const { values } = this.field(customId, [ComponentType.MentionableSelect]);
+		const resolved = this.resolved;
+		const picked = {
+			users: pick(values, resolved?.users),
+			members: pick(values, resolved?.members),
+			roles: pick(values, resolved?.roles)
+		};
+		if (picked.users.size + picked.members.size + picked.roles.size > 0) return picked;
+		if (required) throw new SeedcordTypeError(SeedcordErrorCode.ModalFieldEmpty, [customId]);
+		return null;
+	}
+	getUploadedFiles(customId, required = false) {
+		const kinds = [ComponentType.FileUpload];
+		return this.selected(customId, kinds, this.resolved?.attachments, required);
+	}
+	getRadioGroup(customId, required = false) {
+		const value = this.field(customId, [ComponentType.RadioGroup]).value ?? null;
+		if (value !== null) return value;
+		if (required) throw new SeedcordTypeError(SeedcordErrorCode.ModalFieldEmpty, [customId]);
+		return null;
+	}
+	getCheckboxGroup(customId) {
+		return listOf(this.field(customId, [ComponentType.CheckboxGroup]).values);
+	}
+	getCheckbox(customId) {
+		return this.field(customId, [ComponentType.Checkbox]).value;
+	}
+};
 
 //#endregion
 //#region src/emojis/EmojiInjector.ts
@@ -1011,16 +1188,14 @@ function byName(list) {
 }
 /**
 * The bot's resolved emojis, keyed by {@link EmojiMap}. Filled by {@link EmojiInjector} during startup.
-* A read before that throws.
+* Throws if you read a key the injector did not fill.
 */
 const Emojis = guardedAccessor("Emojis", emojiStorage);
 var EmojiInjector = class {
 	core;
-	applicationId;
 	logger = new Logger("Emojis", { channel: "bot" });
-	constructor(core, applicationId = () => fetchApplicationId(core.rest)) {
+	constructor(core) {
 		this.core = core;
-		this.applicationId = applicationId;
 	}
 	async init() {
 		clearStore(emojiStorage);
@@ -1042,7 +1217,7 @@ var EmojiInjector = class {
 	}
 	async applicationEmojis(failures) {
 		try {
-			const appId = await this.applicationId();
+			const appId = this.core.applicationId;
 			return byName((await this.core.rest.get(Routes.applicationEmojis(appId))).items);
 		} catch (error) {
 			failures.push(`  - the application emojis could not be read (${reasonOf(error)})`);
@@ -1086,9 +1261,14 @@ var EmojiInjector = class {
 var SlashHandler = class extends InteractionHandler {
 	resolver;
 	/**
-	* The typed options for this command's route. Required options drop the null, choices narrow to their
-	* literal union, and only the getters for kinds this command actually uses appear. Rich kinds resolve
-	* from the interaction's `resolved` data.
+	* The typed options for this command's route. Only the getters for kinds this command declares appear.
+	* Each getter's name argument is restricted to that command's options of its kind.
+	*
+	* - A required option drops the null.
+	* - Choices narrow to their literal union.
+	* - A channel option declared with `addChannelTypes` narrows to those types.
+	*
+	* Rich kinds resolve from the interaction's `resolved` data.
 	*/
 	get options() {
 		this.resolver ??= new HttpSlashOptions(this.event.data);
@@ -1108,13 +1288,18 @@ var SlashHandler = class extends InteractionHandler {
 	async match(arms) {
 		const route = slashRouteOf(this.event.data);
 		const arm = Object.hasOwn(arms, route) ? arms[route] : void 0;
-		if (!arm) throw new SeedcordError(SeedcordErrorCode.SlashMatchArmMissing, [route]);
+		if (!arm) throw new SeedcordTypeError(SeedcordErrorCode.SlashMatchArmMissing, [route]);
 		return await arm(this.options);
 	}
 };
 
 //#endregion
 //#region src/handlers/interaction/ContextMenuHandler.ts
+function armFor(arms, name) {
+	const arm = Object.hasOwn(arms, name) ? arms[name] : void 0;
+	if (typeof arm !== "function") throw new SeedcordTypeError(SeedcordErrorCode.ContextMenuMatchArmMissing, [name]);
+	return arm;
+}
 /**
 * Base class for a user context-menu command handler on the HTTP transport (right-click a user).
 *
@@ -1133,6 +1318,37 @@ var UserContextMenuHandler = class extends InteractionHandler {
 		const { target_id: targetId, resolved } = this.event.data;
 		return resolved.members?.[targetId] ?? null;
 	}
+	/** Which of the registered commands fired. */
+	get commandName() {
+		return this.event.data.name;
+	}
+	/**
+	* Run the arm for whichever command fired. Use this only when the handler is registered for several
+	* names.
+	*
+	* Provide one arm per registered name, keyed by the name Discord shows in the right-click menu. Each
+	* arm receives the clicked user and that user's guild member. The arms must cover every name in the
+	* generic. A missing name or an unknown key is a compile error.
+	*
+	* @param arms - One handler per registered command name.
+	* @returns The result of the arm that ran.
+	*
+	* @example
+	* ```ts
+	* \@UserContextMenuRoute('View Profile', 'Warn')
+	* class Moderation extends UserContextMenuHandler<'View Profile' | 'Warn'> {
+	*     async execute() {
+	*         await this.match({
+	*             'View Profile': (user) => this.reply(`Profile for ${user.username}.`),
+	*             Warn: (user, member) => this.reply(`Warned ${member?.nick ?? user.username}.`)
+	*         });
+	*     }
+	* }
+	* ```
+	*/
+	async match(arms) {
+		return await armFor(arms, this.event.data.name)(this.target, this.targetMember);
+	}
 };
 /**
 * Base class for a message context-menu command handler on the HTTP transport (right-click a message).
@@ -1147,6 +1363,37 @@ var MessageContextMenuHandler = class extends InteractionHandler {
 		const { target_id: targetId, resolved } = this.event.data;
 		return resolved.messages[targetId];
 	}
+	/** Which of the registered commands fired. */
+	get commandName() {
+		return this.event.data.name;
+	}
+	/**
+	* Run the arm for whichever command fired. Use this only when the handler is registered for several
+	* names.
+	*
+	* Provide one arm per registered name, keyed by the name Discord shows in the right-click menu. Each
+	* arm receives the clicked message. The arms must cover every name in the generic. A missing name or
+	* an unknown key is a compile error.
+	*
+	* @param arms - One handler per registered command name.
+	* @returns The result of the arm that ran.
+	*
+	* @example
+	* ```ts
+	* \@MessageContextMenuRoute('Report Message', 'Quote Message')
+	* class MessageTools extends MessageContextMenuHandler<'Report Message' | 'Quote Message'> {
+	*     async execute() {
+	*         await this.match({
+	*             'Report Message': (message) => this.report(message),
+	*             'Quote Message': (message) => this.reply(`> ${message.content}`)
+	*         });
+	*     }
+	* }
+	* ```
+	*/
+	async match(arms) {
+		return await armFor(arms, this.event.data.name)(this.target);
+	}
 };
 
 //#endregion
@@ -1215,7 +1462,7 @@ var ComponentHandler = class extends InteractionHandler {
 	async match(arms) {
 		const { prefix, params } = this.route;
 		const arm = Object.hasOwn(arms, prefix) ? arms[prefix] : void 0;
-		if (!arm) throw new SeedcordError(SeedcordErrorCode.CustomIdMatchArmMissing, [prefix]);
+		if (!arm) throw new SeedcordTypeError(SeedcordErrorCode.CustomIdMatchArmMissing, [prefix]);
 		return await arm(params);
 	}
 };
@@ -1240,12 +1487,30 @@ var ButtonHandler = class extends ComponentHandler {};
 * Base class for a modal submit handler on the HTTP transport.
 *
 * Register the customId definitions this handler decodes with `@ModalRoute` and list the same ones in the
-* generic. Read the submitted inputs off `this.event.data.components`. Reply through the handler members.
-* Discord forbids opening a modal in response to a modal, so `showModal` fails compilation on this kind.
+* generic. Read the submitted inputs from `this.fields`. Reply through the handler members. `showModal`
+* fails compilation on this kind, because Discord forbids opening a modal in response to a modal.
 *
 * @typeParam Defs - The customId definitions this handler decodes, e.g. `[typeof ConfigId]`.
+*
+* @example
+* ```ts
+* \@ModalRoute(ConfigId)
+* class ConfigModal extends ModalHandler<[typeof ConfigId]> {
+*     async execute() {
+*         const { guildId } = this.params;
+*         const name = this.fields.getTextInputValue('name');
+*         await this.reply(`saved ${name} for ${guildId}`);
+*     }
+* }
+* ```
 */
 var ModalHandler = class extends ComponentHandler {
+	reader;
+	/** The fields this modal submitted, read by custom id. */
+	get fields() {
+		this.reader ??= new ModalFields(this.event.data);
+		return this.reader;
+	}
 	/** Rewrite the message this modal was opened from. Throws when a command opened the modal. */
 	update(response) {
 		this.ensureSourceMessage("update");
@@ -1267,15 +1532,55 @@ var ModalHandler = class extends ComponentHandler {
 /**
 * Base class for a select menu handler on the HTTP transport.
 *
-* Pass the select kind first and the customId definitions second, the same order as `@SelectMenuRoute`,
-* so `this.event.data` and its `values`/`resolved` are narrowed to that kind. Read `this.params` for a
-* single route or `this.match` for several, and reply through the handler members or rewrite the source
-* message with `this.update`.
+* Pass the select kind first and the customId definitions second, the same order as `@SelectMenuRoute`.
+* Read the picked ids from `this.values`. The kind decides which of `this.users`, `this.members`,
+* `this.roles`, and `this.channels` this handler carries. The rest are `never`.
+*
+* Read `this.params` for a single route or `this.match` for several. Reply through the handler members, or
+* rewrite the source message with `this.update`.
 *
 * @typeParam Kind - The select kind from {@link SelectMenuKind}, e.g. `SelectMenuKind.User`.
 * @typeParam Defs - The customId definitions this handler decodes, e.g. `[typeof AssignId]`.
+*
+* @example
+* ```ts
+* \@SelectMenuRoute(SelectMenuKind.User, AssignId)
+* class AssignSelect extends SelectMenuHandler<SelectMenuKind.User, [typeof AssignId]> {
+*     async execute() {
+*         const { roleId } = this.params;
+*         await this.reply(`assigning ${this.users.size} member(s) to <@&${roleId}>`);
+*     }
+* }
+* ```
 */
-var SelectMenuHandler = class extends ComponentHandler {};
+var SelectMenuHandler = class extends ComponentHandler {
+	get selection() {
+		return this.event.data;
+	}
+	resolvedMap(bucket) {
+		return pick(this.selection.values, bucket);
+	}
+	/** The ids this select picked. */
+	get values() {
+		return this.selection.values ?? [];
+	}
+	/** The users this select picked. */
+	get users() {
+		return this.resolvedMap(this.selection.resolved?.users);
+	}
+	/** The guild members behind the picked users. Discord resolves these only inside a guild. */
+	get members() {
+		return this.resolvedMap(this.selection.resolved?.members);
+	}
+	/** The roles this select picked. */
+	get roles() {
+		return this.resolvedMap(this.selection.resolved?.roles);
+	}
+	/** The channels this select picked. */
+	get channels() {
+		return this.resolvedMap(this.selection.resolved?.channels);
+	}
+};
 
 //#endregion
 //#region src/subscribers/index.ts
@@ -1327,25 +1632,33 @@ var Paginator = class extends PaginatorBase {
 	Handler;
 	constructor(config) {
 		super(config);
-		const loadPage = (ctx, n) => this.page(ctx, n);
+		const pageFor = (handler, n) => this.page(handler, n);
 		this.Handler = class Nav extends ButtonHandler {
 			async execute() {
 				await this.deferUpdate();
-				const response = await loadPage(contextOf(this.event, this.core), this.params.page);
+				const response = await pageFor(this, this.params.page);
 				await this.update(response);
 			}
 		};
 	}
 	/**
-	* Render page 0 and send it through the handler's sender, which picks reply, edit, or followUp from its
-	* ack state.
+	* Render a page as a {@link ReplyResponse} without sending anything.
+	*
+	* @param handler - The handler rendering the page, normally `this`.
+	* @param n - The zero-based page.
+	*/
+	async page(handler, n) {
+		return this.buildPage(contextOf(handler.getEvent(), handler.core), n);
+	}
+	/**
+	* Send a page through the handler's sender. The sender picks reply, edit, or followUp from its ack state.
 	*
 	* @param handler - The handler starting the paginator, normally `this`.
+	* @param n - The zero-based page to open on.
 	*/
-	async start(handler) {
-		const interaction = handler.getEvent();
-		const response = await this.page(contextOf(interaction, handler.core), 0);
-		return handler.getSender().send(response, { ephemeral: this.config.ephemeral ?? false });
+	async start(handler, n = 0) {
+		const response = await this.page(handler, n);
+		return handler.sender.send(response, { ephemeral: this.config.ephemeral ?? false });
 	}
 };
 
@@ -1358,7 +1671,7 @@ var Paginator = class extends PaginatorBase {
 *
 * @typeParam Item - The item type, inferred from the loader's return.
 */
-var ArraySource$1 = class extends ArraySource {};
+var ArraySource = class extends ArraySourceBase {};
 /**
 * A source for a large or unknown-length set you fetch one page at a time (SQL LIMIT/OFFSET, a paged API).
 * The fetcher receives the page index and the page size and reports whether a next page exists. A cursor
@@ -1367,7 +1680,7 @@ var ArraySource$1 = class extends ArraySource {};
 *
 * @typeParam Item - The item type, inferred from the fetcher's slice.
 */
-var CursorSource$1 = class extends CursorSource {};
+var CursorSource = class extends CursorSourceBase {};
 
 //#endregion
 //#region src/gates/Gated.ts
@@ -1412,8 +1725,8 @@ function Gated(...gates) {
 
 //#endregion
 //#region src/version.ts
-const version = "0.4.0";
+const version = "0.5.0";
 
 //#endregion
-export { RepliableHandler$1 as C, AutocompleteHandler as S, fetchApplicationId as _, Paginator as a, buildRouteMaps as b, SelectMenuHandler as c, ComponentHandler as d, MessageContextMenuHandler as f, Emojis as g, EmojiInjector as h, CursorSource$1 as i, ModalHandler as l, SlashHandler as m, Gated as n, Subscriber$1 as o, UserContextMenuHandler as p, ArraySource$1 as r, WebhookLog$1 as s, version as t, ButtonHandler as u, createSeedcord as v, InteractionHandler as x, buildEngine as y };
-//# sourceMappingURL=edge.index-D9PlLJ9b.mjs.map
+export { RepliableHandler$1 as C, AutocompleteHandler as S, ModalFields as _, Paginator as a, buildRouteMaps as b, SelectMenuHandler as c, ComponentHandler as d, MessageContextMenuHandler as f, Emojis as g, EmojiInjector as h, CursorSource as i, ModalHandler as l, SlashHandler as m, Gated as n, Subscriber$1 as o, UserContextMenuHandler as p, ArraySource as r, WebhookLog$1 as s, version as t, ButtonHandler as u, createSeedcord as v, ReplySender as w, InteractionHandler as x, buildEngine as y };
+//# sourceMappingURL=edge.index-DwRPmkh2.mjs.map