pi-roundtable 0.30.4 → 0.31.0

package/src/core/discord/poster/poster-forum.ts

@@ -0,0 +1,162 @@
+import {
+	DISCORD_LIMITS,
+	type ForumPost,
+	type ForumTag,
+	type ForumTagInput,
+	type ThreadAutoArchive,
+} from "./poster.ts";
+import {
+	cardBody,
+	checkChannelName,
+	checkedText,
+	checkSnowflake,
+} from "./poster-checks.ts";
+import { DiscordPosterError, invalid } from "./poster-errors.ts";
+
+/** Discord's channel type numbers the forum calls tell apart. */
+export const CHANNEL_TYPE = Object.freeze({
+	text: 0,
+	category: 4,
+	announcementThread: 10,
+	publicThread: 11,
+	privateThread: 12,
+	forum: 15,
+} as const);
+
+/** The auto-archive durations Discord accepts, in minutes. */
+const AUTO_ARCHIVE_MINUTES: readonly ThreadAutoArchive[] = [
+	60, 1_440, 4_320, 10_080,
+];
+
+/** After how many minutes without a message a post archives itself when its maker says nothing: a week, as a thread. */
+export const POST_ARCHIVE_MINUTES: ThreadAutoArchive = 10_080;
+
+/** Whether the channel type is a thread's. */
+export function isThreadType(type: unknown): boolean {
+	return (
+		type === CHANNEL_TYPE.announcementThread ||
+		type === CHANNEL_TYPE.publicThread ||
+		type === CHANNEL_TYPE.privateThread
+	);
+}
+
+/** Discord's JSON error code for an edit of a thread that is archived ("Thread is archived"). */
+export const THREAD_ARCHIVED = 50083;
+/** Discord's JSON error code for an action a channel's type does not take. */
+export const WRONG_CHANNEL_TYPE = 50024;
+
+/** What Discord answers an edit of an archived thread (a message in it, its name or its tags) that does not reopen it. */
+export function archivedThread(): DiscordPosterError {
+	return new DiscordPosterError("rejected", "the thread is archived", {
+		discordCode: THREAD_ARCHIVED,
+		status: 400,
+	});
+}
+
+/** What Discord answers a message posted straight into a forum: posts go through `createForumPost`. */
+export function forumTakesPosts(): DiscordPosterError {
+	return new DiscordPosterError(
+		"rejected",
+		"a forum takes posts, not messages: use createForumPost",
+		{ discordCode: WRONG_CHANNEL_TYPE, status: 400 },
+	);
+}
+
+/** The error for a channel that is no forum (or a thread that is no forum post). */
+export function notForum(what: string): DiscordPosterError {
+	return new DiscordPosterError("invalid", `${what} is not a forum`, {
+		reason: "not_forum",
+	});
+}
+
+/** The tag ids of a post: at most five Discord ids, none twice. */
+export function checkedTagIds(tagIds: readonly string[] | undefined): string[] {
+	const ids = [...new Set(tagIds ?? [])];
+	if (ids.length > DISCORD_LIMITS.postTags)
+		throw invalid(`a post carries at most ${DISCORD_LIMITS.postTags} tags`);
+	return ids.map((id) => checkSnowflake("a tag", id));
+}
+
+/** The checked tags of a forum, each as the wire form Discord's `available_tags` takes. */
+export function checkedForumTags(tags: readonly ForumTagInput[]) {
+	if (tags.length > DISCORD_LIMITS.forumTags)
+		throw invalid(`a forum holds at most ${DISCORD_LIMITS.forumTags} tags`);
+	const seen = new Set<string>();
+	return tags.map((tag) => {
+		const chars = [...tag.name].length;
+		if (chars < 1 || chars > DISCORD_LIMITS.forumTagNameChars)
+			throw invalid(
+				`a tag name is 1 to ${DISCORD_LIMITS.forumTagNameChars} characters`,
+			);
+		if (tag.emoji !== undefined && tag.emojiId !== undefined)
+			throw invalid("a tag has a Unicode emoji or a custom emoji, not both");
+		if (tag.emoji === "") throw invalid("a tag's emoji is not empty");
+		if (tag.id !== undefined) {
+			checkSnowflake("a tag", tag.id);
+			if (seen.has(tag.id)) throw invalid("a tag id is given once");
+			seen.add(tag.id);
+		}
+		if (tag.emojiId !== undefined) checkSnowflake("a tag's emoji", tag.emojiId);
+		return {
+			...(tag.id === undefined ? {} : { id: tag.id }),
+			name: tag.name,
+			moderated: tag.moderated === true,
+			emoji_id: tag.emojiId ?? null,
+			emoji_name: tag.emoji ?? null,
+		};
+	});
+}
+
+/** A tag as Discord holds it, as `ForumTag`; undefined for an entry with no id or name. */
+export function readTag(raw: unknown): ForumTag | undefined {
+	if (raw === null || typeof raw !== "object") return undefined;
+	const tag = raw as Record<string, unknown>;
+	const id = typeof tag.id === "string" && tag.id !== "" ? tag.id : undefined;
+	const name =
+		typeof tag.name === "string" && tag.name !== "" ? tag.name : undefined;
+	if (!(id && name)) return undefined;
+	const emojiId =
+		typeof tag.emoji_id === "string" && tag.emoji_id !== ""
+			? tag.emoji_id
+			: undefined;
+	const emoji =
+		typeof tag.emoji_name === "string" && tag.emoji_name !== ""
+			? tag.emoji_name
+			: undefined;
+	return {
+		id,
+		name,
+		moderated: tag.moderated === true,
+		...(emojiId ? { emojiId } : emoji ? { emoji } : {}),
+	};
+}
+
+/** The checked parts of a forum post: its name, tags, archive time and first message body. */
+export function checkedForumPost(post: ForumPost) {
+	checkChannelName("a post name", post.name);
+	if ((post.card === undefined) === (post.content === undefined))
+		throw invalid("a post has a card or text as its first message, not both");
+	const autoArchive = post.autoArchive ?? POST_ARCHIVE_MINUTES;
+	if (!AUTO_ARCHIVE_MINUTES.includes(autoArchive))
+		throw invalid(
+			`a post archives after ${AUTO_ARCHIVE_MINUTES.join(", ")} minutes`,
+		);
+	let message: ReturnType<typeof cardBody> | ReturnType<typeof checkedText>;
+	let mentions: string[] = [];
+	if (post.card) message = cardBody(post.card);
+	else {
+		if (!post.content) throw invalid("a post needs text");
+		const text = checkedText(post.content, post.mentions);
+		message = text;
+		mentions = text.allowed_mentions.users;
+	}
+	return {
+		name: post.name,
+		autoArchive,
+		appliedTags: checkedTagIds(post.appliedTags),
+		/** The first message as Discord takes it. */
+		message,
+		/** The users the first message may ping. */
+		mentions,
+	};
+}

package/src/core/discord/poster/poster-legacy-card.ts

@@ -0,0 +1,84 @@
+import { DISCORD_LIMITS, type DiscordCard } from "./poster.ts";
+import {
+	cardRows,
+	checkCardTextSize,
+	checkPicture,
+} from "./poster-card-parts.ts";
+import { invalid } from "./poster-errors.ts";
+
+/** A `preview` flattened to one line: every run of whitespace, line breaks included, becomes one space. */
+export function flatPreview(preview: string): string {
+	return preview.replace(/\s+/g, " ").trim();
+}
+
+/**
+ * The body of a card with a `preview`: a legacy message whose `content` is the preview line (what
+ * the push notification shows), with one embed for the card's text and picture and ordinary action
+ * rows for its buttons and menus. No Components V2 flag, so Discord takes `content` and `embeds`.
+ * `components` is always sent, empty when the card has none, so an edit that drops the buttons
+ * removes them. The text guard is the V2 card's, and no mention in it pings.
+ */
+export function legacyCardBody(card: DiscordCard & { preview: string }) {
+	const content = flatPreview(card.preview);
+	if (content === "")
+		throw invalid("a card's preview has text in it (or leave it out)");
+	if (content.length > DISCORD_LIMITS.contentChars)
+		throw invalid(
+			`a card's preview is at most ${DISCORD_LIMITS.contentChars} characters`,
+		);
+	const sections = card.sections.filter((section) => section !== "");
+	checkCardTextSize([
+		card.title,
+		...sections,
+		...(card.footer ? [card.footer] : []),
+	]);
+	if ([...card.title].length > DISCORD_LIMITS.embedTitleChars)
+		throw invalid(
+			`a card with a preview has a title of at most ${DISCORD_LIMITS.embedTitleChars} characters`,
+		);
+	// The description joins the sections with blank lines, which the text guard above did not count.
+	const description = sections.join("\n\n");
+	const chars = (value: string) => [...value].length;
+	if (chars(description) > DISCORD_LIMITS.embedDescriptionChars)
+		throw invalid(
+			`a card with a preview has text of at most ${DISCORD_LIMITS.embedDescriptionChars} characters once its sections are joined`,
+		);
+	const footer = card.footer ?? "";
+	if (chars(footer) > DISCORD_LIMITS.embedFooterChars)
+		throw invalid(
+			`a card with a preview has a footer of at most ${DISCORD_LIMITS.embedFooterChars} characters`,
+		);
+	if (
+		chars(card.title) + chars(description) + chars(footer) >
+		DISCORD_LIMITS.embedChars
+	)
+		throw invalid(
+			`a card with a preview holds at most ${DISCORD_LIMITS.embedChars} characters in its title, text and footer`,
+		);
+	const thumbnail = card.thumbnail
+		? checkPicture("a card's thumbnail", card.thumbnail)
+		: undefined;
+	const image = card.image
+		? checkPicture("a card's image", card.image)
+		: undefined;
+	const components = cardRows(card);
+	if (components.length > DISCORD_LIMITS.actionRows)
+		throw invalid(
+			`a card with a preview holds at most ${DISCORD_LIMITS.actionRows} rows: one for each menu and one for the buttons`,
+		);
+	return {
+		content,
+		embeds: [
+			{
+				title: card.title,
+				...(sections.length > 0 ? { description } : {}),
+				...(card.accent === undefined ? {} : { color: card.accent }),
+				...(card.footer ? { footer: { text: card.footer } } : {}),
+				...(thumbnail ? { thumbnail: { url: thumbnail.media.url } } : {}),
+				...(image ? { image: { url: image.media.url } } : {}),
+			},
+		],
+		components,
+		allowed_mentions: { parse: [] as never[] },
+	};
+}

package/src/core/discord/poster/poster.ts

@@ -94,10 +94,25 @@ export interface CardPicture {
 
 /**
  * A card the bot posts: a Components V2 container with a heading, text sections, a quiet last line
- * and an optional colour bar. Plain data, so a fake can hold and compare it. It carries no
- * `content` and no embeds and never pings.
+ * and an optional colour bar. Plain data, so a fake can hold and compare it. It never pings. A card
+ * without `preview` carries no `content` and no embeds, so its push notification is blank; with
+ * `preview` it is a legacy message (see `preview`).
  */
 export interface DiscordCard {
+	/**
+	 * One line of plain text for the message's `content`, which is what Discord builds a push or
+	 * desktop notification from (a Components V2 message has none). Whitespace runs, line breaks
+	 * included, are flattened to one space; at most 2,000 characters after that, and a short line
+	 * (about 120 characters) reads best. When set, the card is sent as a legacy message instead:
+	 * `content: preview`, one embed (the title, the sections joined by blank lines as its
+	 * description, `accent` as its colour, `footer`, `thumbnail` and `image`) and ordinary action
+	 * rows for `buttons`, `links` and `selects` (at most five rows: one per menu, one for the
+	 * buttons). An embed has no alt text, so a picture's `description` is dropped. `editCard` and
+	 * `editWebhookCard` re-send the card (and an edit sets `content` too), but the poster cannot
+	 * change a message's kind: an edit that would turn a Components V2 message into a preview card,
+	 * or the other way round, is `rejected`.
+	 */
+	preview?: string;
 	/** The colour of the bar along the side, as 0xRRGGBB. */
 	accent?: number;
 	title: string;
@@ -166,6 +181,81 @@ export interface CategoryChannel {
 	topic: string;
 }
 
+/** What a channel is, as `channelKind` tells it. */
+export type ChannelKind =
+	| "text"
+	| "category"
+	/** A thread of a text channel (or of any parent that is not a forum). */
+	| "thread"
+	| "forum"
+	/** A post of a forum: a thread whose parent is a forum, so its first message has the thread's own id. */
+	| "forum_post"
+	/** Voice, stage, announcement, media and the rest. */
+	| "other";
+
+/** A channel's guild, kind and parent. */
+export interface ChannelKindInfo {
+	guildId: string;
+	kind: ChannelKind;
+	/** The category of a text channel or forum, the parent channel of a thread (the forum for a `forum_post`); absent for a channel under no category. */
+	parentId?: string;
+}
+
+/** A tag a forum offers its posts. */
+export interface ForumTag {
+	id: string;
+	/** 1 to 20 characters. */
+	name: string;
+	/** Only members with Manage Threads can apply a moderated tag. */
+	moderated: boolean;
+	/** A Unicode emoji shown beside the name. */
+	emoji?: string;
+	/** The id of a custom emoji shown beside the name; never together with `emoji`. */
+	emojiId?: string;
+}
+
+/**
+ * A tag as `setForumTags` takes it: a `ForumTag` read earlier is one, and a tag with no `id` is made
+ * new. Discord replaces the forum's whole set, so a tag left out is deleted.
+ */
+export interface ForumTagInput {
+	id?: string;
+	name: string;
+	moderated?: boolean;
+	emoji?: string;
+	emojiId?: string;
+}
+
+/** How many minutes without a message Discord waits before it archives a thread. */
+export type ThreadAutoArchive = 60 | 1_440 | 4_320 | 10_080;
+
+/** A post for `createForumPost`: a name, tags, and a first message that is a card or plain text. */
+export type ForumPost = {
+	/** 1 to 100 characters. */
+	name: string;
+	/** Tag ids of the forum, at most five (`invalid`); an id the forum does not offer is `rejected`. */
+	appliedTags?: readonly string[];
+	/** Default a week, as `startThread`. */
+	autoArchive?: ThreadAutoArchive;
+} & (
+	| { card: DiscordCard; content?: undefined; mentions?: undefined }
+	| {
+			card?: undefined;
+			/** 1 to 2,000 characters. */
+			content: string;
+			/** The only users the first message may ping (at most 20). */
+			mentions?: readonly string[];
+	  }
+);
+
+/** The post `createForumPost` made. */
+export interface ForumPostCreated {
+	/** The post's id: a thread is a channel. */
+	threadId: string;
+	/** The id of the first message, which is the thread's own id; `editCard` and `pin` take it with `threadId`. */
+	messageId: string;
+}
+
 /** Discord's limits as the poster keeps them. */
 export const DISCORD_LIMITS = Object.freeze({
 	contentChars: 2_000,
@@ -184,6 +274,18 @@ export const DISCORD_LIMITS = Object.freeze({
 	/** The most buttons (links too) a card's row holds. */
 	cardButtons: 5,
 	selectOptions: 25,
+	/** The most characters an embed title holds (a `preview` card's title). */
+	embedTitleChars: 256,
+	/** The most characters an embed's description and footer text hold, and its title, description and footer together. */
+	embedDescriptionChars: 4_096,
+	embedFooterChars: 2_048,
+	embedChars: 6_000,
+	/** The most action rows a legacy message holds (a `preview` card: one per menu, one for the buttons). */
+	actionRows: 5,
+	/** The most tags a forum holds, characters in a tag's name, and tags applied to one post. */
+	forumTags: 20,
+	forumTagNameChars: 20,
+	postTags: 5,
 } as const);
 
 export interface DiscordPoster {
@@ -258,7 +360,10 @@ export interface DiscordPoster {
 	sayCard(channelId: string, card: DiscordCard): Promise<PostedMessage>;
 	/**
 	 * Replaces a card the bot posted, keeping it a Components V2 message. A message posted without
-	 * the flag cannot become a card: `rejected` (delete it and post a new card).
+	 * the flag cannot become a card: `rejected` (delete it and post a new card). Discord refuses the
+	 * edit of any message in an archived thread (`rejected`, code 50083): call `setThreadArchived(id,
+	 * false)` first. The one exception is a forum post's first message (`messageId` equal to
+	 * `channelId`), where the poster opens the archived post again itself.
 	 */
 	editCard(
 		channelId: string,
@@ -312,11 +417,20 @@ export interface DiscordPoster {
 	/** Deletes a channel; one that is already gone is `channel_gone`. */
 	deleteChannel(channelId: string): Promise<void>;
 	/**
-	 * Renames a channel (Manage Channels). Discord lets a channel be renamed twice in ten minutes; a
+	 * Renames a channel, or a thread or a forum post (a thread is a channel; the call is the same,
+	 * and Manage Threads is the permission for another person's post; a rename opens an archived thread again,
+	 * as Discord refuses the rename otherwise). Discord lets a channel be renamed twice in ten minutes; a
 	 * rename past that is not queued: it fails as `unavailable` after a short wait and is never sent
 	 * later.
 	 */
 	renameChannel(channelId: string, name: string): Promise<void>;
+	/**
+	 * What a channel is: a text channel, category, thread, forum, forum post or something else (and
+	 * its guild and parent), so a plugin can tell a post of a forum from a thread of a text channel
+	 * before it starts a thread. Kept after the first read. `channel_gone`; `invalid` with
+	 * `wrong_guild` for a direct-message channel.
+	 */
+	channelKind(channelId: string): Promise<ChannelKindInfo>;
 
 	// Threads
 
@@ -339,4 +453,27 @@ export interface DiscordPoster {
 	 * the entry is not among the log's newest 50.
 	 */
 	threadCloser(threadId: string, state: ThreadState): Promise<ThreadCloser>;
+
+	// Forums
+
+	/** The tags a forum offers, in Discord's order. `invalid` with `not_forum` for a channel that is no forum. */
+	forumTags(forumId: string): Promise<ForumTag[]>;
+	/**
+	 * Replaces the forum's tags with these (Manage Channels): a tag with an `id` is kept and may be
+	 * renamed, one without is made, and one left out is deleted, so read `forumTags` first to add one.
+	 * At most 20 tags, no id twice. Returns the forum's tags afterwards, with the new ids.
+	 */
+	setForumTags(
+		forumId: string,
+		tags: readonly ForumTagInput[],
+	): Promise<ForumTag[]>;
+	/**
+	 * A post in a forum with its first message in the same request (Discord does not allow an empty
+	 * post): a card (Components V2, or a legacy message when it has a `preview`), or plain text. `editCard(threadId, messageId, card)` edits a card
+	 * first message. `invalid` with `not_forum` for a channel that is no forum; `forbidden` without
+	 * Create Posts; `rejected` for a tag the forum does not offer.
+	 */
+	createForumPost(forumId: string, post: ForumPost): Promise<ForumPostCreated>;
+	/** Replaces the tags applied to a forum post (at most five; none clears them), opening the post again if it is archived. `invalid` with `not_forum` when the thread is no forum post. */
+	setPostTags(threadId: string, tagIds: readonly string[]): Promise<void>;
 }

package/src/core/discord/poster/rest-poster-core.ts

@@ -1,5 +1,6 @@
 import { type REST, Routes } from "discord.js";
 import { DiscordPosterError, failure } from "./poster-errors.ts";
+import { isThreadType } from "./poster-forum.ts";
 
 /** The options of discord.js' REST client that the poster uses. */
 export interface RestOptions {
@@ -48,13 +49,28 @@ export function text(value: unknown): string | undefined {
 	return typeof value === "string" && value !== "" ? value : undefined;
 }
 
+/** What the poster keeps of a channel it read. */
+export interface ReadChannel {
+	guildId: string;
+	type: unknown;
+	/** The category of a channel, the parent channel of a thread; kept for a thread only, read afresh for any other channel. */
+	parentId?: string;
+}
+
 /** What the poster's two halves share: the REST client, the bot's id and the channels already read. */
 export interface RestCore {
 	rest: DiscordRest;
 	/** The bot's own user id, read on first use. */
 	bot(): Promise<string>;
-	/** A channel's guild and type; neither changes, so they are kept. */
-	readChannel(channelId: string): Promise<{ guildId: string; type: unknown }>;
+	/**
+	 * A channel's guild, type and, for a thread, parent; none changes, so they are kept. A text
+	 * channel or forum can be moved to another category, so its `parentId` is only there when the
+	 * call asks `withParent`, and then Discord is asked again.
+	 */
+	readChannel(
+		channelId: string,
+		options?: { withParent?: boolean },
+	): Promise<ReadChannel>;
 	/** The guild of a category; fails when the channel is no category. */
 	guildOf(categoryId: string): Promise<string>;
 }
@@ -76,11 +92,15 @@ export function restCore(rest: DiscordRest): RestCore {
 			});
 		return botId;
 	};
-	// A channel's guild and type never change; neither is a secret.
-	const known = new Map<string, { guildId: string; type: unknown }>();
-	const readChannel = async (channelId: string) => {
+	// A channel's guild and type never change, nor does a thread's parent; none is a secret.
+	// The category of any other channel does change, so it is never kept.
+	const known = new Map<string, ReadChannel>();
+	const readChannel = async (
+		channelId: string,
+		options: { withParent?: boolean } = {},
+	): Promise<ReadChannel> => {
 		const held = known.get(channelId);
-		if (held) return held;
+		if (held && (!options.withParent || isThreadType(held.type))) return held;
 		const channel = object(
 			await rest.get(Routes.channel(channelId)).catch((error: unknown) => {
 				throw failure("reading a channel", error);
@@ -91,8 +111,16 @@ export function restCore(rest: DiscordRest): RestCore {
 			throw new DiscordPosterError("invalid", "that channel is in no guild", {
 				reason: "wrong_guild",
 			});
-		const read = { guildId, type: channel.type };
-		known.set(channelId, read);
+		const parentId = text(channel.parent_id);
+		const read = {
+			guildId,
+			type: channel.type,
+			...(parentId ? { parentId } : {}),
+		};
+		known.set(
+			channelId,
+			isThreadType(read.type) ? read : { guildId, type: read.type },
+		);
 		return read;
 	};
 	const guildOf = async (categoryId: string): Promise<string> => {

package/src/core/discord/poster/rest-poster-forum.ts

@@ -0,0 +1,133 @@
+import { Routes } from "discord.js";
+import type { ChannelKind, DiscordPoster } from "./poster.ts";
+import { checkSnowflake } from "./poster-checks.ts";
+import { DiscordPosterError, failure } from "./poster-errors.ts";
+import {
+	CHANNEL_TYPE,
+	checkedForumPost,
+	checkedForumTags,
+	checkedTagIds,
+	isThreadType,
+	notForum,
+	readTag,
+} from "./poster-forum.ts";
+import { object, type RestCore, text } from "./rest-poster-core.ts";
+
+/** The poster's calls that tell what a channel is, and the forum calls. */
+export type ForumOperations = Pick<
+	DiscordPoster,
+	| "channelKind"
+	| "forumTags"
+	| "setForumTags"
+	| "createForumPost"
+	| "setPostTags"
+>;
+
+export function forumOperations(core: RestCore): ForumOperations {
+	const { rest } = core;
+
+	/** What a channel is, from its type and, for a thread, its parent's. */
+	const kindOf = async (channelId: string) => {
+		// A thread's parent never changes; a channel's category does, so it is read afresh.
+		const read = await core.readChannel(channelId, { withParent: true });
+		let kind: ChannelKind;
+		if (read.type === CHANNEL_TYPE.text) kind = "text";
+		else if (read.type === CHANNEL_TYPE.category) kind = "category";
+		else if (read.type === CHANNEL_TYPE.forum) kind = "forum";
+		else if (isThreadType(read.type)) {
+			const parent = read.parentId
+				? await core.readChannel(read.parentId)
+				: undefined;
+			kind = parent?.type === CHANNEL_TYPE.forum ? "forum_post" : "thread";
+		} else kind = "other";
+		return {
+			guildId: read.guildId,
+			kind,
+			...(read.parentId ? { parentId: read.parentId } : {}),
+		};
+	};
+
+	const requireForum = async (forumId: string) => {
+		if ((await core.readChannel(forumId)).type !== CHANNEL_TYPE.forum)
+			throw notForum("that channel");
+	};
+
+	return {
+		async channelKind(channelId) {
+			checkSnowflake("a channel", channelId);
+			return kindOf(channelId);
+		},
+		async forumTags(forumId) {
+			checkSnowflake("a forum", forumId);
+			const forum = object(
+				await rest.get(Routes.channel(forumId)).catch((error: unknown) => {
+					throw failure("reading a forum", error);
+				}),
+			);
+			if (forum.type !== CHANNEL_TYPE.forum) throw notForum("that channel");
+			return (Array.isArray(forum.available_tags) ? forum.available_tags : [])
+				.map(readTag)
+				.filter((tag) => tag !== undefined);
+		},
+		async setForumTags(forumId, tags) {
+			checkSnowflake("a forum", forumId);
+			const wire = checkedForumTags(tags);
+			await requireForum(forumId);
+			const changed = object(
+				await rest
+					.patch(Routes.channel(forumId), { body: { available_tags: wire } })
+					.catch((error: unknown) => {
+						throw failure("setting a forum's tags", error);
+					}),
+			);
+			return (
+				Array.isArray(changed.available_tags) ? changed.available_tags : []
+			)
+				.map(readTag)
+				.filter((tag) => tag !== undefined);
+		},
+		async createForumPost(forumId, post) {
+			checkSnowflake("a forum", forumId);
+			const checked = checkedForumPost(post);
+			await requireForum(forumId);
+			const made = object(
+				await rest
+					.post(Routes.threads(forumId), {
+						body: {
+							name: checked.name,
+							auto_archive_duration: checked.autoArchive,
+							...(checked.appliedTags.length > 0
+								? { applied_tags: checked.appliedTags }
+								: {}),
+							message: checked.message,
+						},
+					})
+					.catch((error: unknown) => {
+						throw failure("making a forum post", error);
+					}),
+			);
+			const threadId = text(made.id);
+			if (!threadId)
+				throw new DiscordPosterError("rejected", "Discord made no post");
+			// The first message of a post has the post's own id.
+			return {
+				threadId,
+				messageId: text(object(made.message).id) ?? threadId,
+			};
+		},
+		async setPostTags(threadId, tagIds) {
+			checkSnowflake("a thread", threadId);
+			const applied = checkedTagIds(tagIds);
+			if ((await kindOf(threadId)).kind !== "forum_post")
+				throw notForum("that thread's parent");
+			// An archived post is refused (50083) unless the same PATCH opens it again.
+			await rest
+				.patch(Routes.channel(threadId), {
+					body: { applied_tags: applied, archived: false },
+				})
+				.catch((error: unknown) => {
+					throw failure("setting a post's tags", error);
+				});
+		},
+	};
+}

package/src/core/discord/poster/rest-poster-guild.ts

@@ -2,6 +2,7 @@ import { AuditLogEvent, RESTJSONErrorCodes, Routes } from "discord.js";
 import type { DiscordPoster } from "./poster.ts";
 import { checkChannelName, checkSnowflake } from "./poster-checks.ts";
 import { DiscordPosterError, failure, isCode } from "./poster-errors.ts";
+import { isThreadType } from "./poster-forum.ts";
 import { object, type RestCore, text } from "./rest-poster-core.ts";
 
 /** How long a rename waits: past Discord's limit on renames the request would be held for minutes. */
@@ -146,13 +147,15 @@ export function guildOperations(
 		async renameChannel(channelId, name) {
 			checkSnowflake("a channel", channelId);
 			checkChannelName("a channel name", name);
+			// Discord refuses a rename of an archived thread (50083) unless the same PATCH opens it again.
+			const { type } = await core.readChannel(channelId);
 			// discord.js sleeps out a rate limit's wait (a rename sublimit can be minutes) without
 			// looking at the signal, so the call is also raced against a timer: the caller is freed
 			// at once, and the signal keeps the held request from being sent later.
 			let timer: ReturnType<typeof setTimeout> | undefined;
 			const patch = rest
 				.patch(Routes.channel(channelId), {
-					body: { name },
+					body: isThreadType(type) ? { name, archived: false } : { name },
 					signal: AbortSignal.timeout(renameWaitMs),
 				})
 				.catch((error: unknown) => {