@helyx/module-reactionroles 1.0.14 → 1.0.17

package/dist/index.js

@@ -1,83 +1,17 @@
 import { parseModuleManifest } from "@helyx/module-manifest";
-import { createPrivacyProvider, DashboardActionValidationError, defineModule, getModulePrivacyDeclaration, HELYX_SERVICE_NAMES, } from "@helyx/sdk";
+import { defineModule } 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 { COMPONENT_IDS, REACTION_ROLE_CLEANUP_TASK } from "./constants.js";
 import { reactionRoleRecords } from "./records.js";
+import { cancelDraft, confirmDelete, continueDraft, keepDraft, openEditEntryModal, openEntryModal, publishDraft, replaceDraft, saveBasicDraft, saveEntry, } from "./builder-interactions.js";
+import { handleReactionAdd, handleReactionRemove, reconcileSelection, removeAllPanelRoles, toggleSlot, } from "./member-interactions.js";
+import { managedPanels } from "./managed-resource.js";
+import { reactionRoleLogging } from "./logging.js";
+import { startReactionRoles, stopReactionRoles } from "./module-lifecycle.js";
+import { createReactionRolePrivacy } from "./privacy.js";
+import { reactionRoleManagerPolicy as managerPolicy } from "./permissions.js";
+import { reactionRoleHealth as moduleHealth, reactionRolePanels as panels, runReactionRoleFailureOnly as runFailureOnly, runReactionRolePrimary as runPrimary, } from "./runtime-state.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: {
@@ -110,7 +44,7 @@ export const reactionRolesModule = defineModule({
             {
                 customId: COMPONENT_IDS.publish,
                 acknowledgement: "deferred-ephemeral",
-                execute: publishDraft,
+                execute: (context) => runPrimary(() => publishDraft(context)),
             },
             {
                 customId: COMPONENT_IDS.cancel,
@@ -119,7 +53,7 @@ export const reactionRolesModule = defineModule({
             {
                 customId: COMPONENT_IDS.deleteConfirm,
                 acknowledgement: "deferred-ephemeral",
-                execute: confirmDelete,
+                execute: (context) => runPrimary(() => confirmDelete(context)),
             },
             ...COMPONENT_IDS.slots.map((customId, index) => ({
                 customId,
@@ -152,1147 +86,132 @@ export const reactionRolesModule = defineModule({
         messageReactionAdd: [
             {
                 type: "discord.message-reaction-add",
-                execute: handleReactionAdd,
+                execute: (context) => runFailureOnly(() => handleReactionAdd(context), "member"),
             },
         ],
         messageReactionRemove: [
             {
                 type: "discord.message-reaction-remove",
-                execute: handleReactionRemove,
+                execute: (context) => runFailureOnly(() => handleReactionRemove(context), "member"),
             },
         ],
         messageDelete: [
             {
                 type: "discord.message-delete",
-                execute: (context) => panels.markMessageMissing({
+                execute: (context) => runPrimary(() => panels.markMessageMissing({
                     guildId: context.serverId,
                     messageId: context.messageId,
                     services: context.services,
-                }),
+                }), "lifecycle"),
             },
         ],
         guildRoleDelete: [
             {
                 type: "discord.guild-role-delete",
-                execute: (context) => panels
-                    .handleRoleLifecycle({
+                execute: (context) => runPrimary(() => panels.handleRoleLifecycle({
                     guildId: context.serverId,
                     roleId: context.roleId,
                     deleted: true,
                     services: context.services,
-                })
-                    .then(() => undefined),
+                }), "lifecycle").then(() => undefined),
             },
         ],
         guildRoleUpdate: [
             {
                 type: "discord.guild-role-update",
-                execute: (context) => panels
-                    .handleRoleLifecycle({
+                execute: (context) => runPrimary(() => panels.handleRoleLifecycle({
                     guildId: context.serverId,
                     roleId: context.roleId,
                     deleted: false,
                     services: context.services,
-                })
-                    .then(() => undefined),
+                }), "lifecycle").then(() => undefined),
             },
         ],
         channelDelete: [
             {
                 type: "discord.channel-delete",
-                execute: (context) => panels
-                    .handleChannelLifecycle({
+                execute: (context) => runPrimary(() => panels.handleChannelLifecycle({
                     guildId: context.serverId,
                     channelId: context.channelId,
                     deleted: true,
                     services: context.services,
-                })
-                    .then(() => undefined),
+                }), "lifecycle").then(() => undefined),
             },
         ],
         channelUpdate: [
             {
                 type: "discord.channel-update",
-                execute: (context) => panels
-                    .handleChannelLifecycle({
+                execute: (context) => runPrimary(() => panels.handleChannelLifecycle({
                     guildId: context.serverId,
                     channelId: context.channelId,
                     deleted: false,
                     services: context.services,
-                })
-                    .then(() => undefined),
+                }), "lifecycle").then(() => undefined),
             },
         ],
         guildEmojiDelete: [
             {
                 type: "discord.guild-emoji-delete",
-                execute: (context) => panels
-                    .handleEmojiLifecycle({
+                execute: (context) => runPrimary(() => panels.handleEmojiLifecycle({
                     guildId: context.serverId,
                     emojiId: context.emojiId,
                     deleted: true,
                     services: context.services,
-                })
-                    .then(() => undefined),
+                }), "lifecycle").then(() => undefined),
             },
         ],
         guildEmojiUpdate: [
             {
                 type: "discord.guild-emoji-update",
-                execute: (context) => panels
-                    .handleEmojiLifecycle({
+                execute: (context) => runPrimary(() => 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,
+                }), "lifecycle").then(() => undefined),
             },
         ],
     },
-    privacy: {
-        providerVersion: 1,
-        create: (executor) => createPrivacyProvider({
-            id: MODULE_ID,
-            declaration: getModulePrivacyDeclaration(manifest),
-            executor,
-        }),
-    },
+    logging: reactionRoleLogging,
+    privacy: createReactionRolePrivacy(manifest),
     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 could not clean up ${cleanup.failed + cleanup.abandoned} old panel message${cleanup.failed + cleanup.abandoned === 1 ? "" : "s"}.`
-                    : `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 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 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 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 }),
+    scheduledTasks: [
+        {
+            kind: REACTION_ROLE_CLEANUP_TASK,
+            version: 1,
+            delivery: "one-shot",
+            attemptLimit: 10,
+            validatePayload: validateCleanupPayload,
+            async execute(context, task) {
+                const payload = validateCleanupPayload(task.payload);
+                const execution = await panels.executeMessageCleanupWithRecovery(context.services, payload.cleanupId);
+                const { result } = execution;
+                if (result.outcome === "completed") {
+                    if (execution.recovered)
+                        moduleHealth.cleanupRecovered();
+                    moduleHealth.primarySuccess("lifecycle");
                 }
-                : {
-                    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",
+                else
+                    moduleHealth.primaryFailure("lifecycle");
+                return result;
             },
-        ],
-        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),
-    };
-}
-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;
-}
+    ],
+    start: startReactionRoles,
+    stop: stopReactionRoles,
+    health: () => moduleHealth.health(),
+});
 export default reactionRolesModule;
+function validateCleanupPayload(input) {
+    if (!input || typeof input !== "object" || Array.isArray(input))
+        invalid();
+    const value = input;
+    if (Object.keys(value).length !== 1 ||
+        typeof value.cleanupId !== "string" ||
+        !/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu.test(value.cleanupId))
+        invalid();
+    return { cleanupId: value.cleanupId };
+}
+function invalid() {
+    throw new Error("Reaction Roles cleanup payload is invalid.");
+}