@helyx/module-reactionroles 1.0.1

package/dist/index.js

@@ -0,0 +1,1618 @@
+import { parseModuleManifest } from "@helyx/module-manifest";
+import { createPrivacyProvider, DashboardActionValidationError, defineModule, getModulePrivacyDeclaration, HELYX_SERVICE_NAMES, } from "@helyx/sdk";
+import { readFileSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+import { PANEL_LIMITS, COMPONENT_IDS, MODULE_ID, PANEL_PURPOSE, } from "./constants.js";
+import { canonicaliseEmoji, panelMessageDraft, validatePanelDraft, } from "./builder.js";
+import { PanelSnapshotCache, ReactionRolePanelService, managedContext, parseManagedDraft, toDetail, } from "./panel-service.js";
+import { reactionRoleRecords } from "./records.js";
+const manifest = parseModuleManifest(JSON.parse(readFileSync(new URL("../manifest.json", import.meta.url), "utf8")));
+const cache = new PanelSnapshotCache();
+const panels = new ReactionRolePanelService(cache);
+const memberLocks = new Map();
+let healthStatus = "healthy";
+let healthMessage = "Reaction Roles is ready";
+const managerPolicy = {
+    everyone: false,
+    requiredPermissions: ["MANAGE_GUILD"],
+    allowedRoleIds: [],
+    deniedRoleIds: [],
+    allowedUserIds: [],
+    deniedUserIds: [],
+};
+const managedPanels = {
+    id: "panels",
+    list: (context, input) => panels.list(context, input),
+    read: (context, resourceId) => panels.read(context, resourceId),
+    preview: (context, value) => panels.preview(context, value),
+    async create(context, value) {
+        const panel = await panels.create(managedContext(context), parseManagedDraft(value));
+        return toDetail(panel);
+    },
+    async update(context, input) {
+        const panel = await panels.update(managedContext(context), {
+            resourceId: input.resourceId,
+            expectedRevision: input.expectedRevision,
+            draft: parseManagedDraft(input.value),
+        });
+        return toDetail(panel);
+    },
+    delete: (context, input) => panels
+        .delete(managedContext(context), input.resourceId, input.expectedRevision)
+        .then((deleted) => ({ deleted })),
+    async executeAction(context, input) {
+        if (input.actionId === "duplicate") {
+            const current = await panels
+                .repository(context.services)
+                .findById(context.guildId, input.resourceId);
+            if (!current)
+                throw new DashboardActionValidationError("Role panel was not found");
+            if (current.revision !== input.expectedRevision)
+                throw new DashboardActionValidationError("This role panel changed in another session. Reload and try again.");
+            return toDetail(await panels.create(managedContext(context), {
+                channelId: current.channelId,
+                title: current.title,
+                messageBody: current.messageBody,
+                messageStyle: current.messageStyle,
+                controlType: current.controlType,
+                selectionMode: current.selectionMode,
+                persistentReactions: current.persistentReactions,
+                ...(current.embedColour === undefined
+                    ? {}
+                    : { embedColour: current.embedColour }),
+                ...(current.dropdownPlaceholder === undefined
+                    ? {}
+                    : { dropdownPlaceholder: current.dropdownPlaceholder }),
+                entries: current.entries.map((entry) => ({
+                    ...entry,
+                    entryId: `entry-${randomUUID().replaceAll("-", "")}`,
+                })),
+            }));
+        }
+        if (input.actionId === "delete") {
+            await panels.delete(managedContext(context), input.resourceId, input.expectedRevision);
+            return null;
+        }
+        if (input.actionId !== "repair" && input.actionId !== "repost")
+            throw new Error("Unknown Reaction Roles resource action");
+        return toDetail(await panels.repair(managedContext(context), input.resourceId, input.expectedRevision, input.actionId === "repost"));
+    },
+};
+export const reactionRolesModule = defineModule({
+    manifest,
+    defaultPermissions: {
+        module: managerPolicy,
+        commands: {
+            "reactionroles.create": managerPolicy,
+            "reactionroles.manage": managerPolicy,
+            "reactionroles.delete": managerPolicy,
+        },
+    },
+    records: reactionRoleRecords,
+    interactions: {
+        commands: [
+            {
+                name: "reaction-role",
+                description: "Create and manage Helyx role panels.",
+                registration: "global",
+                contexts: ["guild"],
+                integrationTypes: ["guild_install"],
+                subcommands: [
+                    {
+                        name: "create",
+                        description: "Open the guided Reaction Roles builder.",
+                        permissionId: "reactionroles.create",
+                        options: [
+                            {
+                                type: "channel",
+                                name: "channel",
+                                description: "Prefill the destination channel.",
+                                channelTypes: ["guild_text", "guild_announcement"],
+                            },
+                            {
+                                type: "string",
+                                name: "style",
+                                description: "Prefill the public message style.",
+                                choices: [
+                                    { name: "Text", value: "text" },
+                                    { name: "Embed", value: "embed" },
+                                ],
+                            },
+                            {
+                                type: "string",
+                                name: "control",
+                                description: "Prefill how members choose roles.",
+                                choices: [
+                                    { name: "Buttons", value: "buttons" },
+                                    { name: "Dropdown", value: "dropdown" },
+                                    { name: "Emoji reactions", value: "reactions" },
+                                ],
+                            },
+                            {
+                                type: "boolean",
+                                name: "one-role-only",
+                                description: "Allow each member to hold only one role from this panel.",
+                            },
+                            {
+                                type: "boolean",
+                                name: "persistent-reactions",
+                                description: "Keep member reactions visible and synchronised with roles.",
+                            },
+                        ],
+                        rateLimit: { scope: "user", limit: 5, windowSeconds: 60 },
+                        execute: startCreate,
+                    },
+                    {
+                        name: "edit",
+                        description: "Edit an existing role panel.",
+                        permissionId: "reactionroles.manage",
+                        options: [
+                            referenceOption(),
+                            {
+                                type: "boolean",
+                                name: "persistent-reactions",
+                                description: "Keep member reactions visible and synchronised with roles.",
+                            },
+                        ],
+                        autocomplete: autocompletePanelReference,
+                        execute: startEdit,
+                    },
+                    {
+                        name: "list",
+                        description: "List the active and degraded role panels.",
+                        permissionId: "reactionroles.manage",
+                        execute: listPanels,
+                    },
+                    {
+                        name: "repair",
+                        description: "Revalidate and repair a role panel.",
+                        permissionId: "reactionroles.manage",
+                        options: [referenceOption()],
+                        autocomplete: autocompletePanelReference,
+                        execute: repairPanel,
+                    },
+                    {
+                        name: "delete",
+                        description: "Delete a role panel without changing member roles.",
+                        permissionId: "reactionroles.delete",
+                        options: [referenceOption()],
+                        autocomplete: autocompletePanelReference,
+                        execute: prepareDelete,
+                    },
+                ],
+            },
+        ],
+        buttons: [
+            {
+                customId: COMPONENT_IDS.continueDraft,
+                execute: continueDraft,
+            },
+            {
+                customId: COMPONENT_IDS.replaceDraft,
+                execute: replaceDraft,
+            },
+            {
+                customId: COMPONENT_IDS.keepDraft,
+                execute: keepDraft,
+            },
+            {
+                customId: COMPONENT_IDS.addEntry,
+                execute: openEntryModal,
+            },
+            {
+                customId: COMPONENT_IDS.publish,
+                acknowledgement: "deferred-ephemeral",
+                execute: publishDraft,
+            },
+            {
+                customId: COMPONENT_IDS.cancel,
+                execute: cancelDraft,
+            },
+            {
+                customId: COMPONENT_IDS.deleteConfirm,
+                acknowledgement: "deferred-ephemeral",
+                execute: confirmDelete,
+            },
+            ...COMPONENT_IDS.slots.map((customId, index) => ({
+                customId,
+                acknowledgement: "deferred-ephemeral",
+                execute: (context) => toggleSlot(context, index),
+            })),
+            {
+                customId: COMPONENT_IDS.removeAll,
+                acknowledgement: "deferred-ephemeral",
+                execute: removeAllPanelRoles,
+            },
+        ],
+        modals: [
+            { customId: COMPONENT_IDS.basicModal, execute: saveBasicDraft },
+            { customId: COMPONENT_IDS.entryModal, execute: saveEntry },
+        ],
+        selects: [
+            {
+                customId: COMPONENT_IDS.builderEntries,
+                execute: openEditEntryModal,
+            },
+            {
+                customId: COMPONENT_IDS.select,
+                acknowledgement: "deferred-ephemeral",
+                execute: reconcileSelection,
+            },
+        ],
+    },
+    events: {
+        messageReactionAdd: [
+            {
+                type: "discord.message-reaction-add",
+                execute: handleReactionAdd,
+            },
+        ],
+        messageReactionRemove: [
+            {
+                type: "discord.message-reaction-remove",
+                execute: handleReactionRemove,
+            },
+        ],
+        messageDelete: [
+            {
+                type: "discord.message-delete",
+                execute: (context) => panels.markMessageMissing({
+                    guildId: context.serverId,
+                    messageId: context.messageId,
+                    services: context.services,
+                }),
+            },
+        ],
+        guildRoleDelete: [
+            {
+                type: "discord.guild-role-delete",
+                execute: (context) => panels
+                    .handleRoleLifecycle({
+                    guildId: context.serverId,
+                    roleId: context.roleId,
+                    deleted: true,
+                    services: context.services,
+                })
+                    .then(() => undefined),
+            },
+        ],
+        guildRoleUpdate: [
+            {
+                type: "discord.guild-role-update",
+                execute: (context) => panels
+                    .handleRoleLifecycle({
+                    guildId: context.serverId,
+                    roleId: context.roleId,
+                    deleted: false,
+                    services: context.services,
+                })
+                    .then(() => undefined),
+            },
+        ],
+        channelDelete: [
+            {
+                type: "discord.channel-delete",
+                execute: (context) => panels
+                    .handleChannelLifecycle({
+                    guildId: context.serverId,
+                    channelId: context.channelId,
+                    deleted: true,
+                    services: context.services,
+                })
+                    .then(() => undefined),
+            },
+        ],
+        channelUpdate: [
+            {
+                type: "discord.channel-update",
+                execute: (context) => panels
+                    .handleChannelLifecycle({
+                    guildId: context.serverId,
+                    channelId: context.channelId,
+                    deleted: false,
+                    services: context.services,
+                })
+                    .then(() => undefined),
+            },
+        ],
+        guildEmojiDelete: [
+            {
+                type: "discord.guild-emoji-delete",
+                execute: (context) => panels
+                    .handleEmojiLifecycle({
+                    guildId: context.serverId,
+                    emojiId: context.emojiId,
+                    deleted: true,
+                    services: context.services,
+                })
+                    .then(() => undefined),
+            },
+        ],
+        guildEmojiUpdate: [
+            {
+                type: "discord.guild-emoji-update",
+                execute: (context) => panels
+                    .handleEmojiLifecycle({
+                    guildId: context.serverId,
+                    emojiId: context.emojiId,
+                    deleted: false,
+                    services: context.services,
+                })
+                    .then(() => undefined),
+            },
+        ],
+    },
+    logging: {
+        events: [
+            {
+                id: "reaction-role-panel-created",
+                name: "Role panel created",
+                description: "A server manager created a Reaction Roles panel.",
+                defaultEnabled: true,
+            },
+            {
+                id: "reaction-role-panel-deleted",
+                name: "Role panel deleted",
+                description: "A server manager deleted a Reaction Roles panel.",
+                defaultEnabled: true,
+            },
+            {
+                id: "reaction-role-panel-updated",
+                name: "Role panel updated",
+                description: "A server manager updated a Reaction Roles panel.",
+                defaultEnabled: true,
+            },
+            {
+                id: "reaction-role-panel-reposted",
+                name: "Role panel reposted",
+                description: "A server manager published a replacement Reaction Roles message.",
+                defaultEnabled: true,
+            },
+            {
+                id: "reaction-role-panel-repaired",
+                name: "Role panel repaired",
+                description: "A server manager repaired a Reaction Roles panel.",
+                defaultEnabled: true,
+            },
+            {
+                id: "reaction-role-member-changed",
+                name: "Member role changed",
+                description: "A member added or removed an approved role through a panel.",
+                defaultEnabled: false,
+            },
+        ],
+    },
+    privacy: {
+        providerVersion: 1,
+        create: (executor) => createPrivacyProvider({
+            id: MODULE_ID,
+            declaration: getModulePrivacyDeclaration(manifest),
+            executor,
+        }),
+    },
+    managedResources: [managedPanels],
+    async start(context) {
+        try {
+            const cleanup = await panels.recoverMessageCleanup(context.services);
+            const count = await panels.warm(context.services);
+            const degraded = cache.saturated() || cleanup.failed > 0 || cleanup.abandoned > 0;
+            healthStatus = degraded ? "degraded" : "healthy";
+            healthMessage = cache.saturated()
+                ? `Reaction Roles loaded the bounded maximum of ${count} active panels`
+                : cleanup.failed > 0 || cleanup.abandoned > 0
+                    ? `Reaction Roles loaded ${count} active panels; ${cleanup.failed + cleanup.abandoned} message cleanups need attention`
+                    : `Reaction Roles loaded ${count} active panels`;
+            context.logger.info({
+                event: "reactionroles.started",
+                activePanelCount: count,
+                cleanupCompleted: cleanup.completed,
+                cleanupFailed: cleanup.failed,
+                cleanupAbandoned: cleanup.abandoned,
+            }, "Reaction Roles started");
+        }
+        catch (error) {
+            healthStatus = "degraded";
+            healthMessage = "Active role panels could not be preloaded";
+            context.logger.warn({
+                event: "reactionroles.cache_load_failed",
+                errorName: error instanceof Error ? error.name : "Error",
+            }, "Reaction Roles started without its active cache");
+        }
+    },
+    stop(context) {
+        cache.clear();
+        memberLocks.clear();
+        context.logger.info({ event: "reactionroles.stopped" }, "Reaction Roles stopped");
+        return Promise.resolve();
+    },
+    health: () => ({ status: healthStatus, message: healthMessage }),
+});
+async function startCreate(context) {
+    const guildId = requireGuild(context);
+    const channel = context.getChannelOption("channel");
+    const style = context.getStringOption("style");
+    const control = context.getStringOption("control");
+    const sessions = sessionService(context.services);
+    const nextState = {
+        mode: "create",
+        selectionMode: context.getBooleanOption("one-role-only") === true
+            ? "one_only"
+            : "multiple",
+        persistentReactions: context.getBooleanOption("persistent-reactions") !== false,
+        ...(channel ? { channelId: channel.id } : {}),
+        ...(style ? { messageStyle: requiredStyle([style]) } : {}),
+        ...(control ? { controlType: requiredControl([control]) } : {}),
+    };
+    const existing = await sessions.getFor(guildId, context.userId, PANEL_PURPOSE);
+    if (existing) {
+        await sessions.update({
+            sessionId: existing.sessionId,
+            state: { ...existing.state, pendingReplacement: nextState },
+            expectedVersion: existing.version,
+            expiresAt: expiresAt(),
+        });
+        await context.reply(existingDraftResponse());
+        return;
+    }
+    await sessions.create({
+        guildId,
+        userId: context.userId,
+        purpose: PANEL_PURPOSE,
+        state: nextState,
+        expiresAt: expiresAt(),
+        replace: true,
+    });
+    await context.showModal(basicModal(defaultsFromSessionState(nextState)));
+}
+async function continueDraft(context) {
+    const guildId = requireGuild(context);
+    const session = await sessionService(context.services).getFor(guildId, context.userId, PANEL_PURPOSE);
+    if (!session)
+        return replyExpired(context);
+    const draft = parseSessionDraft(session.state.draft);
+    if (draft) {
+        await context.reply(builderResponse(draft, context.services));
+        return;
+    }
+    await context.showModal(basicModal(defaultsFromSessionState(session.state)));
+}
+async function replaceDraft(context) {
+    const guildId = requireGuild(context);
+    const sessions = sessionService(context.services);
+    const session = await sessions.getFor(guildId, context.userId, PANEL_PURPOSE);
+    if (!session)
+        return replyExpired(context);
+    const replacement = managedObject(session.state.pendingReplacement)
+        ? session.state.pendingReplacement
+        : {
+            mode: "create",
+            selectionMode: "multiple",
+            persistentReactions: true,
+        };
+    await sessions.create({
+        guildId,
+        userId: context.userId,
+        purpose: PANEL_PURPOSE,
+        state: { ...replacement },
+        expiresAt: expiresAt(),
+        replace: true,
+    });
+    await context.showModal(basicModal(defaultsFromSessionState(replacement)));
+}
+async function keepDraft(context) {
+    const guildId = requireGuild(context);
+    const sessions = sessionService(context.services);
+    const session = await sessions.getFor(guildId, context.userId, PANEL_PURPOSE);
+    if (!session)
+        return replyExpired(context);
+    const state = { ...session.state };
+    delete state.pendingReplacement;
+    await sessions.update({
+        sessionId: session.sessionId,
+        state,
+        expectedVersion: session.version,
+        expiresAt: expiresAt(),
+    });
+    await context.reply({
+        ephemeral: true,
+        componentsV2: {
+            text: [{ content: "Your existing Reaction Roles draft was kept." }],
+        },
+    });
+}
+async function startEdit(context) {
+    const guildId = requireGuild(context);
+    const panel = await findPanelReference(context.services, guildId, context.getStringOption("reference"));
+    const persistentReactions = context.getBooleanOption("persistent-reactions");
+    const draft = persistentReactions === null
+        ? panel
+        : validatePanelDraft({ ...panel, persistentReactions });
+    await sessionService(context.services).create({
+        guildId,
+        userId: context.userId,
+        purpose: PANEL_PURPOSE,
+        state: {
+            mode: "edit",
+            panelId: panel.panelId,
+            expectedRevision: panel.revision,
+            draft: serializeDraft(draft),
+        },
+        expiresAt: expiresAt(),
+        replace: true,
+    });
+    await context.showModal(basicModal(draft, true));
+}
+async function listPanels(context) {
+    const guildId = requireGuild(context);
+    const result = await panels.repository(context.services).list({
+        guildId,
+        limit: 10,
+    });
+    await context.reply({
+        ephemeral: true,
+        componentsV2: {
+            text: [
+                {
+                    content: result.panels.length === 0
+                        ? "No Reaction Roles panels have been created."
+                        : result.panels
+                            .map((panel) => `**${panel.title}** · \`${panel.panelId}\` · ${panel.status} · revision ${panel.revision}`)
+                            .join("\n"),
+                },
+            ],
+        },
+        allowedUserMentionIds: [],
+    });
+}
+async function repairPanel(context) {
+    const guildId = requireGuild(context);
+    await context.deferReply?.(true);
+    const panel = await findPanelReference(context.services, guildId, context.getStringOption("reference"));
+    const repaired = await panels.repair(interactionMutationContext(context, guildId), panel.panelId, panel.revision, false);
+    await context.reply({
+        ephemeral: true,
+        componentsV2: {
+            text: [
+                {
+                    content: `Role panel **${repaired.title}** is active at revision ${repaired.revision}.`,
+                },
+            ],
+        },
+        allowedUserMentionIds: [],
+    });
+}
+async function prepareDelete(context) {
+    const guildId = requireGuild(context);
+    const panel = await findPanelReference(context.services, guildId, context.getStringOption("reference"));
+    await sessionService(context.services).create({
+        guildId,
+        userId: context.userId,
+        purpose: PANEL_PURPOSE,
+        state: {
+            mode: "delete",
+            panelId: panel.panelId,
+            expectedRevision: panel.revision,
+        },
+        expiresAt: expiresAt(),
+        replace: true,
+    });
+    await context.reply({
+        ephemeral: true,
+        componentsV2: {
+            text: [
+                {
+                    content: `Delete **${panel.title}**? Helyx will try to remove its panel message. Existing member roles will not change.`,
+                },
+            ],
+        },
+        buttons: [
+            {
+                type: "button",
+                customId: COMPONENT_IDS.deleteConfirm,
+                label: "Delete role panel",
+                style: "danger",
+            },
+            {
+                type: "button",
+                customId: COMPONENT_IDS.cancel,
+                label: "Keep role panel",
+                style: "secondary",
+            },
+        ],
+        allowedUserMentionIds: [],
+    });
+}
+async function saveBasicDraft(context) {
+    const guildId = requireGuild(context);
+    const sessions = sessionService(context.services);
+    const session = await sessions.getFor(guildId, context.userId, PANEL_PURPOSE);
+    if (!session)
+        return replyExpired(context);
+    const prior = parseSessionDraft(session.state.draft);
+    const controlType = requiredControl(context.getStringSelectValues("control"));
+    const selectionMode = session.state.selectionMode === "one_only"
+        ? "one_only"
+        : (prior?.selectionMode ?? "multiple");
+    const persistentReactions = controlType === "reactions" && selectionMode === "one_only"
+        ? false
+        : (prior?.persistentReactions ??
+            session.state.persistentReactions !== false);
+    const draft = {
+        channelId: context.getSelectedChannelIds("channel")[0] ?? "",
+        title: context.getField("title"),
+        messageBody: context.getField("message"),
+        messageStyle: requiredStyle(context.getStringSelectValues("style")),
+        controlType,
+        selectionMode,
+        persistentReactions,
+        ...(prior?.embedColour === undefined
+            ? { embedColour: 0x7c3aed }
+            : { embedColour: prior.embedColour }),
+        ...(prior?.dropdownPlaceholder
+            ? { dropdownPlaceholder: prior.dropdownPlaceholder }
+            : {}),
+        entries: prior?.entries ?? [],
+    };
+    await sessions.update({
+        sessionId: session.sessionId,
+        state: { ...session.state, draft: serializeDraft(draft) },
+        expectedVersion: session.version,
+        expiresAt: expiresAt(),
+    });
+    await context.reply(builderResponse(draft, context.services));
+}
+async function openEntryModal(context) {
+    const guildId = requireGuild(context);
+    const session = await sessionService(context.services).getFor(guildId, context.userId, PANEL_PURPOSE);
+    if (!session)
+        return replyExpired(context);
+    const draft = parseSessionDraft(session.state.draft);
+    if (!draft)
+        return replyExpired(context);
+    if (draft.entries.length >= PANEL_LIMITS[draft.controlType]) {
+        await context.reply({
+            ephemeral: true,
+            componentsV2: {
+                text: [{ content: "This panel already has the maximum role entries." }],
+            },
+        });
+        return;
+    }
+    await context.showModal(entryModal());
+}
+async function openEditEntryModal(context) {
+    const guildId = requireGuild(context);
+    const sessions = sessionService(context.services);
+    const session = await sessions.getFor(guildId, context.userId, PANEL_PURPOSE);
+    if (!session)
+        return replyExpired(context);
+    const draft = parseSessionDraft(session.state.draft);
+    const entryId = context.selectedValues[0];
+    const entry = draft?.entries.find((candidate) => candidate.entryId === entryId);
+    if (!draft || !entry || context.selectedValues.length !== 1)
+        return replyExpired(context);
+    await sessions.update({
+        sessionId: session.sessionId,
+        state: { ...session.state, editingEntryId: entry.entryId },
+        expectedVersion: session.version,
+        expiresAt: expiresAt(),
+    });
+    await context.showModal(entryModal(entry, true));
+}
+async function saveEntry(context) {
+    const guildId = requireGuild(context);
+    const sessions = sessionService(context.services);
+    const session = await sessions.getFor(guildId, context.userId, PANEL_PURPOSE);
+    if (!session)
+        return replyExpired(context);
+    const draft = parseSessionDraft(session.state.draft);
+    if (!draft)
+        return replyExpired(context);
+    const editingEntryId = typeof session.state.editingEntryId === "string"
+        ? session.state.editingEntryId
+        : null;
+    const editingIndex = editingEntryId
+        ? draft.entries.findIndex(({ entryId }) => entryId === editingEntryId)
+        : -1;
+    if (editingEntryId && editingIndex < 0)
+        return replyExpired(context);
+    const action = editingEntryId
+        ? (context.getStringSelectValues("entry-action")[0] ?? "save")
+        : "save";
+    const entries = [...draft.entries];
+    if (editingEntryId && action === "remove") {
+        entries.splice(editingIndex, 1);
+    }
+    else if (editingEntryId && action === "move-up") {
+        if (editingIndex > 0)
+            [entries[editingIndex - 1], entries[editingIndex]] = [
+                entries[editingIndex],
+                entries[editingIndex - 1],
+            ];
+    }
+    else if (editingEntryId && action === "move-down") {
+        if (editingIndex < entries.length - 1)
+            [entries[editingIndex], entries[editingIndex + 1]] = [
+                entries[editingIndex + 1],
+                entries[editingIndex],
+            ];
+    }
+    else {
+        const roleId = context.getSelectedRoleIds("role")[0] ?? "";
+        const buttonStyle = context.getStringSelectValues("button-style")[0];
+        const entry = {
+            entryId: editingEntryId ?? `entry-${randomUUID().replaceAll("-", "")}`,
+            roleId,
+            nameplate: context.getField("nameplate"),
+            ...(context.getField("emoji").trim()
+                ? { emoji: context.getField("emoji") }
+                : {}),
+            ...(buttonStyle
+                ? {
+                    buttonStyle: buttonStyle,
+                }
+                : {}),
+        };
+        if (editingEntryId)
+            entries[editingIndex] = entry;
+        else
+            entries.push(entry);
+    }
+    const next = entries.length === 0
+        ? { ...draft, entries }
+        : validatePanelDraft({
+            ...draft,
+            entries,
+        });
+    const state = {
+        ...session.state,
+        draft: serializeDraft(next),
+    };
+    delete state.editingEntryId;
+    await sessions.update({
+        sessionId: session.sessionId,
+        state,
+        expectedVersion: session.version,
+        expiresAt: expiresAt(),
+    });
+    await context.reply(builderResponse(next, context.services));
+}
+async function publishDraft(context) {
+    const guildId = requireGuild(context);
+    const sessions = sessionService(context.services);
+    const session = await sessions.getFor(guildId, context.userId, PANEL_PURPOSE);
+    if (!session)
+        return replyExpired(context);
+    const draft = parseSessionDraft(session.state.draft);
+    if (!draft)
+        return replyExpired(context);
+    const mutation = interactionMutationContext(context, guildId);
+    const panel = session.state.mode === "edit" &&
+        typeof session.state.panelId === "string" &&
+        typeof session.state.expectedRevision === "number"
+        ? await panels.update(mutation, {
+            resourceId: session.state.panelId,
+            expectedRevision: session.state.expectedRevision,
+            draft,
+        })
+        : await panels.create(mutation, draft);
+    await sessions.delete(session.sessionId);
+    await context.reply({
+        ephemeral: true,
+        componentsV2: {
+            text: [
+                {
+                    content: `Reaction Roles panel **${panel.title}** is active in <#${panel.channelId}>.`,
+                },
+            ],
+        },
+        allowedUserMentionIds: [],
+    });
+}
+async function cancelDraft(context) {
+    const guildId = requireGuild(context);
+    const sessions = sessionService(context.services);
+    const session = await sessions.getFor(guildId, context.userId, PANEL_PURPOSE);
+    if (session)
+        await sessions.delete(session.sessionId);
+    await context.reply({
+        ephemeral: true,
+        componentsV2: { text: [{ content: "Nothing was changed." }] },
+    });
+}
+async function confirmDelete(context) {
+    const guildId = requireGuild(context);
+    const sessions = sessionService(context.services);
+    const session = await sessions.getFor(guildId, context.userId, PANEL_PURPOSE);
+    if (!session ||
+        session.state.mode !== "delete" ||
+        typeof session.state.panelId !== "string" ||
+        typeof session.state.expectedRevision !== "number")
+        return replyExpired(context);
+    await panels.delete(interactionMutationContext(context, guildId), session.state.panelId, session.state.expectedRevision);
+    await sessions.delete(session.sessionId);
+    await context.reply({
+        ephemeral: true,
+        componentsV2: {
+            text: [
+                {
+                    content: "The role panel was deleted. Existing member roles were not changed.",
+                },
+            ],
+        },
+    });
+}
+async function toggleSlot(context, index) {
+    const { guildId, panel } = await activePanelForInteraction(context);
+    const entry = panel.entries[index];
+    if (!entry)
+        return stalePanelReply(context);
+    await consumeMemberLimit(context.services, guildId, context.userId);
+    let changed = "removed";
+    try {
+        await withMemberLock(guildId, panel.panelId, context.userId, async () => {
+            const roles = context.services.get(HELYX_SERVICE_NAMES.memberRoles);
+            const current = new Set(await roles.getCurrentRoleIds({
+                guildId,
+                memberUserId: context.userId,
+            }));
+            const changes = [];
+            if (panel.selectionMode === "one_only") {
+                const desired = current.has(entry.roleId) ? [] : [entry.roleId];
+                const result = await roles.reconcileApprovedRoles({
+                    guildId,
+                    memberUserId: context.userId,
+                    allowedRoleIds: panel.entries.map(({ roleId }) => roleId),
+                    desiredRoleIds: desired,
+                    moduleId: MODULE_ID,
+                    reason: `Reaction Roles panel ${panel.panelId}`,
+                });
+                changes.push(...result.added.map((roleId) => ({
+                    roleId,
+                    outcome: "added",
+                })), ...result.removed.map((roleId) => ({
+                    roleId,
+                    outcome: "removed",
+                })));
+                changed = result.added.includes(entry.roleId) ? "added" : "removed";
+            }
+            else if (current.has(entry.roleId)) {
+                await roles.removeApprovedRole({
+                    guildId,
+                    memberUserId: context.userId,
+                    roleId: entry.roleId,
+                    moduleId: MODULE_ID,
+                    reason: `Reaction Roles panel ${panel.panelId}`,
+                });
+                changed = "removed";
+                changes.push({ roleId: entry.roleId, outcome: changed });
+            }
+            else {
+                await roles.addApprovedRole({
+                    guildId,
+                    memberUserId: context.userId,
+                    roleId: entry.roleId,
+                    moduleId: MODULE_ID,
+                    reason: `Reaction Roles panel ${panel.panelId}`,
+                });
+                changed = "added";
+                changes.push({ roleId: entry.roleId, outcome: changed });
+            }
+            await emitMemberChanges(context.services, guildId, context.userId, panel.panelId, changes);
+        });
+    }
+    catch {
+        await roleFailure(context, panel);
+        return;
+    }
+    await context.reply(memberOutcome(entry.nameplate, changed));
+}
+async function reconcileSelection(context) {
+    const { guildId, panel } = await activePanelForInteraction(context);
+    if (panel.controlType !== "dropdown")
+        return stalePanelReply(context);
+    await consumeMemberLimit(context.services, guildId, context.userId);
+    const selected = new Set(context.selectedValues);
+    const desired = panel.entries
+        .filter(({ entryId }) => selected.has(entryId))
+        .map(({ roleId }) => roleId);
+    if (selected.size !== desired.length ||
+        (panel.selectionMode === "one_only" && desired.length > 1))
+        return stalePanelReply(context);
+    let added = 0;
+    let removed = 0;
+    try {
+        await withMemberLock(guildId, panel.panelId, context.userId, async () => {
+            const result = await context.services
+                .get(HELYX_SERVICE_NAMES.memberRoles)
+                .reconcileApprovedRoles({
+                guildId,
+                memberUserId: context.userId,
+                allowedRoleIds: panel.entries.map(({ roleId }) => roleId),
+                desiredRoleIds: desired,
+                moduleId: MODULE_ID,
+                reason: `Reaction Roles panel ${panel.panelId}`,
+            });
+            added = result.added.length;
+            removed = result.removed.length;
+            await emitMemberChanges(context.services, guildId, context.userId, panel.panelId, [
+                ...result.added.map((roleId) => ({
+                    roleId,
+                    outcome: "added",
+                })),
+                ...result.removed.map((roleId) => ({
+                    roleId,
+                    outcome: "removed",
+                })),
+            ]);
+        });
+    }
+    catch {
+        await roleFailure(context, panel);
+        return;
+    }
+    await context.reply({
+        ephemeral: true,
+        componentsV2: {
+            text: [
+                {
+                    content: `Your panel roles were updated: ${added} added, ${removed} removed.`,
+                },
+            ],
+        },
+    });
+}
+async function removeAllPanelRoles(context) {
+    const { guildId, panel } = await activePanelForInteraction(context);
+    await consumeMemberLimit(context.services, guildId, context.userId);
+    let removed = [];
+    try {
+        await withMemberLock(guildId, panel.panelId, context.userId, async () => {
+            const result = await context.services
+                .get(HELYX_SERVICE_NAMES.memberRoles)
+                .reconcileApprovedRoles({
+                guildId,
+                memberUserId: context.userId,
+                allowedRoleIds: panel.entries.map(({ roleId }) => roleId),
+                desiredRoleIds: [],
+                moduleId: MODULE_ID,
+                reason: `Reaction Roles panel ${panel.panelId}`,
+            });
+            removed = result.removed;
+            await emitMemberChanges(context.services, guildId, context.userId, panel.panelId, result.removed.map((roleId) => ({
+                roleId,
+                outcome: "removed",
+            })));
+        });
+    }
+    catch {
+        await roleFailure(context, panel);
+        return;
+    }
+    await context.reply({
+        ephemeral: true,
+        componentsV2: {
+            text: [
+                {
+                    content: removed.length === 0
+                        ? "You did not have any roles from this panel."
+                        : `${removed.length} panel ${removed.length === 1 ? "role was" : "roles were"} removed.`,
+                },
+            ],
+        },
+    });
+}
+async function handleReactionAdd(context) {
+    if (context.reactionType !== "normal")
+        return;
+    const panel = await panels.resolveActive(context.serverId, context.messageId, context.services);
+    if (!panel || panel.controlType !== "reactions")
+        return;
+    const entry = panel.entries.find((candidate) => candidate.emoji &&
+        canonicalEmojiKey(candidate.emoji) === context.emojiKey);
+    if (!entry)
+        return;
+    const changes = [];
+    try {
+        await withMemberLock(context.serverId, panel.panelId, context.userId, async () => {
+            const roles = context.services.get(HELYX_SERVICE_NAMES.memberRoles);
+            if (panel.selectionMode === "one_only") {
+                const result = await roles.reconcileApprovedRoles({
+                    guildId: context.serverId,
+                    memberUserId: context.userId,
+                    allowedRoleIds: panel.entries.map(({ roleId }) => roleId),
+                    desiredRoleIds: [entry.roleId],
+                    moduleId: MODULE_ID,
+                    reason: `Reaction Roles panel ${panel.panelId}`,
+                });
+                changes.push(...result.added.map((roleId) => ({
+                    roleId,
+                    outcome: "added",
+                })), ...result.removed.map((roleId) => ({
+                    roleId,
+                    outcome: "removed",
+                })));
+                return;
+            }
+            const result = await roles.addApprovedRole({
+                guildId: context.serverId,
+                memberUserId: context.userId,
+                roleId: entry.roleId,
+                moduleId: MODULE_ID,
+                reason: `Reaction Roles panel ${panel.panelId}`,
+            });
+            if (result.changed)
+                changes.push({ roleId: entry.roleId, outcome: "added" });
+        });
+        await emitMemberChanges(context.services, context.serverId, context.userId, panel.panelId, changes);
+    }
+    catch {
+        await panels.markNeedsAttention(panel, context.services).catch(() => false);
+        await context.removeAddedReaction().catch(() => undefined);
+        return;
+    }
+    if (!panel.persistentReactions) {
+        try {
+            await context.removeAddedReaction();
+        }
+        catch {
+            await panels
+                .markNeedsAttention(panel, context.services)
+                .catch(() => false);
+        }
+    }
+}
+async function handleReactionRemove(context) {
+    if (context.reactionType !== "normal")
+        return;
+    const panel = await panels.resolveActive(context.serverId, context.messageId, context.services);
+    if (!panel || panel.controlType !== "reactions" || !panel.persistentReactions)
+        return;
+    const entry = panel.entries.find((candidate) => candidate.emoji &&
+        canonicalEmojiKey(candidate.emoji) === context.emojiKey);
+    if (!entry)
+        return;
+    try {
+        await withMemberLock(context.serverId, panel.panelId, context.userId, () => context.services
+            .get(HELYX_SERVICE_NAMES.memberRoles)
+            .removeApprovedRole({
+            guildId: context.serverId,
+            memberUserId: context.userId,
+            roleId: entry.roleId,
+            moduleId: MODULE_ID,
+            reason: `Reaction Roles panel ${panel.panelId}`,
+        })
+            .then(() => undefined));
+        await emitMemberChanges(context.services, context.serverId, context.userId, panel.panelId, [{ roleId: entry.roleId, outcome: "removed" }]);
+    }
+    catch {
+        await panels.markNeedsAttention(panel, context.services).catch(() => false);
+    }
+}
+async function activePanelForInteraction(context) {
+    const guildId = context.serverId;
+    if (!guildId || !context.messageId)
+        throw new Error("Server panel required");
+    const panel = await panels.resolveActive(guildId, context.messageId, context.services);
+    if (!panel)
+        throw new Error("Role panel is no longer active");
+    return { guildId, panel };
+}
+async function consumeMemberLimit(services, guildId, userId) {
+    const result = await services
+        .get(HELYX_SERVICE_NAMES.rateLimits)
+        .consume({
+        scope: "user",
+        subjectId: userId,
+        action: `${MODULE_ID}:${guildId}:member-role`,
+        limit: 10,
+        windowSeconds: 10,
+    });
+    if (!result.allowed)
+        throw new Error("Role panel rate limit reached");
+}
+async function withMemberLock(guildId, panelId, userId, operation) {
+    const key = `${guildId}:${panelId}:${userId}`;
+    const previous = memberLocks.get(key) ?? Promise.resolve();
+    const current = previous.catch(() => undefined).then(operation);
+    memberLocks.set(key, current);
+    try {
+        await current;
+    }
+    finally {
+        if (memberLocks.get(key) === current)
+            memberLocks.delete(key);
+    }
+}
+function basicModal(panel, editing = false) {
+    return {
+        customId: COMPONENT_IDS.basicModal,
+        title: editing ? "Edit role panel" : "Create role panel",
+        fields: [
+            {
+                type: "discord-channel",
+                customId: "channel",
+                label: "Destination channel",
+                required: true,
+                channelTypes: ["guild_text", "guild_announcement"],
+                ...(panel?.channelId ? { defaultValues: [panel.channelId] } : {}),
+            },
+            {
+                customId: "title",
+                label: "Title",
+                style: "short",
+                required: true,
+                minLength: 1,
+                maxLength: 80,
+                ...(panel?.title ? { value: panel.title } : {}),
+            },
+            {
+                customId: "message",
+                label: "Message",
+                style: "paragraph",
+                required: true,
+                minLength: 1,
+                maxLength: 1_000,
+                ...(panel?.messageBody ? { value: panel.messageBody } : {}),
+            },
+            {
+                type: "string-select",
+                customId: "style",
+                label: "Message style",
+                required: true,
+                options: [
+                    {
+                        label: "Text",
+                        value: "text",
+                        default: panel?.messageStyle !== "embed",
+                    },
+                    {
+                        label: "Embed",
+                        value: "embed",
+                        default: panel?.messageStyle === "embed",
+                    },
+                ],
+            },
+            {
+                type: "string-select",
+                customId: "control",
+                label: "Role controls",
+                required: true,
+                options: [
+                    {
+                        label: "Buttons",
+                        value: "buttons",
+                        default: !panel?.controlType || panel.controlType === "buttons",
+                    },
+                    {
+                        label: "Dropdown",
+                        value: "dropdown",
+                        default: panel?.controlType === "dropdown",
+                    },
+                    {
+                        label: "Emoji reactions",
+                        value: "reactions",
+                        default: panel?.controlType === "reactions",
+                    },
+                ],
+            },
+        ],
+    };
+}
+function existingDraftResponse() {
+    return {
+        ephemeral: true,
+        componentsV2: {
+            text: [
+                {
+                    content: "You already have a Reaction Roles draft. Continue it or replace it with a new draft.",
+                },
+            ],
+        },
+        buttons: [
+            {
+                type: "button",
+                customId: COMPONENT_IDS.continueDraft,
+                label: "Continue draft",
+                style: "primary",
+            },
+            {
+                type: "button",
+                customId: COMPONENT_IDS.replaceDraft,
+                label: "Replace draft",
+                style: "danger",
+            },
+            {
+                type: "button",
+                customId: COMPONENT_IDS.keepDraft,
+                label: "Cancel",
+                style: "secondary",
+            },
+        ],
+        allowedUserMentionIds: [],
+    };
+}
+function defaultsFromSessionState(state) {
+    return {
+        ...(typeof state.channelId === "string"
+            ? { channelId: state.channelId }
+            : {}),
+        ...(state.messageStyle === "text" || state.messageStyle === "embed"
+            ? { messageStyle: state.messageStyle }
+            : {}),
+        ...(state.controlType === "buttons" ||
+            state.controlType === "dropdown" ||
+            state.controlType === "reactions"
+            ? { controlType: state.controlType }
+            : {}),
+    };
+}
+function managedObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function entryModal(entry, editing = false) {
+    return {
+        customId: COMPONENT_IDS.entryModal,
+        title: editing ? "Edit role entry" : "Add a role entry",
+        fields: [
+            {
+                type: "discord-role",
+                customId: "role",
+                label: "Discord role",
+                required: true,
+                ...(entry ? { defaultValues: [entry.roleId] } : {}),
+            },
+            {
+                customId: "nameplate",
+                label: "Public label",
+                style: "short",
+                required: true,
+                minLength: 1,
+                maxLength: 80,
+                ...(entry ? { value: entry.nameplate } : {}),
+            },
+            {
+                customId: "emoji",
+                label: "Emoji",
+                description: "Optional for buttons and dropdowns; required for reactions.",
+                style: "short",
+                required: false,
+                minLength: 1,
+                maxLength: 100,
+                ...(entry?.emoji ? { value: entry.emoji } : {}),
+                placeholder: "✅ or <:updates:123456789012345678>",
+            },
+            {
+                type: "string-select",
+                customId: "button-style",
+                label: "Button colour",
+                required: false,
+                options: [
+                    { label: "Grey", value: "secondary", default: true },
+                    { label: "Blue", value: "primary" },
+                    { label: "Green", value: "success" },
+                    { label: "Red", value: "danger" },
+                ],
+            },
+            ...(editing
+                ? [
+                    {
+                        type: "string-select",
+                        customId: "entry-action",
+                        label: "Entry action",
+                        required: true,
+                        options: [
+                            { label: "Save changes", value: "save", default: true },
+                            { label: "Move up", value: "move-up" },
+                            { label: "Move down", value: "move-down" },
+                            { label: "Remove entry", value: "remove" },
+                        ],
+                    },
+                ]
+                : []),
+        ],
+    };
+}
+function builderResponse(draft, services) {
+    const builder = services.get(HELYX_SERVICE_NAMES.messageBuilder);
+    const panel = draft.entries.length > 0
+        ? builder.build(panelMessageDraft(draft)).response
+        : builder.build({
+            presentation: draft.messageStyle === "embed"
+                ? {
+                    type: "embed",
+                    title: draft.title,
+                    body: draft.messageBody,
+                    ...(draft.embedColour === undefined
+                        ? {}
+                        : { color: draft.embedColour }),
+                }
+                : {
+                    type: "text",
+                    title: draft.title,
+                    body: draft.messageBody,
+                    accentColor: 0x7c3aed,
+                },
+            allowedUserMentionIds: [],
+        }).response;
+    return {
+        ...panel,
+        ephemeral: true,
+        selects: draft.entries.length === 0
+            ? []
+            : [
+                {
+                    type: "string",
+                    customId: COMPONENT_IDS.builderEntries,
+                    placeholder: "Edit, reorder or remove a role",
+                    minValues: 1,
+                    maxValues: 1,
+                    options: draft.entries.map((entry) => ({
+                        label: entry.nameplate,
+                        value: entry.entryId,
+                        ...(entry.emoji
+                            ? {
+                                emojiIdentifier: canonicaliseEmoji(entry.emoji)
+                                    .identifier,
+                            }
+                            : {}),
+                    })),
+                },
+            ],
+        buttons: [
+            {
+                type: "button",
+                customId: COMPONENT_IDS.addEntry,
+                label: "Add role",
+                style: "secondary",
+                disabled: draft.entries.length >= PANEL_LIMITS[draft.controlType],
+            },
+            {
+                type: "button",
+                customId: COMPONENT_IDS.publish,
+                label: "Publish panel",
+                style: "success",
+                disabled: draft.entries.length === 0,
+            },
+            {
+                type: "button",
+                customId: COMPONENT_IDS.cancel,
+                label: "Cancel",
+                style: "secondary",
+            },
+        ],
+        allowedUserMentionIds: [],
+    };
+}
+function interactionMutationContext(context, guildId) {
+    return {
+        guildId,
+        actorUserId: context.userId,
+        source: "discord",
+        services: context.services,
+        correlationId: context.interactionId,
+        sendToChannel: (channelId, response) => context.sendToChannel(channelId, response),
+        deleteChannelMessage: (channelId, messageId) => context.deleteChannelMessage(channelId, messageId),
+        editChannelMessage: (channelId, messageId, response) => context.editChannelMessage(channelId, messageId, response),
+        addChannelMessageReaction: (channelId, messageId, emojiIdentifier) => context.addChannelMessageReaction(channelId, messageId, emojiIdentifier),
+    };
+}
+async function findPanelReference(services, guildId, value) {
+    const reference = value?.trim();
+    if (!reference)
+        throw new Error("Role panel reference is required");
+    const panel = await panels.repository(services).findById(guildId, reference);
+    if (!panel)
+        throw new Error("Role panel was not found");
+    return panel;
+}
+async function autocompletePanelReference(context) {
+    if (!context.serverId || context.focusedOptionName !== "reference") {
+        await context.respond([]);
+        return;
+    }
+    const query = context.focusedValue.trim().normalize("NFKC").toLowerCase();
+    const repository = panels.repository(context.services);
+    const choices = [];
+    let cursor;
+    for (let pageNumber = 0; pageNumber < 5 && choices.length < 25; pageNumber += 1) {
+        const page = await repository.listReferences({
+            guildId: context.serverId,
+            ...(cursor ? { cursor } : {}),
+            limit: query ? 100 : 25,
+        });
+        for (const panel of page.panels) {
+            if (panel.status === "deleting")
+                continue;
+            const searchable = `${panel.title} ${panel.panelId} ${panel.status}`.toLowerCase();
+            if (query && !searchable.includes(query))
+                continue;
+            const title = panel.title.replaceAll(/\s+/gu, " ").trim();
+            const suffix = `${panel.status} · ${panel.panelId.slice(0, 8)}`;
+            choices.push({
+                name: `${title.slice(0, Math.max(1, 97 - suffix.length))} · ${suffix}`,
+                value: panel.panelId,
+            });
+            if (choices.length === 25)
+                break;
+        }
+        if (!query || !page.nextCursor)
+            break;
+        cursor = page.nextCursor;
+    }
+    await context.respond(choices);
+}
+function referenceOption() {
+    return {
+        type: "string",
+        name: "reference",
+        description: "Panel reference shown by /reaction-role list.",
+        required: true,
+        minLength: 1,
+        maxLength: 100,
+        autocomplete: true,
+    };
+}
+function sessionService(services) {
+    return services.get(HELYX_SERVICE_NAMES.sessions);
+}
+function requireGuild(context) {
+    if (!context.serverId)
+        throw new Error("Use this command in a Discord server");
+    return context.serverId;
+}
+function expiresAt() {
+    return new Date(Date.now() + 20 * 60 * 1_000);
+}
+function serializeDraft(draft) {
+    return {
+        channelId: draft.channelId,
+        title: draft.title,
+        messageBody: draft.messageBody,
+        messageStyle: draft.messageStyle,
+        controlType: draft.controlType,
+        selectionMode: draft.selectionMode,
+        persistentReactions: draft.persistentReactions,
+        ...(draft.embedColour === undefined
+            ? {}
+            : { embedColour: draft.embedColour }),
+        ...(draft.dropdownPlaceholder === undefined
+            ? {}
+            : { dropdownPlaceholder: draft.dropdownPlaceholder }),
+        entries: draft.entries.map((entry) => ({ ...entry })),
+    };
+}
+function parseSessionDraft(value) {
+    if (!isObject(value) || !Array.isArray(value.entries))
+        return null;
+    try {
+        return validatePanelDraft({
+            channelId: stringValue(value.channelId),
+            title: stringValue(value.title),
+            messageBody: stringValue(value.messageBody),
+            messageStyle: stringValue(value.messageStyle),
+            controlType: stringValue(value.controlType),
+            selectionMode: stringValue(value.selectionMode),
+            persistentReactions: typeof value.persistentReactions === "boolean"
+                ? value.persistentReactions
+                : true,
+            ...(typeof value.embedColour === "number"
+                ? { embedColour: value.embedColour }
+                : {}),
+            ...(typeof value.dropdownPlaceholder === "string"
+                ? { dropdownPlaceholder: value.dropdownPlaceholder }
+                : {}),
+            entries: value.entries.map((entry) => {
+                if (!isObject(entry))
+                    throw new Error("invalid entry");
+                return {
+                    entryId: stringValue(entry.entryId),
+                    roleId: stringValue(entry.roleId),
+                    nameplate: stringValue(entry.nameplate),
+                    ...(typeof entry.emoji === "string" ? { emoji: entry.emoji } : {}),
+                    ...(typeof entry.buttonStyle === "string"
+                        ? { buttonStyle: entry.buttonStyle }
+                        : {}),
+                };
+            }),
+        }, { allowEmptyEntries: true });
+    }
+    catch {
+        return null;
+    }
+}
+async function replyExpired(context) {
+    await context.reply({
+        ephemeral: true,
+        componentsV2: {
+            text: [
+                {
+                    content: "This role-panel builder expired. Run `/reaction-role create` or `/reaction-role edit` again.",
+                },
+            ],
+        },
+    });
+}
+async function stalePanelReply(context) {
+    await context.reply({
+        ephemeral: true,
+        componentsV2: {
+            text: [
+                {
+                    content: "This role panel changed or is no longer active. Ask a server manager to repair it.",
+                },
+            ],
+        },
+    });
+}
+function memberOutcome(nameplate, changed) {
+    return {
+        ephemeral: true,
+        componentsV2: {
+            text: [
+                {
+                    content: `${nameplate} was ${changed === "added" ? "added to" : "removed from"} your roles.`,
+                },
+            ],
+        },
+        allowedUserMentionIds: [],
+    };
+}
+async function roleFailure(context, panel) {
+    await panels.markNeedsAttention(panel, context.services).catch(() => false);
+    await context.reply({
+        ephemeral: true,
+        componentsV2: {
+            text: [
+                {
+                    content: "Helyx cannot manage that role right now. A server administrator needs to check the Reaction Roles panel.",
+                },
+            ],
+        },
+        allowedUserMentionIds: [],
+    });
+}
+async function emitMemberChanges(services, guildId, memberUserId, panelId, changes) {
+    if (changes.length === 0 || !services.has(HELYX_SERVICE_NAMES.moduleLogging))
+        return;
+    const logging = services.get(HELYX_SERVICE_NAMES.moduleLogging);
+    await Promise.all(changes.slice(0, 25).map(({ roleId, outcome }) => logging
+        .emit({
+        guildId,
+        moduleId: MODULE_ID,
+        eventId: "reaction-role-member-changed",
+        summary: "A member changed an approved Reaction Roles role.",
+        details: [
+            { label: "Member ID", value: memberUserId },
+            { label: "Panel", value: panelId },
+            { label: "Role ID", value: roleId },
+            { label: "Outcome", value: outcome },
+        ],
+    })
+        .catch(() => ({ delivered: false }))));
+}
+function requiredStyle(values) {
+    const value = values[0];
+    if (value !== "text" && value !== "embed")
+        throw new Error("Choose Text or Embed");
+    return value;
+}
+function requiredControl(values) {
+    const value = values[0];
+    if (value !== "buttons" && value !== "dropdown" && value !== "reactions")
+        throw new Error("Choose valid role controls");
+    return value;
+}
+function canonicalEmojiKey(value) {
+    const custom = /^([A-Za-z0-9_]{2,32}):(\d{17,20})$/u.exec(value);
+    return custom ? `custom:${custom[2]}` : `unicode:${value.normalize("NFKC")}`;
+}
+function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringValue(value) {
+    if (typeof value !== "string")
+        throw new Error("invalid string");
+    return value;
+}
+export default reactionRolesModule;