pi-roundtable 0.26.3 → 0.27.0

package/src/core/discord/discord-surface.ts

@@ -16,7 +16,11 @@ import type {
 	ChannelContext,
 	ChannelContextOptions,
 } from "../contract/channel-context.ts";
-import type { ChatSurface, SurfaceThreads } from "../contract/surface.ts";
+import type {
+	ChatSurface,
+	SurfaceMessageEvents,
+	SurfaceThreads,
+} from "../contract/surface.ts";
 import type {
 	ChannelKey,
 	InboundMessage,
@@ -42,7 +46,8 @@ import type { ChannelInfo, DiscordConnection } from "./connection.ts";
 import { DiscordThreadHost } from "./dispatch-thread-host.ts";
 import { DISCORD_FORMATTING, pickFormatting } from "./formatting.ts";
 import { DEFAULT_FRESH_MARKER, postFreshMarker } from "./fresh-marker.ts";
-import { lateAnswerMessage, toInbound } from "./inbound-message.ts";
+import { lateAnswerMessage } from "./inbound-message.ts";
+import { listenForMessages, reportChanges } from "./message-changes.ts";
 import type { CardChannel, LateTurn } from "./owner-cards.ts";
 import { DiscordOwnerOps } from "./owner-discord.ts";
 import { stopPanel } from "./stop-button.ts";
@@ -103,7 +108,7 @@ export class DiscordSurface
 			GatewayIntentBits.DirectMessages,
 			GatewayIntentBits.MessageContent,
 		],
-		partials: [Partials.Channel],
+		partials: [Partials.Channel, Partials.Message],
 		allowedMentions: { parse: [] },
 	});
 
@@ -263,21 +268,14 @@ export class DiscordSurface
 		onMessage(lateAnswerMessage(turn));
 	}
 
-	async start(onMessage: (message: InboundMessage) => void): Promise<void> {
+	async start(
+		onMessage: (message: InboundMessage) => void,
+		events?: SurfaceMessageEvents,
+	): Promise<void> {
 		const { logger, token } = this.#options;
 		this.#onMessage = onMessage;
-		this.#client.on(Events.MessageCreate, (message) => {
-			toInbound(message, {
-				botId: this.#client.user?.id,
-				applicationId: this.#client.application?.id,
-			})
-				.then((inbound) => {
-					if (inbound) onMessage(inbound);
-				})
-				.catch((error: unknown) =>
-					logger.error({ err: error }, "inbound message could not be read"),
-				);
-		});
+		if (events) reportChanges(this.#client, events, logger);
+		listenForMessages(this.#client, onMessage, logger);
 		this.#client.on(Events.InteractionCreate, (interaction) => {
 			void this.#dispatch(interaction);
 		});

package/src/core/discord/message-changes.ts

@@ -0,0 +1,66 @@
+import { type Client, Events } from "discord.js";
+import type { InboundMessage } from "../contract/channels.ts";
+import type { SurfaceMessageEvents } from "../contract/surface.ts";
+import { channelKey } from "../contract/surface.ts";
+import type { Logger } from "../log.ts";
+import { toInbound } from "./inbound-message.ts";
+
+/** Hands every message the client sees to `deliver` as the neutral message; the bot's own are left out. */
+export function listenForMessages(
+	client: Client,
+	deliver: (message: InboundMessage) => void,
+	logger: Logger,
+): void {
+	client.on(Events.MessageCreate, (message) => {
+		toInbound(message, {
+			botId: client.user?.id,
+			applicationId: client.application?.id,
+		})
+			.then((inbound) => {
+				if (inbound) deliver(inbound);
+			})
+			.catch((error: unknown) =>
+				logger.error({ err: error }, "inbound message could not be read"),
+			);
+	});
+}
+
+/**
+ * Reports deleted and edited messages to the claims. The partial-message setting of the client
+ * lets a delete or an edit of a message it never cached arrive; an edit of one is fetched to read
+ * it. A delete carries only ids, so it is reported for the bot's own messages too.
+ */
+export function reportChanges(
+	client: Client,
+	events: SurfaceMessageEvents,
+	logger: Logger,
+): void {
+	const deleted = (channelId: string, id: string, guildId: string | null) =>
+		events.deleted(channelKey("discord", channelId), id, guildId ?? undefined);
+	client.on(Events.MessageDelete, (message) =>
+		deleted(message.channelId, message.id, message.guildId),
+	);
+	client.on(Events.MessageBulkDelete, (messages, channel) => {
+		for (const id of messages.keys()) deleted(channel.id, id, channel.guildId);
+	});
+	client.on(Events.MessageUpdate, (before, after) => {
+		void (async () => {
+			const current = after.partial ? await after.fetch() : after;
+			// An unfurled link, a pin or an edit by the bot itself is not what a claim keeps track of.
+			if (
+				!before.partial &&
+				before.content === current.content &&
+				before.embeds.length === current.embeds.length &&
+				before.attachments.size === current.attachments.size
+			)
+				return;
+			const inbound = await toInbound(current, {
+				botId: client.user?.id,
+				applicationId: client.application?.id,
+			});
+			if (inbound) events.edited(inbound);
+		})().catch((error: unknown) =>
+			logger.warn({ err: error }, "an edited message could not be read"),
+		);
+	});
+}

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

@@ -1,6 +1,8 @@
 import {
+	type CardPicture,
 	DISCORD_LIMITS,
 	type DiscordCard,
+	type WebhookCardPost,
 	type WebhookPost,
 } from "./poster.ts";
 import { DiscordPosterError } from "./poster-errors.ts";
@@ -14,6 +16,9 @@ const AVATAR_URL_MAX = 2_048;
 /** The longest address Discord accepts on a link button. */
 const LINK_BUTTON_URL_MAX = 512;
 
+/** The longest alt text Discord takes for a thumbnail or a gallery item. */
+const PICTURE_DESCRIPTION_MAX = 1_024;
+
 /** Discord's style number for a button that opens an address. */
 const LINK_BUTTON_STYLE = 5;
 
@@ -93,6 +98,21 @@ export function checkedText(
 	};
 }
 
+/** The checked body of a webhook's card post or edit: the card, and for a post the name and picture it shows. */
+export function checkedWebhookCard(post: WebhookCardPost) {
+	const webhook = checkWebhookName(post.webhook);
+	const username = checkUsername(post.username);
+	const card = cardBody(post.card);
+	return {
+		webhook,
+		body: {
+			username,
+			...(isHttps(post.avatarUrl) ? { avatar_url: post.avatarUrl } : {}),
+			...card,
+		},
+	};
+}
+
 /** The checked body of a webhook post, its webhook name, and the files to send with it. */
 export function checkedPost(post: WebhookPost) {
 	const webhook = checkWebhookName(post.webhook);
@@ -120,6 +140,26 @@ export function checkedPost(post: WebhookPost) {
 	};
 }
 
+/** The checked wire form of a card's picture: an `https` address, and an alt text of 1 to 1,024 characters when given. */
+function checkPicture(label: string, picture: CardPicture) {
+	if (!(isHttps(picture.url) && picture.url === picture.url.trim()))
+		throw invalid(
+			`${label} has an https address of at most ${AVATAR_URL_MAX} characters`,
+		);
+	const { description } = picture;
+	if (
+		description !== undefined &&
+		(description === "" || [...description].length > PICTURE_DESCRIPTION_MAX)
+	)
+		throw invalid(
+			`${label} has a description of 1 to ${PICTURE_DESCRIPTION_MAX} characters`,
+		);
+	return {
+		media: { url: picture.url },
+		...(description === undefined ? {} : { description }),
+	};
+}
+
 function isHttps(url: string | undefined): url is string {
 	if (url === undefined || url.length > AVATAR_URL_MAX) return false;
 	try {
@@ -155,11 +195,9 @@ export function checkChannelName(label: string, name: string): void {
  */
 export function cardBody(card: DiscordCard) {
 	const heading = `### ${card.title}`;
-	const texts = [
-		heading,
-		...card.sections.filter((section) => section !== ""),
-		...(card.footer ? [`-# ${card.footer}`] : []),
-	];
+	const main = [heading, ...card.sections.filter((section) => section !== "")];
+	const footer = card.footer ? [`-# ${card.footer}`] : [];
+	const texts = [...main, ...footer];
 	const size = texts.reduce((sum, text) => sum + [...text].length, 0);
 	if (size > DISCORD_LIMITS.cardTextChars)
 		throw invalid(
@@ -167,7 +205,13 @@ export function cardBody(card: DiscordCard) {
 		);
 	if (texts.some((text) => text.trim() === ""))
 		throw invalid("a card has no empty text");
-	const [first, ...rest] = texts;
+	const [first, ...rest] = main;
+	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 buttons = card.buttons ?? [];
 	const links = card.links ?? [];
 	if (buttons.length + links.length > DISCORD_LIMITS.cardButtons)
@@ -222,9 +266,19 @@ export function cardBody(card: DiscordCard) {
 				type: 17,
 				...(card.accent === undefined ? {} : { accent_color: card.accent }),
 				components: [
-					{ type: 10, content: first },
-					...(rest.length > 0 ? [{ type: 14, divider: true, spacing: 1 }] : []),
+					thumbnail
+						? {
+								type: 9,
+								components: [{ type: 10, content: first }],
+								accessory: { type: 11, ...thumbnail },
+							}
+						: { type: 10, content: first },
+					...(texts.length > 1
+						? [{ type: 14, divider: true, spacing: 1 }]
+						: []),
 					...rest.map((content) => ({ type: 10, content })),
+					...(image ? [{ type: 12, items: [image] }] : []),
+					...footer.map((content) => ({ type: 10, content })),
 					...selects.map((select) => ({
 						type: 1,
 						components: [

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

@@ -39,6 +39,17 @@ export interface WebhookPost {
 	mentions?: readonly string[];
 }
 
+/** A card a channel's webhook posts, under a name and picture the plugin chooses. */
+export interface WebhookCardPost {
+	/** The webhook that posts it; the same rule and meaning as `WebhookPost.webhook`. */
+	webhook: string;
+	/** The name shown for this message; the same rule as `WebhookPost.username`. */
+	username: string;
+	/** An `https` address of at most 2,048 characters for the picture beside the name; anything else is left out. */
+	avatarUrl?: string;
+	card: DiscordCard;
+}
+
 /** A message the poster posted, to edit, delete or pin later. */
 export interface PostedMessage {
 	channelId: string;
@@ -73,6 +84,14 @@ export interface RecentMessage {
 	referencedMessageId?: string;
 }
 
+/** A picture on a card: an address Discord fetches, and the text a screen reader gives for it. */
+export interface CardPicture {
+	/** An `https` address of at most 2,048 characters (`invalid` otherwise). */
+	url: string;
+	/** Alt text of 1 to 1,024 characters. */
+	description?: string;
+}
+
 /**
  * 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
@@ -83,6 +102,10 @@ export interface DiscordCard {
 	accent?: number;
 	title: string;
 	sections: readonly string[];
+	/** A small picture beside the heading (a Section with a Thumbnail); the heading is the section's text. */
+	thumbnail?: CardPicture;
+	/** A picture under the text sections, above the quiet last line (a Media Gallery of one item). */
+	image?: CardPicture;
 	footer?: string;
 	/** Up to five buttons in one row under the text; a press comes to the Discord plugin's interactions by `customId`. */
 	buttons?: readonly CardButton[];
@@ -178,6 +201,24 @@ export interface DiscordPoster {
 		edit: { content: string; mentions?: readonly string[] },
 		webhooks: readonly string[],
 	): Promise<void>;
+	/**
+	 * Posts a card through the channel's webhook of that name, found or made on first use, so the
+	 * card shows the webhook's name and picture instead of the bot's. The webhook is the bot's own,
+	 * so the card's buttons and menus reach the Discord plugin's interactions as the bot's own cards'
+	 * do. It pings nobody.
+	 */
+	postCard(channelId: string, post: WebhookCardPost): Promise<PostedMessage>;
+	/**
+	 * Replaces a card a webhook posted, asking each named webhook in order (a webhook edits only its
+	 * own messages); makes none. `message_gone` when none of them posted it; a message that is not a
+	 * card cannot become one (`rejected`).
+	 */
+	editWebhookCard(
+		channelId: string,
+		messageId: string,
+		card: DiscordCard,
+		webhooks: readonly string[],
+	): Promise<void>;
 	/**
 	 * Deletes a message one of the named webhooks posted, else as the bot (Manage Messages, for one
 	 * an earlier webhook of the same name posted); makes none. `message_gone` when it does not exist.

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

@@ -0,0 +1,130 @@
+import { Routes } from "discord.js";
+import type { DiscordMessage, DiscordPoster, RecentMessage } from "./poster.ts";
+import { checkSnowflake } from "./poster-checks.ts";
+import { DiscordPosterError, failure } from "./poster-errors.ts";
+import { type DiscordRest, object, text } from "./rest-poster-core.ts";
+
+/** How many pins Discord lists in a page, and how many pages the poster reads (250 pins, the most a channel keeps). */
+const PIN_PAGE = 50;
+const PIN_PAGES = 5;
+
+/** The poster's pin calls and the reads of messages. */
+export type ReadOperations = Pick<
+	DiscordPoster,
+	"pin" | "unpin" | "pinnedIds" | "message" | "recentMessages"
+>;
+
+export function readOperations(rest: DiscordRest): ReadOperations {
+	return {
+		async pin(channelId, messageId) {
+			checkSnowflake("a channel", channelId);
+			checkSnowflake("a message", messageId);
+			await rest
+				.put(Routes.channelMessagesPin(channelId, messageId))
+				.catch((error: unknown) => {
+					throw failure("pinning a message", error);
+				});
+		},
+		async unpin(channelId, messageId) {
+			checkSnowflake("a channel", channelId);
+			checkSnowflake("a message", messageId);
+			await rest
+				.delete(Routes.channelMessagesPin(channelId, messageId))
+				.catch((error: unknown) => {
+					throw failure("unpinning a message", error);
+				});
+		},
+		async pinnedIds(channelId) {
+			checkSnowflake("a channel", channelId);
+			// Discord keeps at most 250 pins in a channel and lists 50 a page, newest first; `before`
+			// takes the `pinned_at` of the last one read. Five pages cover a channel.
+			const ids: string[] = [];
+			let before: string | undefined;
+			for (let page = 0; page < PIN_PAGES; page += 1) {
+				const query = new URLSearchParams({ limit: String(PIN_PAGE) });
+				if (before) query.set("before", before);
+				const listed = object(
+					await rest
+						.get(Routes.channelMessagesPins(channelId), { query })
+						.catch((error: unknown) => {
+							throw failure("listing a channel's pins", error);
+						}),
+				);
+				const items = Array.isArray(listed.items) ? listed.items : [];
+				for (const entry of items) {
+					const id = text(object(object(entry).message).id);
+					if (id) ids.push(id);
+				}
+				const last = text(object(items.at(-1)).pinned_at);
+				if (listed.has_more !== true || !last) break;
+				before = last;
+			}
+			return ids;
+		},
+		async message(channelId, messageId): Promise<DiscordMessage> {
+			checkSnowflake("a channel", channelId);
+			checkSnowflake("a message", messageId);
+			const read = object(
+				await rest
+					.get(Routes.channelMessage(channelId, messageId))
+					.catch((error: unknown) => {
+						throw failure("reading a message", error);
+					}),
+			);
+			const id = text(read.id);
+			if (!id)
+				throw new DiscordPosterError("rejected", "Discord sent no message");
+			const webhookId = text(read.webhook_id);
+			const files = (
+				Array.isArray(read.attachments) ? read.attachments : []
+			).flatMap((entry) => {
+				const file = object(entry);
+				const name = text(file.filename);
+				const url = text(file.url);
+				return name && url
+					? [
+							{
+								name,
+								url,
+								contentType: text(file.content_type) ?? "",
+								size: typeof file.size === "number" ? file.size : 0,
+							},
+						]
+					: [];
+			});
+			return {
+				id,
+				authorId: text(object(read.author).id) ?? "",
+				...(webhookId ? { webhookId } : {}),
+				content: typeof read.content === "string" ? read.content : "",
+				files,
+			};
+		},
+		async recentMessages(channelId, limit): Promise<RecentMessage[]> {
+			checkSnowflake("a channel", channelId);
+			const listed = await rest
+				.get(Routes.channelMessages(channelId), {
+					query: new URLSearchParams({
+						limit: String(Math.min(50, Math.max(1, Math.trunc(limit)))),
+					}),
+				})
+				.catch((error: unknown) => {
+					throw failure("listing a channel's messages", error);
+				});
+			return (Array.isArray(listed) ? listed : []).flatMap((entry) => {
+				const message = object(entry);
+				const id = text(message.id);
+				if (!id) return [];
+				const referenced = text(object(message.message_reference).message_id);
+				return [
+					{
+						id,
+						type: typeof message.type === "number" ? message.type : 0,
+						authorId: text(object(message.author).id) ?? "",
+						...(referenced ? { referencedMessageId: referenced } : {}),
+					},
+				];
+			});
+		},
+	};
+}

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

@@ -1,15 +1,11 @@
 import { RESTJSONErrorCodes, Routes } from "discord.js";
-import type {
-	DiscordMessage,
-	DiscordPoster,
-	PosterFile,
-	RecentMessage,
-} from "./poster.ts";
+import type { DiscordPoster, PosterFile } from "./poster.ts";
 import {
 	cardBody,
 	checkAvatar,
 	checkedPost,
 	checkedText,
+	checkedWebhookCard,
 	checkSnowflake,
 	checkWebhookName,
 	invalid,
@@ -22,14 +18,11 @@ import {
 	text,
 } from "./rest-poster-core.ts";
 import { guildOperations } from "./rest-poster-guild.ts";
+import { readOperations } from "./rest-poster-read.ts";
 
 export type { DiscordRest, RestOptions } from "./rest-poster-core.ts";
 export { restOf } from "./rest-poster-core.ts";
 
-/** How many pins Discord lists in a page, and how many pages the poster reads (250 pins, the most a channel keeps). */
-const PIN_PAGE = 50;
-const PIN_PAGES = 5;
-
 interface Webhook {
 	id: string;
 	token: string;
@@ -252,6 +245,40 @@ export function restPoster(
 				}),
 			);
 		},
+		async postCard(channelId, post) {
+			checkSnowflake("a channel", channelId);
+			const { webhook: name, body } = checkedWebhookCard(post);
+			const sent = await through(
+				"posting a card",
+				channelId,
+				name,
+				(hook) =>
+					rest.post(Routes.webhook(hook.id, hook.token), {
+						auth: false,
+						body,
+						// Without this Discord drops the components of a webhook's post.
+						query: new URLSearchParams({
+							wait: "true",
+							with_components: "true",
+						}),
+					}),
+				true,
+			);
+			return { channelId, messageId: messageIdOf(sent) };
+		},
+		async editWebhookCard(channelId, messageId, card, names) {
+			checkSnowflake("a channel", channelId);
+			checkSnowflake("a message", messageId);
+			const body = cardBody(card);
+			for (const name of names) checkWebhookName(name);
+			await eachWebhook("editing a card", channelId, names, (hook) =>
+				rest.patch(Routes.webhookMessage(hook.id, hook.token, messageId), {
+					auth: false,
+					body,
+					query: new URLSearchParams({ with_components: "true" }),
+				}),
+			);
+		},
 		async remove(channelId, messageId, names) {
 			checkSnowflake("a channel", channelId);
 			checkSnowflake("a message", messageId);
@@ -373,116 +400,7 @@ export function restPoster(
 				throw failure("sending a direct message", error);
 			}
 		},
-		async pin(channelId, messageId) {
-			checkSnowflake("a channel", channelId);
-			checkSnowflake("a message", messageId);
-			await rest
-				.put(Routes.channelMessagesPin(channelId, messageId))
-				.catch((error: unknown) => {
-					throw failure("pinning a message", error);
-				});
-		},
-		async unpin(channelId, messageId) {
-			checkSnowflake("a channel", channelId);
-			checkSnowflake("a message", messageId);
-			await rest
-				.delete(Routes.channelMessagesPin(channelId, messageId))
-				.catch((error: unknown) => {
-					throw failure("unpinning a message", error);
-				});
-		},
-		async pinnedIds(channelId) {
-			checkSnowflake("a channel", channelId);
-			// Discord keeps at most 250 pins in a channel and lists 50 a page, newest first; `before`
-			// takes the `pinned_at` of the last one read. Five pages cover a channel.
-			const ids: string[] = [];
-			let before: string | undefined;
-			for (let page = 0; page < PIN_PAGES; page += 1) {
-				const query = new URLSearchParams({ limit: String(PIN_PAGE) });
-				if (before) query.set("before", before);
-				const listed = object(
-					await rest
-						.get(Routes.channelMessagesPins(channelId), { query })
-						.catch((error: unknown) => {
-							throw failure("listing a channel's pins", error);
-						}),
-				);
-				const items = Array.isArray(listed.items) ? listed.items : [];
-				for (const entry of items) {
-					const id = text(object(object(entry).message).id);
-					if (id) ids.push(id);
-				}
-				const last = text(object(items.at(-1)).pinned_at);
-				if (listed.has_more !== true || !last) break;
-				before = last;
-			}
-			return ids;
-		},
-		async message(channelId, messageId): Promise<DiscordMessage> {
-			checkSnowflake("a channel", channelId);
-			checkSnowflake("a message", messageId);
-			const read = object(
-				await rest
-					.get(Routes.channelMessage(channelId, messageId))
-					.catch((error: unknown) => {
-						throw failure("reading a message", error);
-					}),
-			);
-			const id = text(read.id);
-			if (!id)
-				throw new DiscordPosterError("rejected", "Discord sent no message");
-			const webhookId = text(read.webhook_id);
-			const files = (
-				Array.isArray(read.attachments) ? read.attachments : []
-			).flatMap((entry) => {
-				const file = object(entry);
-				const name = text(file.filename);
-				const url = text(file.url);
-				return name && url
-					? [
-							{
-								name,
-								url,
-								contentType: text(file.content_type) ?? "",
-								size: typeof file.size === "number" ? file.size : 0,
-							},
-						]
-					: [];
-			});
-			return {
-				id,
-				authorId: text(object(read.author).id) ?? "",
-				...(webhookId ? { webhookId } : {}),
-				content: typeof read.content === "string" ? read.content : "",
-				files,
-			};
-		},
-		async recentMessages(channelId, limit): Promise<RecentMessage[]> {
-			checkSnowflake("a channel", channelId);
-			const listed = await rest
-				.get(Routes.channelMessages(channelId), {
-					query: new URLSearchParams({
-						limit: String(Math.min(50, Math.max(1, Math.trunc(limit)))),
-					}),
-				})
-				.catch((error: unknown) => {
-					throw failure("listing a channel's messages", error);
-				});
-			return (Array.isArray(listed) ? listed : []).flatMap((entry) => {
-				const message = object(entry);
-				const id = text(message.id);
-				if (!id) return [];
-				const referenced = text(object(message.message_reference).message_id);
-				return [
-					{
-						id,
-						type: typeof message.type === "number" ? message.type : 0,
-						authorId: text(object(message.author).id) ?? "",
-						...(referenced ? { referencedMessageId: referenced } : {}),
-					},
-				];
-			});
-		},
+		...readOperations(rest),
 		botUserId: () => core.bot(),
 	};
 }

package/src/core/domain/round.ts

@@ -0,0 +1,31 @@
+/**
+ * Where a group's round stands, for a surface that shows it: who speaks now, who is next and who
+ * has spoken. A round is the members' answers to one owner message, one after another; this is what
+ * the core tells a surface at each step, and a surface that shows no rounds never hears it.
+ */
+export type RoundEnd =
+	/** Every member in the order has spoken. */
+	| "done"
+	/** The round reached the most replies a round holds, with members still waiting. */
+	| "limit"
+	/** The owner pressed Stop: the running turn ended and the members waiting did not speak. */
+	| "stopped";
+
+export interface RoundProgress {
+	/** The group message id of the line that opened the round; one round has one id. */
+	id: number;
+	state: "running" | "ended";
+	/** The member speaking now, by name. */
+	current?: string;
+	/** The members still to speak, in order, a handoff appended. */
+	next: string[];
+	/** The members who have replied so far, in order. */
+	spoken: string[];
+	/** The replies made so far, and the most a round holds. */
+	replies: number;
+	limit: number;
+	/** Why a round that has ended ended. */
+	ended?: RoundEnd;
+	/** The owner's messages waiting in the channel for the next round. */
+	queued?: number;
+}