@helyx/module-account-gate 1.0.14 → 1.1.1

package/dist/setup-presentation.js

@@ -0,0 +1,378 @@
+import { DashboardActionValidationError, HELYX_SERVICE_NAMES, validateServerQuestion, ACCOUNT_GATE_COMPONENTS, ACCOUNT_GATE_IDENTITY, isStrictModeActive, parseAccountGateConfiguration, validateRuntimeCapabilities, accountGateRecords, hasPasswordGatePanel, VIOLET, GREEN, } from "./runtime-dependencies.js";
+import { boundComponentId, dateValue, stringValue } from "./runtime-support.js";
+export function configurationForPanel(configuration, accessType) {
+    if (accessType === "challenges")
+        return configuration;
+    const challengeType = accessType === "password" ? "password_entry" : "emoji_entry";
+    return {
+        ...configuration,
+        accessType,
+        preset: "custom",
+        allocationMode: "fixed_chain",
+        enabledChallengeTypes: [challengeType],
+        fixedChallengeChain: [challengeType],
+        challengeCount: 1,
+    };
+}
+export function reviewMessage(memberUserId, reasonCode) {
+    return {
+        allowedUserMentionIds: [memberUserId],
+        componentsV2: {
+            accentColor: VIOLET,
+            text: [
+                { content: "## Access Control review" },
+                { content: `Member: <@${memberUserId}> (${memberUserId})` },
+                { content: `Reason: ${reasonCode}`, markdown: false },
+                {
+                    content: "Challenge answers and Password Entry content are not included.",
+                    markdown: false,
+                },
+            ],
+        },
+        buttons: [
+            {
+                type: "button",
+                customId: ACCOUNT_GATE_COMPONENTS.review.approve,
+                label: "Approve",
+                style: "primary",
+            },
+            {
+                type: "button",
+                customId: ACCOUNT_GATE_COMPONENTS.review.retry,
+                label: "Retry",
+                style: "secondary",
+            },
+            {
+                type: "button",
+                customId: ACCOUNT_GATE_COMPONENTS.review.kick,
+                label: "Kick",
+                style: "danger",
+            },
+            {
+                type: "button",
+                customId: ACCOUNT_GATE_COMPONENTS.review.dismiss,
+                label: "Dismiss",
+                style: "secondary",
+            },
+        ],
+    };
+}
+export async function validateAccountGateSetup(services, guildId, configuration, throwOnError = true, allowMissingPanel = false) {
+    const resources = services.get(HELYX_SERVICE_NAMES.discordResources);
+    const records = services.get(HELYX_SERVICE_NAMES.records);
+    const verificationEnabled = await services
+        .get(HELYX_SERVICE_NAMES.installations)
+        .isModuleEnabled(guildId, "helyx.verification");
+    const [gateChannel, gateAudience, guildCapabilities, verifiedRole, capabilities,] = await Promise.all([
+        resources.inspectChannel({
+            guildId,
+            channelId: configuration.gateChannelId,
+        }),
+        resources.inspectChannelAudience({
+            guildId,
+            channelId: configuration.gateChannelId,
+            roleIds: configuration.temporaryRoleIds,
+        }),
+        resources.inspectGuildCapabilities({ guildId }),
+        resources.inspectRole({
+            guildId,
+            roleId: configuration.verifiedRoleId,
+        }),
+        resources.inspectRuntimeCapabilities(),
+    ]);
+    const errors = [...validateRuntimeCapabilities(configuration, capabilities)];
+    const panel = await records.findOne({
+        moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
+        collection: "gate_panels",
+        select: accountGateRecords.gate_panels.readableFields,
+        where: { guild_id: guildId },
+    });
+    if (!panel) {
+        if (!allowMissingPanel)
+            errors.push("The managed Access Control panel has not been posted. Post or repair it before processing joins.");
+    }
+    else {
+        const panelMessage = await resources.inspectMessage({
+            guildId,
+            channelId: stringValue(panel.channel_id),
+            messageId: stringValue(panel.message_id),
+        });
+        if (!panelMessage.exists ||
+            !panelMessage.guildMatches ||
+            !panelMessage.channelMatches)
+            errors.push("The managed Access Control panel message is missing. Repost it before processing joins.");
+    }
+    if (verificationEnabled)
+        errors.push("Helyx Verification already owns this server's entry-role workflow. Disable it before enabling Access Control.");
+    if (!gateChannel.viewable || !gateChannel.sendMessages)
+        errors.push("Helyx cannot view and send messages in the gate channel.");
+    if (!gateAudience.everyoneCanView &&
+        (gateAudience.roles.length === 0 ||
+            gateAudience.roles.some(({ exists, canView }) => !exists || !canView)))
+        errors.push("The gate channel must be visible to @everyone or every configured temporary member role.");
+    if (!guildCapabilities.manageRoles)
+        errors.push("Access Control requires Manage Roles.");
+    if (!verifiedRole.assignable)
+        errors.push("The access role is missing or is above Helyx.");
+    for (const roleId of configuration.temporaryRoleIds) {
+        const role = await resources.inspectRole({ guildId, roleId });
+        if (!role.exists || !role.assignable)
+            errors.push(`Temporary role ${roleId} is missing or is above Helyx.`);
+    }
+    if (configuration.reviewChannelId) {
+        const [reviewChannel, reviewAudience] = await Promise.all([
+            resources.inspectChannel({
+                guildId,
+                channelId: configuration.reviewChannelId,
+            }),
+            resources.inspectChannelAudience({
+                guildId,
+                channelId: configuration.reviewChannelId,
+                roleIds: configuration.temporaryRoleIds,
+            }),
+        ]);
+        if (!reviewChannel.viewable || !reviewChannel.sendMessages)
+            errors.push("Helyx cannot use the configured staff review channel.");
+        if (reviewAudience.everyoneCanView ||
+            reviewAudience.roles.some(({ canView }) => canView))
+            errors.push("The staff review channel must not be visible to @everyone or temporary pre-gate roles.");
+    }
+    if (configuration.failureAction === "kick" && !guildCapabilities.kickMembers)
+        errors.push("The kick outcome requires Kick Members.");
+    if (configuration.enabledChallengeTypes.includes("password_entry")) {
+        const [passwordChannel, passwordAudience] = await Promise.all([
+            resources.inspectChannel({
+                guildId,
+                channelId: configuration.passwordChannelId,
+            }),
+            resources.inspectChannelAudience({
+                guildId,
+                channelId: configuration.passwordChannelId,
+                roleIds: configuration.temporaryRoleIds,
+            }),
+        ]);
+        if (!passwordChannel.viewable ||
+            !passwordChannel.readMessageHistory ||
+            !passwordChannel.manageMessages)
+            errors.push("Password Entry requires View Channel, Read Message History and Manage Messages.");
+        if (passwordAudience.everyoneCanView)
+            errors.push("Password Entry must not be visible to @everyone.");
+        if (configuration.temporaryRoleIds.length === 0 ||
+            !configuration.temporaryRoleIds.every((roleId) => passwordAudience.roles.some((role) => role.roleId === roleId && role.exists && role.canView)))
+            errors.push("Password Entry requires every configured temporary pre-gate role to view its isolated channel.");
+        const store = services.get(HELYX_SERVICE_NAMES.records);
+        if (!(await hasPasswordGatePanel(store, guildId)))
+            errors.push("Password Entry needs a published panel with a password.");
+    }
+    if (configuration.enabledChallengeTypes.includes("server_question") &&
+        (await loadQuestions(services, guildId)).length === 0)
+        errors.push("Server Question requires at least one enabled question.");
+    if (configuration.enabledChallengeTypes.includes("emoji_entry")) {
+        const [message, emoji, channel] = await Promise.all([
+            resources.inspectMessage({
+                guildId,
+                channelId: configuration.emojiChannelId,
+                messageId: configuration.emojiMessageId,
+            }),
+            resources.inspectEmoji({
+                guildId,
+                emojiIdentifier: configuration.emojiIdentifier,
+            }),
+            resources.inspectChannel({
+                guildId,
+                channelId: configuration.emojiChannelId,
+            }),
+        ]);
+        if (!message.exists || !message.guildMatches || !message.channelMatches)
+            errors.push("The Emoji Entry message is unavailable.");
+        if (!emoji.exists || !emoji.usable)
+            errors.push("The Emoji Entry emoji is unavailable.");
+        if (!channel.viewable ||
+            !channel.readMessageHistory ||
+            !channel.addReactions)
+            errors.push("Emoji Entry requires View Channel, Read Message History and Add Reactions.");
+        if (errors.length === 0 && throwOnError)
+            await resources.seedMessageReaction({
+                guildId,
+                channelId: configuration.emojiChannelId,
+                messageId: configuration.emojiMessageId,
+                emojiIdentifier: configuration.emojiIdentifier,
+            });
+    }
+    if (throwOnError && errors.length > 0)
+        throw new DashboardActionValidationError(errors[0]);
+    return errors;
+}
+export function challengeMessage(state, binding, options = {}) {
+    const challenge = state.chain[state.currentStep];
+    if (!challenge) {
+        return {
+            ephemeral: true,
+            componentsV2: {
+                accentColor: GREEN,
+                text: [
+                    { content: "## Check complete" },
+                    {
+                        content: "Your Access Control check is complete.",
+                        markdown: false,
+                    },
+                ],
+            },
+        };
+    }
+    const base = {
+        ephemeral: true,
+        componentsV2: {
+            accentColor: VIOLET,
+            text: [
+                { content: "## Complete Access Control" },
+                {
+                    content: options.redactRecallCode && challenge.type === "modal_recall"
+                        ? "Remember this code: **-****"
+                        : challenge.prompt,
+                    markdown: false,
+                },
+                {
+                    content: `Challenge ${state.currentStep + 1} of ${state.chain.length}`,
+                    markdown: false,
+                },
+            ],
+        },
+    };
+    switch (challenge.type) {
+        case "quick_sum":
+        case "number_order":
+        case "symbol_match":
+        case "server_question":
+            return {
+                ...base,
+                buttons: [
+                    ...challenge.options.map((label, index) => ({
+                        type: "button",
+                        customId: boundComponentId(ACCOUNT_GATE_COMPONENTS.answerPrefix, {
+                            ...binding,
+                            step: state.step,
+                            value: String(index),
+                        }),
+                        label,
+                        style: "secondary",
+                        ...(challenge.type === "number_order" &&
+                            challenge.expectedSequence
+                                .slice(0, challenge.progress)
+                                .includes(index)
+                            ? { disabled: true }
+                            : {}),
+                    })),
+                    {
+                        type: "button",
+                        customId: boundComponentId(ACCOUNT_GATE_COMPONENTS.rerollPrefix, {
+                            ...binding,
+                            step: state.step,
+                        }),
+                        label: "Different challenge",
+                        style: "secondary",
+                    },
+                ],
+            };
+        case "button_sequence":
+            return {
+                ...base,
+                buttons: [
+                    {
+                        type: "button",
+                        customId: boundComponentId(ACCOUNT_GATE_COMPONENTS.sequencePrefix, {
+                            ...binding,
+                            step: state.step,
+                            value: "red",
+                        }),
+                        label: "Red",
+                        style: "secondary",
+                    },
+                    {
+                        type: "button",
+                        customId: boundComponentId(ACCOUNT_GATE_COMPONENTS.sequencePrefix, {
+                            ...binding,
+                            step: state.step,
+                            value: "blue",
+                        }),
+                        label: "Blue",
+                        style: "secondary",
+                    },
+                    {
+                        type: "button",
+                        customId: boundComponentId(ACCOUNT_GATE_COMPONENTS.sequencePrefix, {
+                            ...binding,
+                            step: state.step,
+                            value: "green",
+                        }),
+                        label: "Green",
+                        style: "secondary",
+                    },
+                ],
+            };
+        case "modal_recall":
+            return {
+                ...base,
+                buttons: [
+                    {
+                        type: "button",
+                        customId: boundComponentId(ACCOUNT_GATE_COMPONENTS.recallOpenPrefix, { ...binding, step: state.step }),
+                        label: "Enter code",
+                        style: "primary",
+                    },
+                ],
+            };
+        case "password_entry":
+        case "emoji_entry":
+            return base;
+    }
+}
+export async function loadQuestions(services, guildId) {
+    const rows = await services
+        .get(HELYX_SERVICE_NAMES.records)
+        .findMany({
+        moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
+        collection: "questions",
+        select: accountGateRecords.questions.readableFields,
+        where: { guild_id: guildId, enabled: true },
+        orderBy: [
+            { field: "guild_id", direction: "asc" },
+            { field: "sort_order", direction: "asc" },
+            { field: "question_id", direction: "asc" },
+        ],
+        limit: 100,
+    });
+    return rows.records.map((row) => validateServerQuestion({
+        id: row.question_id,
+        question: row.question_text,
+        answers: JSON.parse(stringValue(row.answers_json)),
+        correctOption: row.correct_option_index,
+    }));
+}
+export async function currentStrictMode(services, guildId) {
+    const row = await services
+        .get(HELYX_SERVICE_NAMES.records)
+        .findOne({
+        moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
+        collection: "strict_modes",
+        select: accountGateRecords.strict_modes.readableFields,
+        where: { guild_id: guildId, status: "active" },
+    });
+    return !!row && isStrictModeActive(dateValue(row.ends_at));
+}
+export async function getConfiguration(services, guildId) {
+    const record = await services
+        .get(HELYX_SERVICE_NAMES.configuration)
+        .get(guildId, ACCOUNT_GATE_IDENTITY.moduleId);
+    return record ? parseAccountGateConfiguration(record.value) : null;
+}
+export async function requiredRuntimeConfiguration(services, guildId) {
+    const configuration = await getConfiguration(services, guildId);
+    if (!configuration)
+        throw new DashboardActionValidationError("Save the Access Control settings first.");
+    const errors = await validateAccountGateSetup(services, guildId, configuration, false);
+    if (errors.length > 0)
+        throw new DashboardActionValidationError(errors[0]);
+    return configuration;
+}
+//# sourceMappingURL=setup-presentation.js.map

package/dist/strict-mode.d.ts

@@ -0,0 +1,17 @@
+import type { CommandInteractionContext, RuntimeContext, ScheduledTaskPayload, ServiceAccess } from "./runtime-dependencies.js";
+export declare function showStatus(context: CommandInteractionContext): Promise<void>;
+export declare function activateStrictModeCommand(context: CommandInteractionContext): Promise<void>;
+export declare function activateStrictMode(services: ServiceAccess, guildId: string, actorUserId: string, durationMinutes: number, correlationId: string): Promise<Date>;
+export declare function validateStrictTaskPayload(input: unknown): ScheduledTaskPayload;
+export declare function expireStrictMode(context: RuntimeContext, task: {
+    payload: ScheduledTaskPayload;
+}): Promise<{
+    outcome: "completed";
+    delayMs?: never;
+    safeCode?: never;
+} | {
+    outcome: "deferred";
+    delayMs: number;
+    safeCode: string;
+}>;
+//# sourceMappingURL=strict-mode.d.ts.map

package/dist/strict-mode.js

@@ -0,0 +1,154 @@
+import { HELYX_SERVICE_NAMES, ACCOUNT_GATE_IDENTITY, accountGateRecords, emitLog, VIOLET, GREEN, RED, STRICT_EXPIRY_TASK, } from "./runtime-dependencies.js";
+import { dateValue, numberValue, replyError } from "./runtime-support.js";
+import { currentStrictMode, requiredRuntimeConfiguration, validateAccountGateSetup, } from "./setup-presentation.js";
+export async function showStatus(context) {
+    if (!context.serverId)
+        return replyError(context, "This command is server-only.");
+    const configuration = await requiredRuntimeConfiguration(context.services, context.serverId);
+    const errors = await validateAccountGateSetup(context.services, context.serverId, configuration, false);
+    const strict = await currentStrictMode(context.services, context.serverId);
+    await context.reply({
+        ephemeral: true,
+        embed: {
+            title: "Access Control status",
+            description: `${errors.length === 0 ? "Configuration checks passed." : errors.join("\n")}\nTemporary strict mode: ${strict ? "Active" : "Off"}.`,
+            color: errors.length === 0 ? GREEN : RED,
+        },
+    });
+}
+export async function activateStrictModeCommand(context) {
+    if (!context.serverId)
+        return replyError(context, "This command is server-only.");
+    const configuration = await requiredRuntimeConfiguration(context.services, context.serverId);
+    const endsAt = await activateStrictMode(context.services, context.serverId, context.userId, configuration.strictModeDurationMinutes, context.interactionId);
+    await context.reply({
+        ephemeral: true,
+        embed: {
+            title: "Temporary strict mode active",
+            description: `One generated challenge has been added until <t:${Math.floor(endsAt.getTime() / 1_000)}:F>.`,
+            color: VIOLET,
+        },
+    });
+}
+export async function activateStrictMode(services, guildId, actorUserId, durationMinutes, correlationId) {
+    const records = services.get(HELYX_SERVICE_NAMES.records);
+    let generation = 0;
+    let endsAt = new Date();
+    for (let retry = 0; retry < 4; retry += 1) {
+        const current = await records.findOne({
+            moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
+            collection: "strict_modes",
+            select: accountGateRecords.strict_modes.readableFields,
+            where: { guild_id: guildId },
+        });
+        const now = new Date();
+        endsAt = new Date(now.getTime() + durationMinutes * 60_000);
+        generation = current ? numberValue(current.generation) + 1 : 1;
+        const schedule = {
+            taskKind: STRICT_EXPIRY_TASK,
+            guildId,
+            idempotencyKey: `${guildId}:strict:${generation}`,
+            payload: { guildId },
+            scheduledFor: endsAt,
+        };
+        const stored = current
+            ? await records.updateOne({
+                moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
+                collection: "strict_modes",
+                where: { guild_id: guildId },
+                expected: {
+                    field: "revision",
+                    value: numberValue(current.revision),
+                },
+                values: {
+                    status: "active",
+                    ends_at: endsAt,
+                    generation,
+                    activated_by_user_id: actorUserId,
+                    revision: numberValue(current.revision) + 1,
+                    updated_at: now,
+                },
+                schedule,
+            })
+            : await records.appendUnique({
+                moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
+                collection: "strict_modes",
+                uniqueBy: ["guild_id"],
+                values: {
+                    guild_id: guildId,
+                    status: "active",
+                    ends_at: endsAt,
+                    generation,
+                    activated_by_user_id: actorUserId,
+                    revision: 1,
+                    created_at: now,
+                    updated_at: now,
+                },
+                schedule,
+            });
+        if ("updated" in stored ? stored.updated : stored.created)
+            break;
+        if (retry === 3)
+            throw new Error("Access Control strict mode changed concurrently");
+    }
+    await emitLog(services, guildId, {
+        eventId: "account-gate-strict-mode-changed",
+        summary: "Temporary Access Control strict mode was activated.",
+        details: [
+            { label: "Duration minutes", value: String(durationMinutes) },
+            { label: "Generation", value: String(generation) },
+        ],
+        idempotencyKey: correlationId,
+    });
+    return endsAt;
+}
+export function validateStrictTaskPayload(input) {
+    if (!input || typeof input !== "object" || Array.isArray(input))
+        throw new Error("Account Gate strict task payload is invalid");
+    const value = input;
+    if (typeof value.guildId !== "string" || !/^\d{17,20}$/u.test(value.guildId))
+        throw new Error("Account Gate strict task payload is invalid");
+    return { guildId: value.guildId };
+}
+export async function expireStrictMode(context, task) {
+    const records = context.services.get(HELYX_SERVICE_NAMES.records);
+    const row = await records.findOne({
+        moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
+        collection: "strict_modes",
+        select: accountGateRecords.strict_modes.readableFields,
+        where: { guild_id: task.payload.guildId },
+    });
+    if (!row || row.status !== "active")
+        return { outcome: "completed" };
+    const endsAt = dateValue(row.ends_at);
+    if (!endsAt)
+        return { outcome: "completed" };
+    if (endsAt.getTime() > Date.now())
+        return {
+            outcome: "deferred",
+            delayMs: Math.max(100, endsAt.getTime() - Date.now()),
+            safeCode: "strict-expiry-not-due",
+        };
+    const generation = numberValue(row.generation);
+    const result = await records.updateOne({
+        moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
+        collection: "strict_modes",
+        where: { guild_id: task.payload.guildId },
+        expected: { field: "generation", value: generation },
+        dateAtOrBeforeNow: { field: "ends_at" },
+        values: {
+            status: "expired",
+            revision: numberValue(row.revision) + 1,
+            updated_at: new Date(),
+        },
+    });
+    if (result.updated) {
+        await emitLog(context.services, task.payload.guildId, {
+            eventId: "account-gate-strict-mode-changed",
+            summary: "Temporary Access Control strict mode expired.",
+            details: [{ label: "Generation", value: String(generation) }],
+        });
+    }
+    return { outcome: "completed" };
+}
+//# sourceMappingURL=strict-mode.js.map

package/dist/task-contributions.d.ts

@@ -0,0 +1,4 @@
+import type { ModuleScheduledTaskContribution } from "@helyx/sdk";
+import type { AccountGateHealth } from "./health.js";
+export declare function createAccountGateTasks(health: AccountGateHealth): readonly ModuleScheduledTaskContribution[];
+//# sourceMappingURL=task-contributions.d.ts.map

package/dist/task-contributions.js

@@ -0,0 +1,113 @@
+import { enforceJoinDeadline, expireSession, runLeaveRetention, validateJoinDeadlinePayload, validateLeaveRetentionPayload, validateSessionExpiryPayload, } from "./expiry-workflows.js";
+import { executePanelMessageCleanup, PANEL_MESSAGE_CLEANUP_TASK, validatePanelCleanupPayload, } from "./panel-maintenance.js";
+import { reconcileRevocationTask, validateRevocationPayload, } from "./member-revocation.js";
+import { deliverReview, recoverReviewClaim, validateReviewClaimRecoveryPayload, validateReviewDeliveryPayload, } from "./review-delivery.js";
+import { retryRoleTransition, validateRoleRetryPayload, } from "./role-recovery.js";
+import { JOIN_DEADLINE_TASK, LEAVE_RETENTION_TASK, REVIEW_CLAIM_RECOVERY_TASK, REVIEW_DELIVERY_TASK, ROLE_RETRY_TASK, REVOCATION_RECONCILE_TASK, SESSION_EXPIRY_TASK, STRICT_EXPIRY_TASK, TERMINAL_FINALIZATION_TASK, } from "./runtime-dependencies.js";
+import { expireStrictMode, validateStrictTaskPayload } from "./strict-mode.js";
+import { runTerminalFinalizationTask, validateTerminalFinalizationPayload, } from "./terminal-finalization.js";
+export function createAccountGateTasks(health) {
+    return [
+        trackedTask(health, {
+            kind: STRICT_EXPIRY_TASK,
+            version: 1,
+            delivery: "one-shot",
+            attemptLimit: 5,
+            validatePayload: validateStrictTaskPayload,
+            execute: expireStrictMode,
+        }),
+        trackedTask(health, {
+            kind: ROLE_RETRY_TASK,
+            version: 1,
+            delivery: "one-shot",
+            attemptLimit: 5,
+            validatePayload: validateRoleRetryPayload,
+            execute: retryRoleTransition,
+        }),
+        trackedTask(health, {
+            kind: JOIN_DEADLINE_TASK,
+            version: 1,
+            delivery: "one-shot",
+            attemptLimit: 5,
+            validatePayload: validateJoinDeadlinePayload,
+            execute: enforceJoinDeadline,
+        }),
+        trackedTask(health, {
+            kind: SESSION_EXPIRY_TASK,
+            version: 1,
+            delivery: "one-shot",
+            attemptLimit: 5,
+            validatePayload: validateSessionExpiryPayload,
+            execute: expireSession,
+        }),
+        trackedTask(health, {
+            kind: REVIEW_DELIVERY_TASK,
+            version: 1,
+            delivery: "one-shot",
+            attemptLimit: 8,
+            validatePayload: validateReviewDeliveryPayload,
+            execute: deliverReview,
+        }),
+        trackedTask(health, {
+            kind: REVIEW_CLAIM_RECOVERY_TASK,
+            version: 1,
+            delivery: "one-shot",
+            attemptLimit: 5,
+            validatePayload: validateReviewClaimRecoveryPayload,
+            execute: recoverReviewClaim,
+        }),
+        trackedTask(health, {
+            kind: TERMINAL_FINALIZATION_TASK,
+            version: 1,
+            delivery: "one-shot",
+            attemptLimit: 10,
+            validatePayload: validateTerminalFinalizationPayload,
+            execute: runTerminalFinalizationTask,
+        }),
+        trackedTask(health, {
+            kind: REVOCATION_RECONCILE_TASK,
+            version: 1,
+            delivery: "one-shot",
+            attemptLimit: 10,
+            validatePayload: validateRevocationPayload,
+            execute: reconcileRevocationTask,
+        }),
+        trackedTask(health, {
+            kind: LEAVE_RETENTION_TASK,
+            version: 1,
+            delivery: "one-shot",
+            attemptLimit: 5,
+            validatePayload: validateLeaveRetentionPayload,
+            execute: runLeaveRetention,
+        }),
+        trackedTask(health, {
+            kind: PANEL_MESSAGE_CLEANUP_TASK,
+            version: 1,
+            delivery: "one-shot",
+            attemptLimit: 10,
+            validatePayload: validatePanelCleanupPayload,
+            execute: executePanelMessageCleanup,
+        }),
+    ];
+}
+function trackedTask(health, contribution) {
+    return {
+        ...contribution,
+        execute: (context, task) => executeTrackedTask(health, contribution, context, task),
+    };
+}
+async function executeTrackedTask(health, contribution, context, task) {
+    try {
+        const result = await contribution.execute(context, task);
+        if (result.outcome === "completed")
+            health.recordTaskSuccess(task.taskKind);
+        else
+            health.recordTaskFailure(task.taskKind, result.safeCode);
+        return result;
+    }
+    catch (error) {
+        health.recordTaskFailure(task.taskKind, "account_gate.task_failed");
+        throw error;
+    }
+}
+//# sourceMappingURL=task-contributions.js.map

package/dist/task-scheduling.d.ts

@@ -0,0 +1,12 @@
+import type { ModuleRecordService, ServiceAccess } from "./runtime-dependencies.js";
+export declare function scheduleJoinDeadline(services: ServiceAccess, guildId: string, memberUserId: string, generation: number, deadlineAt: Date): Promise<void>;
+export declare function scheduleSessionExpiry(services: ServiceAccess, input: {
+    guildId: string;
+    userId: string;
+    sessionId: string;
+    expiredAt: Date;
+}): Promise<void>;
+export declare function scheduleReviewDelivery(services: ServiceAccess, guildId: string, reviewId: string, scheduledFor: Date): Promise<void>;
+export declare function scheduleTerminalFinalization(services: ServiceAccess, guildId: string, finalizationId: string, scheduledFor: Date): Promise<void>;
+export declare function armRecordRetention(records: ModuleRecordService, guildId: string, collection: "attempts" | "reviews" | "terminal_finalizations", idField: "attempt_id" | "review_id" | "finalization_id", id: string, scheduledFor: Date): Promise<void>;
+//# sourceMappingURL=task-scheduling.d.ts.map