@helyx/module-account-gate 1.0.15 → 1.1.3

package/dist/index.js

@@ -1,33 +1,28 @@
-import { randomUUID } from "node:crypto";
 import { readFileSync } from "node:fs";
 import { parseModuleManifest } from "@helyx/module-manifest";
-import { createPrivacyProvider, DashboardActionValidationError, defineModule, getModulePrivacyDeclaration, HELYX_SERVICE_NAMES, ModuleStateValidationError, } from "@helyx/sdk";
+import { createPrivacyProvider, defineModule, getModulePrivacyDeclaration, HELYX_SERVICE_NAMES, ModuleStateValidationError, } from "@helyx/sdk";
 import { generateChallengeChain, validateServerQuestion, } from "./challenges.js";
-import { ACCOUNT_GATE_COMPONENTS, ACCOUNT_GATE_IDENTITY, ACCOUNT_GATE_SESSION_PURPOSE, } from "./contracts.js";
-import { generatedChallengePool, isStrictModeActive, parseAccountGateConfiguration, validateRuntimeCapabilities, } from "./configuration.js";
-import { applyRoleTransition, neutralKickDirectMessage, } from "./enforcement.js";
-import { verifyPasswordEntry } from "./password-entry.js";
+import { openRecallModal, processBoundOption, processBoundSequence, rerollChallenge, submitRecallModal, } from "./challenge-interactions.js";
+import { handleEmojiEntry, handlePasswordEntry, } from "./gateway-interactions.js";
+import { accountGateCommands } from "./commands.js";
+import { parseAccountGateConfiguration, validateRuntimeCapabilities, } from "./configuration.js";
+import { ACCOUNT_GATE_COMPONENTS, ACCOUNT_GATE_IDENTITY } from "./contracts.js";
+import { AccountGateHealth } from "./health.js";
+import { accountGateLogging } from "./logging.js";
 import { accountGateMemberResource } from "./member-resource.js";
-import { accountGateRecords } from "./records.js";
+import { handleGuildMemberAdd, handleGuildMemberRemove, resetOwnAccess, } from "./member-lifecycle.js";
+import { startCheck } from "./member-start.js";
+import { gatePanelResource } from "./panel-resource.js";
 import { serverQuestionResource } from "./question-resource.js";
-import { gatePanelResource, getGatePanelRuntime, hasPasswordGatePanel, } from "./panel-resource.js";
-import { isAccountGateWorkSuppressed } from "./privacy.js";
-import { applyChallengeAction, createAccountGateSessionState, parseAccountGateSessionState, rerollForAccessibility, } from "./workflow.js";
-import { accountGateCommands } from "./commands.js";
-import { accountGateLogging, emitAccountGateCompletedLog, emitAccountGateKickLog, emitLog, successfulKickOutcome, } from "./logging.js";
+import { accountGateRecords } from "./records.js";
+import { handleReviewDecision } from "./review-decisions.js";
+import { getConfiguration, requiredRuntimeConfiguration, validateAccountGateSetup, } from "./setup-presentation.js";
+import { activateStrictMode, activateStrictModeCommand, showStatus, } from "./strict-mode.js";
+import { createAccountGateTasks } from "./task-contributions.js";
+import { ensureTerminalFinalization } from "./terminal-finalization.js";
+import { applyChallengeAction, createAccountGateSessionState, } from "./workflow.js";
 const manifest = parseModuleManifest(JSON.parse(readFileSync(new URL("../manifest.json", import.meta.url), "utf8")));
-const VIOLET = 0x7c3aed;
-const GREEN = 0x16a34a;
-const RED = 0xdc2626;
-const STRICT_EXPIRY_TASK = "account-gate.strict-expiry";
-const ROLE_RETRY_TASK = "account-gate.role-transition-retry";
-const JOIN_DEADLINE_TASK = "account-gate.join-deadline";
-const SESSION_EXPIRY_TASK = "account-gate.session-expiry";
-const REVIEW_DELIVERY_TASK = "account-gate.review-delivery";
-const REVIEW_CLAIM_RECOVERY_TASK = "account-gate.review-claim-recovery";
-const TERMINAL_FINALIZATION_TASK = "account-gate.terminal-finalization";
-const LEAVE_RETENTION_TASK = "account-gate.leave-retention";
-const RETENTION_MS = 90 * 24 * 60 * 60 * 1_000;
+const health = new AccountGateHealth();
 const managerPolicy = {
     everyone: false,
     requiredPermissions: ["MANAGE_ROLES"],
@@ -55,14 +50,14 @@ export const accountGateModule = defineModule({
         if (errors.length > 0)
             throw new ModuleStateValidationError(errors[0]);
     },
-    configuration: {
-        schemaVersion: 1,
-        validate: parseAccountGateConfiguration,
-    },
+    configuration: { schemaVersion: 1, validate: parseAccountGateConfiguration },
     defaultPermissions: {
         module: everyonePolicy,
         commands: {
+            "account-gate.start": everyonePolicy,
             "account-gate.reset": managerPolicy,
+            "account-gate.status": managerPolicy,
+            "account-gate.strict": managerPolicy,
             "account-gate.manage": managerPolicy,
             "account-gate.review": managerPolicy,
         },
@@ -159,22 +154,13 @@ export const accountGateModule = defineModule({
             },
         ],
         messageReactionAdd: [
-            {
-                type: "discord.message-reaction-add",
-                execute: handleEmojiEntry,
-            },
+            { type: "discord.message-reaction-add", execute: handleEmojiEntry },
         ],
         guildMemberAdd: [
-            {
-                type: "discord.guild-member-add",
-                execute: handleGuildMemberAdd,
-            },
+            { type: "discord.guild-member-add", execute: handleGuildMemberAdd },
         ],
         guildMemberRemove: [
-            {
-                type: "discord.guild-member-remove",
-                execute: handleGuildMemberRemove,
-            },
+            { type: "discord.guild-member-remove", execute: handleGuildMemberRemove },
         ],
     },
     dashboardActions: [
@@ -190,3132 +176,24 @@ export const accountGateModule = defineModule({
             },
         },
     ],
-    scheduledTasks: [
-        {
-            kind: STRICT_EXPIRY_TASK,
-            version: 1,
-            delivery: "one-shot",
-            attemptLimit: 5,
-            validatePayload: validateStrictTaskPayload,
-            execute: expireStrictMode,
-        },
-        {
-            kind: ROLE_RETRY_TASK,
-            version: 1,
-            delivery: "one-shot",
-            attemptLimit: 5,
-            validatePayload: validateRoleRetryPayload,
-            execute: retryRoleTransition,
-        },
-        {
-            kind: JOIN_DEADLINE_TASK,
-            version: 1,
-            delivery: "one-shot",
-            attemptLimit: 5,
-            validatePayload: validateJoinDeadlinePayload,
-            execute: enforceJoinDeadline,
-        },
-        {
-            kind: SESSION_EXPIRY_TASK,
-            version: 1,
-            delivery: "one-shot",
-            attemptLimit: 5,
-            validatePayload: validateSessionExpiryPayload,
-            execute: expireSession,
-        },
-        {
-            kind: REVIEW_DELIVERY_TASK,
-            version: 1,
-            delivery: "one-shot",
-            attemptLimit: 8,
-            validatePayload: validateReviewDeliveryPayload,
-            execute: deliverReview,
-        },
-        {
-            kind: REVIEW_CLAIM_RECOVERY_TASK,
-            version: 1,
-            delivery: "one-shot",
-            attemptLimit: 5,
-            validatePayload: validateReviewClaimRecoveryPayload,
-            execute: recoverReviewClaim,
-        },
-        {
-            kind: TERMINAL_FINALIZATION_TASK,
-            version: 1,
-            delivery: "one-shot",
-            attemptLimit: 10,
-            validatePayload: validateTerminalFinalizationPayload,
-            execute: runTerminalFinalizationTask,
-        },
-        {
-            kind: LEAVE_RETENTION_TASK,
-            version: 1,
-            delivery: "one-shot",
-            attemptLimit: 5,
-            validatePayload: validateLeaveRetentionPayload,
-            execute: runLeaveRetention,
-        },
-    ],
+    scheduledTasks: createAccountGateTasks(health),
     start(context) {
+        health.start(context);
         context.logger.info({ event: "account_gate.started" }, "Access Control module started");
         return Promise.resolve();
     },
     stop(context) {
+        health.stop();
         context.logger.info({ event: "account_gate.stopped" }, "Access Control module stopped");
         return Promise.resolve();
     },
-    health() {
-        return {
-            status: "healthy",
-            message: "Access Control contributions are loaded",
-        };
-    },
+    health: () => health.snapshot(),
 });
 export default accountGateModule;
 export { ACCOUNT_GATE_IDENTITY, accountGateRecords, applyChallengeAction, createAccountGateSessionState, generateChallengeChain, parseAccountGateConfiguration, validateRuntimeCapabilities, validateServerQuestion, };
-async function handleGuildMemberAdd(context) {
-    if (context.memberIsBot)
-        return;
-    let configuration;
-    try {
-        configuration = await requiredRuntimeConfiguration(context.services, context.serverId);
-    }
-    catch {
-        return;
-    }
-    if (await isAccountGateWorkSuppressed(context.services, context.serverId, context.memberId, context.joinedAt))
-        return;
-    const records = context.services.get(HELYX_SERVICE_NAMES.records);
-    const previous = await loadMemberSummary(records, context.serverId, context.memberId);
-    const generation = (previous ? numberValue(previous.join_generation) : 0) + 1;
-    const accountTooYoung = isAccountTooYoung(context.accountCreatedAt, context.joinedAt, configuration.minimumAccountAgeDays);
-    const returningSuccess = previous?.last_decision !== "revoked" &&
-        hasPreviousSuccess(previous?.previous_success_at);
-    const restore = returningSuccess &&
-        configuration.restoreVerifiedMembers &&
-        !configuration.reverifyReturningMembers &&
-        !accountTooYoung;
-    const now = context.joinedAt;
-    const deadlineAt = accountTooYoung
-        ? now
-        : new Date(now.getTime() + configuration.joinDeadlineSeconds * 1_000);
-    const values = summaryValues({
-        guildId: context.serverId,
-        memberUserId: context.memberId,
-        now,
-        previous,
-        failureCount: 0,
-        lockoutUntil: new Date(0),
-        rejoinCount: previous ? numberValue(previous.rejoin_count) + 1 : 1,
-        joinGeneration: generation,
-        accountCreatedAt: context.accountCreatedAt,
-        joinedAt: context.joinedAt,
-        deadlineAt,
-        pendingReason: accountTooYoung ? "account_too_new" : "none",
-        lastDecision: restore ? "passed" : "pending",
-    });
-    const stored = previous
-        ? await records.updateOne({
-            moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
-            collection: "member_summaries",
-            where: {
-                guild_id: context.serverId,
-                member_user_id: context.memberId,
-            },
-            expected: {
-                field: "revision",
-                value: numberValue(previous.revision),
-            },
-            values: summaryUpdateValues(values),
-        })
-        : await records.appendUnique({
-            moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
-            collection: "member_summaries",
-            uniqueBy: ["guild_id", "member_user_id"],
-            values,
-        });
-    if (!("updated" in stored ? stored.updated : stored.created))
-        return;
-    if (restore) {
-        const role = await context.services
-            .get(HELYX_SERVICE_NAMES.discordResources)
-            .inspectRole({
-            guildId: context.serverId,
-            roleId: configuration.verifiedRoleId,
-        });
-        if (role.exists && role.assignable) {
-            await context.services
-                .get(HELYX_SERVICE_NAMES.memberRoles)
-                .addApprovedRole({
-                guildId: context.serverId,
-                memberUserId: context.memberId,
-                roleId: configuration.verifiedRoleId,
-                moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
-                reason: "Restore retained Access Control success after rejoin",
-            });
-            return;
-        }
-        await setSummaryDecision(records, context.serverId, context.memberId, generation, "review");
-        await createReview(context.services, context.serverId, context.memberId, "returning_role_restore_failed", null);
-        return;
-    }
-    for (const roleId of configuration.temporaryRoleIds) {
-        await context.services
-            .get(HELYX_SERVICE_NAMES.memberRoles)
-            .addApprovedRole({
-            guildId: context.serverId,
-            memberUserId: context.memberId,
-            roleId,
-            moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
-            reason: "Apply Access Control temporary pre-gate role",
-        });
-    }
-    await scheduleJoinDeadline(context.services, context.serverId, context.memberId, generation, deadlineAt);
-}
-async function handleGuildMemberRemove(context) {
-    if (context.memberIsBot)
-        return;
-    const sessions = context.services.get(HELYX_SERVICE_NAMES.sessions);
-    const active = await sessions.getFor(context.serverId, context.memberId, ACCOUNT_GATE_SESSION_PURPOSE);
-    if (active)
-        await sessions.delete(active.sessionId);
-    const records = context.services.get(HELYX_SERVICE_NAMES.records);
-    const row = await loadMemberSummary(records, context.serverId, context.memberId);
-    if (!row)
-        return;
-    const now = new Date();
-    const retentionUntil = new Date(now.getTime() + RETENTION_MS);
-    const generation = numberValue(row.join_generation);
-    await records.updateOne({
-        moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
-        collection: "member_summaries",
-        where: {
-            guild_id: context.serverId,
-            member_user_id: context.memberId,
-        },
-        expected: { field: "revision", value: numberValue(row.revision) },
-        values: {
-            revision: numberValue(row.revision) + 1,
-            left_at: now,
-            retention_until: retentionUntil,
-            updated_at: now,
-        },
-        schedule: {
-            taskKind: LEAVE_RETENTION_TASK,
-            guildId: context.serverId,
-            idempotencyKey: `${context.serverId}:${context.memberId}:leave:${generation}`,
-            payload: {
-                guildId: context.serverId,
-                memberUserId: context.memberId,
-                summaryId: stringValue(row.summary_id),
-            },
-            scheduledFor: retentionUntil,
-        },
-    });
-}
-export function isAccountTooYoung(accountCreatedAt, joinedAt, minimumAccountAgeDays) {
-    if (minimumAccountAgeDays <= 0)
-        return false;
-    return (joinedAt.getTime() - accountCreatedAt.getTime() <
-        minimumAccountAgeDays * 24 * 60 * 60 * 1_000);
-}
-export function hasPreviousSuccess(value) {
-    return value instanceof Date && value.getTime() > 0;
-}
-async function resetOwnAccess(context) {
-    if (!context.serverId) {
-        await replyError(context, "Access Control only works in a Discord server.");
-        return;
-    }
-    const configuration = await getConfiguration(context.services, context.serverId);
-    if (!configuration) {
-        await replyError(context, "Access Control has not been configured by the server team.");
-        return;
-    }
-    const records = context.services.get(HELYX_SERVICE_NAMES.records);
-    const summary = await loadMemberSummary(records, context.serverId, context.userId);
-    const [member] = await context.services
-        .get(HELYX_SERVICE_NAMES.discordResources)
-        .resolveMemberSnapshots({
-        guildId: context.serverId,
-        userIds: [context.userId],
-    });
-    if (!summary || !member?.exists || member.isBot) {
-        await replyError(context, "There is no Access Control member state to reset.");
-        return;
-    }
-    const sessions = context.services.get(HELYX_SERVICE_NAMES.sessions);
-    const activeSession = await sessions.getFor(context.serverId, context.userId, ACCOUNT_GATE_SESSION_PURPOSE);
-    if (activeSession)
-        await sessions.delete(activeSession.sessionId);
-    const now = new Date();
-    const generation = numberValue(summary.join_generation) + 1;
-    const accountCreatedAt = dateValue(summary.account_created_at) ?? new Date(0);
-    const deadlineAt = new Date(now.getTime() + configuration.joinDeadlineSeconds * 1_000);
-    const values = summaryValues({
-        guildId: context.serverId,
-        memberUserId: context.userId,
-        now,
-        previous: summary,
-        previousSuccessAt: new Date(0),
-        failureCount: 0,
-        lockoutUntil: new Date(0),
-        rejoinCount: numberValue(summary.rejoin_count),
-        joinGeneration: generation,
-        accountCreatedAt,
-        joinedAt: dateValue(summary.joined_at) ?? member.joinedAt ?? now,
-        deadlineAt,
-        pendingReason: isAccountTooYoung(accountCreatedAt, now, configuration.minimumAccountAgeDays)
-            ? "account_too_new"
-            : "none",
-        lastFailureTerminalId: "",
-        leftAt: new Date(0),
-        lastDecision: "pending",
-    });
-    const reset = await records.updateOne({
-        moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
-        collection: "member_summaries",
-        where: {
-            guild_id: context.serverId,
-            member_user_id: context.userId,
-        },
-        expected: {
-            field: "revision",
-            value: numberValue(summary.revision),
-        },
-        requireModuleEnabledForGuildId: context.serverId,
-        values: summaryUpdateValues(values),
-        audit: {
-            guildId: context.serverId,
-            actorUserId: context.userId,
-            action: "account_gate.self_reset",
-            source: "discord",
-            correlationId: context.interactionId,
-            idempotencyKey: context.interactionId,
-            targetType: "account_gate_member",
-            targetId: context.userId,
-            metadata: { generation },
-        },
-    });
-    if (!reset.updated) {
-        await replyError(context, "The Access Control state changed while it was being reset. Run the command again.");
-        return;
-    }
-    await scheduleJoinDeadline(context.services, context.serverId, context.userId, generation, deadlineAt);
-    try {
-        await context.services
-            .get(HELYX_SERVICE_NAMES.memberRoles)
-            .reconcileApprovedRoles({
-            guildId: context.serverId,
-            memberUserId: context.userId,
-            allowedRoleIds: [
-                configuration.verifiedRoleId,
-                ...configuration.temporaryRoleIds,
-            ],
-            desiredRoleIds: configuration.temporaryRoleIds,
-            moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
-            reason: "Access Control self reset",
-        });
-    }
-    catch {
-        await replyError(context, "The check was reset, but Discord did not apply all configured roles. Run the reset command again.");
-        return;
-    }
-    await context.reply({
-        ephemeral: true,
-        componentsV2: {
-            accentColor: VIOLET,
-            text: [
-                { content: "## Access Control reset" },
-                {
-                    content: "Your access was revoked and a fresh Access Control check is ready. Press Start check when you are ready.",
-                    markdown: false,
-                },
-            ],
-        },
-    });
-}
-async function startCheck(context) {
-    if (!context.serverId) {
-        await replyError(context, "Access Control only works in a Discord server.");
-        return;
-    }
-    const configuration = await getConfiguration(context.services, context.serverId);
-    if (!configuration) {
-        await replyError(context, "Access Control has not been configured by the server team.");
-        return;
-    }
-    const panelId = startPanelId(context.customId);
-    if (context.customId?.startsWith(ACCOUNT_GATE_COMPONENTS.startPrefix) &&
-        panelId === null) {
-        await replyError(context, "This Access Control panel control is invalid.");
-        return;
-    }
-    const panel = panelId === null
-        ? null
-        : await getGatePanelRuntime(context.services.get(HELYX_SERVICE_NAMES.records), context.serverId, panelId);
-    if (panelId !== null && !panel) {
-        await replyError(context, "This Access Control panel is no longer available. Ask the server team to publish or repair it.");
-        return;
-    }
-    if (panel?.accessType === "password" && !panel.password) {
-        await replyError(context, "This Password Entry panel does not have a password. Ask the server team to update it.");
-        return;
-    }
-    if (panel?.accessType === "challenges" &&
-        configuration.accessType !== "challenges") {
-        await replyError(context, "This Challenge panel is not currently active. Ask the server team to publish the current Access Control setup.");
-        return;
-    }
-    const activeConfiguration = panel
-        ? configurationForPanel(configuration, panel.accessType)
-        : configuration;
-    const setupErrors = await validateAccountGateSetup(context.services, context.serverId, activeConfiguration, false);
-    if (setupErrors.length > 0) {
-        await replyError(context, setupErrors[0]);
-        return;
-    }
-    const resources = context.services.get(HELYX_SERVICE_NAMES.discordResources);
-    let summary = await loadMemberSummary(context.services.get(HELYX_SERVICE_NAMES.records), context.serverId, context.userId);
-    const [member] = await resources.resolveMemberSnapshots({
-        guildId: context.serverId,
-        userIds: [context.userId],
-    });
-    if (summary?.last_decision === "revoked" &&
-        member?.exists &&
-        !member.isBot &&
-        !member.roleIds.includes(activeConfiguration.verifiedRoleId)) {
-        summary = await resumeRevokedMember(context.services, context.serverId, context.userId, summary, activeConfiguration, context.interactionId);
-        if (!summary) {
-            await replyError(context, "The revoked Access Control state changed while this check was starting. Press Start check again.");
-            return;
-        }
-    }
-    if (!summary ||
-        summary.last_decision !== "pending" ||
-        !member?.exists ||
-        member.isBot ||
-        member.roleIds.includes(activeConfiguration.verifiedRoleId)) {
-        await replyError(context, "There is no current pending Access Control check for this member.");
-        return;
-    }
-    const capabilityErrors = validateRuntimeCapabilities(activeConfiguration, await resources.inspectRuntimeCapabilities());
-    if (capabilityErrors.length > 0) {
-        await replyError(context, capabilityErrors[0]);
-        return;
-    }
-    const sessions = context.services.get(HELYX_SERVICE_NAMES.sessions);
-    const lockoutUntil = dateValue(summary?.lockout_until);
-    if (lockoutUntil && lockoutUntil.getTime() > Date.now()) {
-        await replyError(context, `Please wait until <t:${Math.floor(lockoutUntil.getTime() / 1_000)}:R> before starting another check.`);
-        return;
-    }
-    const existing = await sessions.getFor(context.serverId, context.userId, ACCOUNT_GATE_SESSION_PURPOSE);
-    if (existing) {
-        const existingState = parseAccountGateSessionState(existing.state);
-        if (existingState.status === "passed" ||
-            existingState.status === "failed") {
-            if (await ensureTerminalFinalization(context.services, context.serverId, context.userId, existing.sessionId, existingState, existingState.status))
-                await finalizeTerminalFinalization(context.services, context.serverId, existing.sessionId);
-            const finalizedSummary = await loadMemberSummary(context.services.get(HELYX_SERVICE_NAMES.records), context.serverId, context.userId);
-            await context.reply(terminalRecoveryMessage(existingState.status, typeof finalizedSummary?.last_decision === "string"
-                ? finalizedSummary.last_decision
-                : "pending"));
-            return;
-        }
-        await context.reply(challengeMessage(existingState, {
-            sessionId: existing.sessionId,
-            version: existing.version,
-        }));
-        return;
-    }
-    const strictModeActive = await currentStrictMode(context.services, context.serverId);
-    const random = secureRandom(context.services);
-    const questions = activeConfiguration.enabledChallengeTypes.includes("server_question")
-        ? await loadQuestions(context.services, context.serverId)
-        : [];
-    const state = createAccountGateSessionState(generateChallengeChain({
-        configuration: activeConfiguration,
-        random,
-        operationContext: `${context.serverId}:${context.userId}:${context.interactionId}`,
-        strictModeActive,
-        adaptiveRisk: (summary ? numberValue(summary.failure_count) : 0) > 0 ||
-            summary?.pending_reason === "account_too_new",
-        questions,
-    }), numberValue(summary.join_generation), new Date(), panelId ?? undefined);
-    const expiresAt = new Date(Date.now() + activeConfiguration.sessionExpirySeconds * 1_000);
-    const created = await sessions.create({
-        guildId: context.serverId,
-        userId: context.userId,
-        purpose: ACCOUNT_GATE_SESSION_PURPOSE,
-        state,
-        expiresAt,
-    });
-    await scheduleSessionExpiry(context.services, {
-        guildId: context.serverId,
-        userId: context.userId,
-        sessionId: created.sessionId,
-        expiredAt: expiresAt,
-    });
-    await context.reply(challengeMessage(state, {
-        sessionId: created.sessionId,
-        version: created.version,
-    }));
-}
-function startPanelId(customId) {
-    if (!customId?.startsWith(ACCOUNT_GATE_COMPONENTS.startPrefix))
-        return null;
-    const panelId = customId.slice(ACCOUNT_GATE_COMPONENTS.startPrefix.length);
-    return panelId.length >= 1 && panelId.length <= 100 && !panelId.includes(":")
-        ? panelId
-        : null;
-}
-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,
-    };
-}
-function terminalRecoveryMessage(outcome, decision) {
-    if (outcome === "passed" && decision === "passed")
-        return {
-            ephemeral: true,
-            componentsV2: {
-                accentColor: GREEN,
-                text: [
-                    { content: "## Access applied" },
-                    {
-                        content: "Your Access Control check is complete and your server access has been applied.",
-                        markdown: false,
-                    },
-                ],
-            },
-        };
-    if (decision === "review")
-        return {
-            ephemeral: true,
-            componentsV2: {
-                accentColor: VIOLET,
-                text: [
-                    { content: "## Check sent for review" },
-                    {
-                        content: "Your check is complete, but Helyx could not safely apply the configured roles. The server team has been notified.",
-                        markdown: false,
-                    },
-                ],
-            },
-        };
-    return {
-        ephemeral: true,
-        componentsV2: {
-            accentColor: outcome === "passed" ? VIOLET : RED,
-            text: [
-                {
-                    content: outcome === "passed"
-                        ? "## Access is being finalized"
-                        : "## Attempt submitted",
-                },
-                {
-                    content: outcome === "passed"
-                        ? "Your Access Control check is complete. Helyx is still applying the configured access changes."
-                        : "Your attempt has been recorded. Start a new check after the configured cooldown if another attempt is available.",
-                    markdown: false,
-                },
-            ],
-        },
-    };
-}
-async function processAction(context, action, binding) {
-    if (!context.serverId) {
-        await replyError(context, "This Access Control interaction is unavailable.");
-        return;
-    }
-    const sessions = context.services.get(HELYX_SERVICE_NAMES.sessions);
-    const session = await sessions.getFor(context.serverId, context.userId, ACCOUNT_GATE_SESSION_PURPOSE);
-    if (!session) {
-        await replyError(context, "This check has expired. Start a new check.");
-        return;
-    }
-    if (session.sessionId !== binding.sessionId ||
-        session.version !== binding.version ||
-        parseAccountGateSessionState(session.state).step !== binding.step) {
-        await replyError(context, "That control belongs to an older check or challenge step.");
-        return;
-    }
-    const configuration = await requiredRuntimeConfiguration(context.services, context.serverId);
-    if (!(await isCurrentPendingMember(context.services, context.serverId, context.userId, configuration.verifiedRoleId))) {
-        await sessions.delete(session.sessionId);
-        await replyError(context, "This pending Access Control check is no longer valid.");
-        return;
-    }
-    const state = parseAccountGateSessionState(session.state);
-    const result = applyChallengeAction(state, action);
-    if (result.outcome === "stale") {
-        await replyError(context, "That interaction is no longer part of your current check.");
-        return;
-    }
-    if (result.outcome === "progress") {
-        const updated = await sessions.update({
-            sessionId: session.sessionId,
-            expectedVersion: session.version,
-            state: result.state,
-        });
-        await scheduleSessionExpiry(context.services, {
-            guildId: context.serverId,
-            userId: context.userId,
-            sessionId: session.sessionId,
-            expiredAt: session.expiresAt,
-        });
-        await context.reply(challengeMessage(result.state, {
-            sessionId: session.sessionId,
-            version: updated.version,
-        }));
-        return;
-    }
-    const advanced = await sessions.advance({
-        sessionId: session.sessionId,
-        guildId: context.serverId,
-        userId: context.userId,
-        purpose: ACCOUNT_GATE_SESSION_PURPOSE,
-        expectedVersion: session.version,
-        expectedStep: state.step,
-        nextStep: state.step + 1,
-        state: { ...result.state, step: state.step + 1 },
-    });
-    await scheduleSessionExpiry(context.services, {
-        guildId: context.serverId,
-        userId: context.userId,
-        sessionId: session.sessionId,
-        expiredAt: session.expiresAt,
-    });
-    if (result.outcome === "advanced") {
-        await context.reply(challengeMessage(result.state, {
-            sessionId: session.sessionId,
-            version: advanced.version,
-        }));
-        return;
-    }
-    await finaliseAttempt(context, session.sessionId, result, state.chain[state.currentStep].type);
-}
-async function finaliseAttempt(context, sessionId, result, challengeType) {
-    const guildId = context.serverId;
-    await requiredRuntimeConfiguration(context.services, guildId);
-    if (await isAccountGateWorkSuppressed(context.services, guildId, context.userId, new Date(result.state.startedAt))) {
-        await context.services
-            .get(HELYX_SERVICE_NAMES.sessions)
-            .delete(sessionId);
-        await replyError(context, "This check can no longer be completed. Start a new check if you still require access.");
-        return;
-    }
-    const records = context.services.get(HELYX_SERVICE_NAMES.records);
-    await recordAccountGateAttempt(records, guildId, context.userId, sessionId, result.state, challengeType, result.outcome);
-    if (!(await ensureTerminalFinalization(context.services, guildId, context.userId, sessionId, result.state, result.outcome)))
-        return;
-    await finalizeTerminalFinalization(context.services, guildId, sessionId);
-    await context.reply({
-        ephemeral: true,
-        componentsV2: {
-            accentColor: result.outcome === "passed" ? GREEN : RED,
-            text: [
-                {
-                    content: result.outcome === "passed"
-                        ? "## Check submitted"
-                        : "## Attempt submitted",
-                },
-                {
-                    content: result.outcome === "passed"
-                        ? "Your result is being finalized. If access is not applied, the server team will receive a review."
-                        : "That answer was not correct. Start a new check when the cooldown ends if another attempt is available.",
-                    markdown: false,
-                },
-            ],
-        },
-    });
-}
-async function rerollChallenge(context) {
-    if (!context.serverId)
-        return replyError(context, "This check is unavailable.");
-    const sessions = context.services.get(HELYX_SERVICE_NAMES.sessions);
-    const session = await sessions.getFor(context.serverId, context.userId, ACCOUNT_GATE_SESSION_PURPOSE);
-    if (!session)
-        return replyError(context, "This check has expired.");
-    const binding = parseComponentBinding(context.customId, ACCOUNT_GATE_COMPONENTS.rerollPrefix);
-    if (!binding ||
-        binding.sessionId !== session.sessionId ||
-        binding.version !== session.version ||
-        binding.step !== parseAccountGateSessionState(session.state).step)
-        return replyError(context, "That reroll control is no longer current.");
-    const configuration = await requiredRuntimeConfiguration(context.services, context.serverId);
-    const currentState = parseAccountGateSessionState(session.state);
-    if (await isAccountGateWorkSuppressed(context.services, context.serverId, context.userId, new Date(currentState.startedAt))) {
-        await sessions.delete(session.sessionId);
-        await replyError(context, "This check can no longer be changed. Start a new check if you still require access.");
-        return;
-    }
-    const state = rerollForAccessibility({
-        state: currentState,
-        enabledTypes: generatedChallengePool(configuration),
-        random: secureRandom(context.services),
-        operationContext: `${context.serverId}:${context.userId}:reroll`,
-    });
-    if (!state) {
-        await replyError(context, "A different challenge is not available for this check.");
-        return;
-    }
-    const updated = await sessions.update({
-        sessionId: session.sessionId,
-        expectedVersion: session.version,
-        state,
-    });
-    await scheduleSessionExpiry(context.services, {
-        guildId: context.serverId,
-        userId: context.userId,
-        sessionId: session.sessionId,
-        expiredAt: session.expiresAt,
-    });
-    await context.reply(challengeMessage(state, {
-        sessionId: session.sessionId,
-        version: updated.version,
-    }));
-}
-async function openRecallModal(context) {
-    if (!context.serverId)
-        return replyError(context, "This check is unavailable.");
-    const binding = parseComponentBinding(context.customId, ACCOUNT_GATE_COMPONENTS.recallOpenPrefix);
-    if (!binding)
-        return replyError(context, "This recall challenge has expired.");
-    await context.showModal({
-        customId: boundComponentId(ACCOUNT_GATE_COMPONENTS.recallSubmitPrefix, binding),
-        title: "Enter the recalled code",
-        fields: [
-            {
-                customId: "code",
-                label: "Recall code",
-                description: "Letter case and surrounding spaces are ignored.",
-                style: "short",
-                required: true,
-                minLength: 5,
-                maxLength: 8,
-            },
-        ],
-    });
-    let session;
-    try {
-        session = await context.services
-            .get(HELYX_SERVICE_NAMES.sessions)
-            .getFor(context.serverId, context.userId, ACCOUNT_GATE_SESSION_PURPOSE);
-    }
-    catch {
-        return;
-    }
-    const state = session ? parseAccountGateSessionState(session.state) : null;
-    if (!session ||
-        !state ||
-        binding.sessionId !== session.sessionId ||
-        binding.version !== session.version ||
-        binding.step !== state.step ||
-        state.chain[state.currentStep]?.type !== "modal_recall") {
-        return;
-    }
-    await context
-        .editSourceMessage?.(challengeMessage(state, {
-        sessionId: session.sessionId,
-        version: session.version,
-    }, { redactRecallCode: true }))
-        .catch(() => undefined);
-}
-async function submitRecallModal(context) {
-    const binding = parseComponentBinding(context.customId, ACCOUNT_GATE_COMPONENTS.recallSubmitPrefix);
-    if (!binding) {
-        await replyError(context, "This recall challenge is no longer current.");
-        return;
-    }
-    await processAction(context, {
-        type: "recall",
-        value: context.getField("code"),
-    }, binding);
-}
-async function processBoundOption(context) {
-    const binding = parseComponentBinding(context.customId, ACCOUNT_GATE_COMPONENTS.answerPrefix);
-    const option = binding ? Number(binding.value) : -1;
-    if (!binding || !Number.isInteger(option) || option < 0 || option > 3) {
-        await replyError(context, "This answer control is invalid.");
-        return;
-    }
-    await processAction(context, { type: "option", option }, binding);
-}
-async function processBoundSequence(context) {
-    const binding = parseComponentBinding(context.customId, ACCOUNT_GATE_COMPONENTS.sequencePrefix);
-    if (!binding || !["red", "blue", "green"].includes(binding.value ?? "")) {
-        await replyError(context, "This sequence control is invalid.");
-        return;
-    }
-    await processAction(context, {
-        type: "sequence",
-        value: binding.value,
-    }, binding);
-}
-async function handlePasswordEntry(context) {
-    if (context.userIsBot || context.webhookId !== null)
-        return;
-    const configuration = await getConfiguration(context.services, context.serverId);
-    if (!configuration || configuration.passwordChannelId !== context.channelId) {
-        return;
-    }
-    const passwordConfiguration = configurationForPanel(configuration, "password");
-    if ((await validateAccountGateSetup(context.services, context.serverId, passwordConfiguration, false)).length > 0)
-        return;
-    const sessions = context.services.get(HELYX_SERVICE_NAMES.sessions);
-    const session = await sessions.getFor(context.serverId, context.userId, ACCOUNT_GATE_SESSION_PURPOSE);
-    if (!session)
-        return;
-    const state = parseAccountGateSessionState(session.state);
-    if (state.chain[state.currentStep]?.type !== "password_entry")
-        return;
-    await context.deleteSource();
-    const store = context.services.get(HELYX_SERVICE_NAMES.records);
-    const secret = state.panelId
-        ? ((await getGatePanelRuntime(store, context.serverId, state.panelId))
-            ?.password ?? null)
-        : null;
-    const matched = secret !== null &&
-        (await verifyPasswordEntry(context.content, secret.encodedHash, secret));
-    await processGatewayAction(context.services, context.serverId, context.userId, session, matched
-        ? { type: "static-complete", challenge: "password_entry" }
-        : { type: "static-failed", challenge: "password_entry" });
-}
-async function handleEmojiEntry(context) {
-    if (context.reactionType !== "normal")
-        return;
-    const configuration = await getConfiguration(context.services, context.serverId);
-    if (!configuration ||
-        !configuration.enabledChallengeTypes.includes("emoji_entry") ||
-        configuration.emojiChannelId !== context.channelId ||
-        configuration.emojiMessageId !== context.messageId ||
-        canonicalEmojiKey(configuration.emojiIdentifier) !== context.emojiKey) {
-        return;
-    }
-    if ((await validateAccountGateSetup(context.services, context.serverId, configuration, false)).length > 0)
-        return;
-    const [member] = await context.services
-        .get(HELYX_SERVICE_NAMES.discordResources)
-        .resolveMemberSnapshots({
-        guildId: context.serverId,
-        userIds: [context.userId],
-    });
-    if (!member || !member.exists || member.isBot)
-        return;
-    const sessions = context.services.get(HELYX_SERVICE_NAMES.sessions);
-    const session = await sessions.getFor(context.serverId, context.userId, ACCOUNT_GATE_SESSION_PURPOSE);
-    if (!session)
-        return;
-    const state = parseAccountGateSessionState(session.state);
-    if (state.chain[state.currentStep]?.type !== "emoji_entry")
-        return;
-    await processGatewayAction(context.services, context.serverId, context.userId, session, { type: "static-complete", challenge: "emoji_entry" });
-}
-async function processGatewayAction(services, guildId, userId, session, action) {
-    if (!session)
-        return;
-    const configuration = await requiredRuntimeConfiguration(services, guildId);
-    if (!(await isCurrentPendingMember(services, guildId, userId, configuration.verifiedRoleId)))
-        return;
-    const state = parseAccountGateSessionState(session.state);
-    const result = applyChallengeAction(state, action);
-    if (result.outcome === "progress" || result.outcome === "stale")
-        return;
-    const advanced = await services
-        .get(HELYX_SERVICE_NAMES.sessions)
-        .advance({
-        sessionId: session.sessionId,
-        guildId,
-        userId,
-        purpose: ACCOUNT_GATE_SESSION_PURPOSE,
-        expectedVersion: session.version,
-        expectedStep: state.step,
-        nextStep: state.step + 1,
-        state: { ...result.state, step: state.step + 1 },
-    });
-    await scheduleSessionExpiry(services, {
-        guildId,
-        userId,
-        sessionId: session.sessionId,
-        expiredAt: session.expiresAt,
-    });
-    if (result.outcome === "passed" || result.outcome === "failed") {
-        await recordAccountGateAttempt(services.get(HELYX_SERVICE_NAMES.records), guildId, userId, session.sessionId, result.state, state.chain[state.currentStep].type, result.outcome);
-        if (!(await ensureTerminalFinalization(services, guildId, userId, session.sessionId, result.state, result.outcome)))
-            return;
-    }
-    if (result.outcome === "advanced") {
-        let delivery = "failed";
-        try {
-            delivery = (await services
-                .get(HELYX_SERVICE_NAMES.discordMessages)
-                .sendDirect({
-                userId,
-                response: staticResumeMessage(guildId, configuration.gateChannelId),
-            })).outcome;
-        }
-        catch {
-            // A failed DM must not expose user-specific challenge controls publicly.
-        }
-        await emitLog(services, guildId, {
-            eventId: "account-gate-resume-notice",
-            summary: "Private Access Control resume guidance was attempted.",
-            details: [
-                { label: "Member ID", value: userId },
-                { label: "Delivery", value: delivery },
-            ],
-            idempotencyKey: `account-gate-resume:${session.sessionId}:${String(advanced.version)}`,
-        });
-        return;
-    }
-    if (result.outcome === "passed") {
-        await finalizeTerminalFinalization(services, guildId, session.sessionId);
-    }
-    else if (result.outcome === "failed") {
-        await finalizeTerminalFinalization(services, guildId, session.sessionId);
-    }
-}
-export async function resumeRevokedMember(services, guildId, memberUserId, summary, configuration, correlationId, now = new Date()) {
-    if (summary.last_decision !== "revoked")
-        return summary;
-    const records = services.get(HELYX_SERVICE_NAMES.records);
-    const revision = numberValue(summary.revision);
-    const generation = numberValue(summary.join_generation);
-    const deadlineAt = new Date(now.getTime() + configuration.joinDeadlineSeconds * 1_000);
-    const updated = await records.updateOne({
-        moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
-        collection: "member_summaries",
-        where: { guild_id: guildId, member_user_id: memberUserId },
-        expected: { field: "revision", value: revision },
-        requireModuleEnabledForGuildId: guildId,
-        values: {
-            failure_count: 0,
-            lockout_until: new Date(0),
-            last_failure_terminal_id: "",
-            deadline_at: deadlineAt,
-            pending_reason: "none",
-            left_at: new Date(0),
-            last_decision: "pending",
-            revision: revision + 1,
-            retention_until: new Date(now.getTime() + RETENTION_MS),
-            updated_at: now,
-        },
-        audit: {
-            guildId,
-            actorUserId: memberUserId,
-            action: "account_gate.revoked_check_started",
-            source: "discord",
-            correlationId,
-            idempotencyKey: correlationId,
-            targetType: "account_gate_member",
-            targetId: memberUserId,
-            metadata: { generation },
-        },
-    });
-    if (!updated.updated)
-        return null;
-    await scheduleJoinDeadline(services, guildId, memberUserId, generation, deadlineAt);
-    return loadMemberSummary(records, guildId, memberUserId);
-}
-export async function recordAccountGateAttempt(records, guildId, memberUserId, sessionId, state, challengeType, outcome, now = new Date()) {
-    const attemptId = randomUUID();
-    const retentionUntil = new Date(now.getTime() + RETENTION_MS);
-    const recorded = await records.appendUnique({
-        moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
-        collection: "attempts",
-        uniqueBy: ["guild_id", "session_id", "challenge_type"],
-        values: {
-            attempt_id: attemptId,
-            guild_id: guildId,
-            member_user_id: memberUserId,
-            session_id: sessionId,
-            challenge_type: challengeType,
-            outcome,
-            reason_code: outcome === "passed" ? "challenge_passed" : "challenge_failed",
-            duration_ms: Math.max(0, now.getTime() - Date.parse(state.startedAt)),
-            retention_until: retentionUntil,
-            created_at: now,
-        },
-    });
-    if (recorded.created)
-        await armRecordRetention(records, guildId, "attempts", "attempt_id", attemptId, retentionUntil);
-}
-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,
-        },
-    });
-}
-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,
-        },
-    });
-}
-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 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,
-                },
-            })
-            : 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,
-                },
-            });
-        if ("updated" in stored ? stored.updated : stored.created)
-            break;
-        if (retry === 3)
-            throw new Error("Access Control strict mode changed concurrently");
-    }
-    await services
-        .get(HELYX_SERVICE_NAMES.scheduledTasks)
-        .schedule({
-        moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
-        taskKind: STRICT_EXPIRY_TASK,
-        guildId,
-        idempotencyKey: `${guildId}:strict:${generation}`,
-        payload: { guildId },
-        scheduledFor: endsAt,
-    });
-    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;
-}
-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 };
-}
-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" };
-}
-function validateJoinDeadlinePayload(input) {
-    if (!input || typeof input !== "object" || Array.isArray(input))
-        throw new Error("Account Gate join-deadline payload is invalid");
-    const value = input;
-    if (typeof value.guildId !== "string" ||
-        !/^\d{17,20}$/u.test(value.guildId) ||
-        typeof value.memberUserId !== "string" ||
-        !/^\d{17,20}$/u.test(value.memberUserId))
-        throw new Error("Account Gate join-deadline payload is invalid");
-    return {
-        guildId: value.guildId,
-        memberUserId: value.memberUserId,
-    };
-}
-function validateLeaveRetentionPayload(input) {
-    if (!input || typeof input !== "object" || Array.isArray(input))
-        throw new Error("Account Gate leave-retention payload is invalid");
-    const value = input;
-    if (typeof value.guildId !== "string" ||
-        !/^\d{17,20}$/u.test(value.guildId) ||
-        typeof value.memberUserId !== "string" ||
-        !/^\d{17,20}$/u.test(value.memberUserId) ||
-        typeof value.summaryId !== "string")
-        throw new Error("Account Gate leave-retention payload is invalid");
-    return {
-        guildId: value.guildId,
-        memberUserId: value.memberUserId,
-        summaryId: value.summaryId,
-    };
-}
-async function runLeaveRetention(context, task) {
-    const guildId = task.payload.guildId;
-    const memberUserId = task.payload.memberUserId;
-    const summaryId = task.payload.summaryId;
-    const records = context.services.get(HELYX_SERVICE_NAMES.records);
-    const row = await records.findOne({
-        moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
-        collection: "member_summaries",
-        select: accountGateRecords.member_summaries.readableFields,
-        where: { summary_id: summaryId },
-    });
-    const leftAt = dateValue(row?.left_at);
-    const retentionUntil = dateValue(row?.retention_until);
-    if (!row ||
-        row.guild_id !== guildId ||
-        row.member_user_id !== memberUserId ||
-        !leftAt ||
-        !retentionUntil ||
-        (dateValue(row.joined_at)?.getTime() ?? Number.POSITIVE_INFINITY) >
-            leftAt.getTime())
-        return { outcome: "completed" };
-    if (retentionUntil.getTime() > Date.now())
-        return {
-            outcome: "deferred",
-            delayMs: Math.max(100, retentionUntil.getTime() - Date.now()),
-            safeCode: "leave-retention-not-due",
-        };
-    const [member] = await context.services
-        .get(HELYX_SERVICE_NAMES.discordResources)
-        .resolveMemberSnapshots({ guildId, userIds: [memberUserId] });
-    if (member?.exists)
-        return { outcome: "completed" };
-    await records.deleteMany({
-        moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
-        collection: "member_summaries",
-        where: { summary_id: summaryId },
-        limit: 1,
-    });
-    return { outcome: "completed" };
-}
-async function enforceJoinDeadline(context, task) {
-    const guildId = task.payload.guildId;
-    const memberUserId = task.payload.memberUserId;
-    const enabled = await context.services
-        .get(HELYX_SERVICE_NAMES.installations)
-        .isModuleEnabled(guildId, ACCOUNT_GATE_IDENTITY.moduleId);
-    if (!enabled)
-        return { outcome: "completed" };
-    const records = context.services.get(HELYX_SERVICE_NAMES.records);
-    const row = await loadMemberSummary(records, guildId, memberUserId);
-    if (!row || row.last_decision !== "pending")
-        return { outcome: "completed" };
-    const generation = numberValue(row.join_generation);
-    const joinedAt = dateValue(row.joined_at) ?? new Date(0);
-    const deadlineAt = dateValue(row.deadline_at);
-    if (!deadlineAt || deadlineAt.getTime() > Date.now()) {
-        return deadlineAt
-            ? {
-                outcome: "deferred",
-                delayMs: Math.max(100, deadlineAt.getTime() - Date.now()),
-                safeCode: "join-deadline-not-due",
-            }
-            : { outcome: "completed" };
-    }
-    if (await isAccountGateWorkSuppressed(context.services, guildId, memberUserId, joinedAt))
-        return { outcome: "completed" };
-    const [member] = await context.services
-        .get(HELYX_SERVICE_NAMES.discordResources)
-        .resolveMemberSnapshots({ guildId, userIds: [memberUserId] });
-    if (!member?.exists || member.isBot)
-        return { outcome: "completed" };
-    const sessions = context.services.get(HELYX_SERVICE_NAMES.sessions);
-    const active = await sessions.getFor(guildId, memberUserId, ACCOUNT_GATE_SESSION_PURPOSE);
-    if (active)
-        await sessions.delete(active.sessionId);
-    const configuration = await requiredRuntimeConfiguration(context.services, guildId);
-    const reason = row.pending_reason === "account_too_new"
-        ? "account_too_new"
-        : "join_deadline_expired";
-    const decision = row.pending_reason === "account_too_new"
-        ? "review"
-        : configuration.failureAction === "kick"
-            ? "kick_pending"
-            : configuration.failureAction === "review"
-                ? "review"
-                : "failed";
-    const claimed = await setSummaryDecision(records, guildId, memberUserId, generation, decision);
-    if (!claimed)
-        return { outcome: "completed" };
-    if (decision === "review") {
-        await createReview(context.services, guildId, memberUserId, reason, null);
-    }
-    else if (decision === "kick_pending") {
-        const result = await context.services
-            .get(HELYX_SERVICE_NAMES.memberEnforcement)
-            .kick({
-            guildId,
-            memberUserId,
-            moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
-            reason: `Access Control ${reason}`,
-            directMessage: {
-                embed: {
-                    title: "Removed after incomplete Access Control",
-                    description: neutralKickDirectMessage(`Discord server ${guildId}`),
-                    color: VIOLET,
-                },
-            },
-            revalidate: async () => {
-                const [stillEnabled, current, currentSession] = await Promise.all([
-                    context.services
-                        .get(HELYX_SERVICE_NAMES.installations)
-                        .isModuleEnabled(guildId, ACCOUNT_GATE_IDENTITY.moduleId),
-                    loadMemberSummary(records, guildId, memberUserId),
-                    sessions.getFor(guildId, memberUserId, ACCOUNT_GATE_SESSION_PURPOSE),
-                ]);
-                return (stillEnabled &&
-                    current !== null &&
-                    numberValue(current.join_generation) === generation &&
-                    current?.last_decision === "kick_pending" &&
-                    currentSession === null &&
-                    !(await isAccountGateWorkSuppressed(context.services, guildId, memberUserId, joinedAt)));
-            },
-        });
-        if (["kicked", "member_missing"].includes(result.outcome)) {
-            const committed = await setSummaryDecision(records, guildId, memberUserId, generation, "kicked", "kick_pending");
-            if (committed)
-                await emitAccountGateKickLog(context.services, guildId, {
-                    memberUserId,
-                    outcome: successfulKickOutcome(result.outcome),
-                    directMessage: result.directMessage,
-                    source: "Join deadline",
-                    idempotencyKey: `account-gate-kick:deadline:${memberUserId}:${generation}`,
-                });
-        }
-    }
-    return { outcome: "completed" };
-}
-function validateSessionExpiryPayload(input) {
-    if (!input || typeof input !== "object" || Array.isArray(input))
-        throw new Error("Account Gate session-expiry payload is invalid");
-    const value = input;
-    if (typeof value.guildId !== "string" ||
-        typeof value.userId !== "string" ||
-        typeof value.sessionId !== "string")
-        throw new Error("Account Gate session-expiry payload is invalid");
-    return {
-        guildId: value.guildId,
-        userId: value.userId,
-        sessionId: value.sessionId,
-    };
-}
-async function expireSession(context, task) {
-    const guildId = task.payload.guildId;
-    const userId = task.payload.userId;
-    const sessionId = task.payload.sessionId;
-    const sessions = context.services.get(HELYX_SERVICE_NAMES.sessions);
-    const current = await sessions.getFor(guildId, userId, ACCOUNT_GATE_SESSION_PURPOSE);
-    if (!current || current.sessionId !== sessionId) {
-        return { outcome: "completed" };
-    }
-    const result = await sessions.expire({
-        sessionId,
-        guildId,
-        userId,
-        purpose: ACCOUNT_GATE_SESSION_PURPOSE,
-        expiredAt: current.expiresAt,
-    });
-    if (!result.expired)
-        return { outcome: "completed" };
-    const expiredState = parseAccountGateSessionState(result.state);
-    if (await isAccountGateWorkSuppressed(context.services, guildId, userId, new Date(expiredState.startedAt)))
-        return { outcome: "completed" };
-    if (expiredState.status === "passed" || expiredState.status === "failed") {
-        const configuration = await requiredRuntimeConfiguration(context.services, guildId);
-        if (!(await isCurrentPendingMember(context.services, guildId, userId, configuration.verifiedRoleId)))
-            return { outcome: "completed" };
-    }
-    if (expiredState.status === "failed") {
-        if (!(await ensureTerminalFinalization(context.services, guildId, userId, sessionId, expiredState, "failed")))
-            return { outcome: "completed" };
-        await finalizeTerminalFinalization(context.services, guildId, sessionId);
-        return { outcome: "completed" };
-    }
-    if (expiredState.status === "passed") {
-        if (!(await ensureTerminalFinalization(context.services, guildId, userId, sessionId, expiredState, "passed")))
-            return { outcome: "completed" };
-        const now = new Date();
-        const challengeType = expiredState.chain.at(-1)?.type;
-        if (challengeType) {
-            const records = context.services.get(HELYX_SERVICE_NAMES.records);
-            const attemptId = randomUUID();
-            const retentionUntil = new Date(now.getTime() + RETENTION_MS);
-            const recorded = await records.appendUnique({
-                moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
-                collection: "attempts",
-                uniqueBy: ["guild_id", "session_id", "challenge_type"],
-                values: {
-                    attempt_id: attemptId,
-                    guild_id: guildId,
-                    member_user_id: userId,
-                    session_id: sessionId,
-                    challenge_type: challengeType,
-                    outcome: "passed",
-                    reason_code: "challenge_passed_recovered",
-                    duration_ms: Math.max(0, now.getTime() - Date.parse(expiredState.startedAt)),
-                    retention_until: retentionUntil,
-                    created_at: now,
-                },
-            });
-            if (recorded.created)
-                await armRecordRetention(records, guildId, "attempts", "attempt_id", attemptId, retentionUntil);
-        }
-        await finalizeTerminalFinalization(context.services, guildId, sessionId);
-        return { outcome: "completed" };
-    }
-    const challengeType = expiredState.chain[expiredState.currentStep]?.type;
-    if (challengeType) {
-        const now = new Date();
-        const records = context.services.get(HELYX_SERVICE_NAMES.records);
-        const attemptId = randomUUID();
-        const retentionUntil = new Date(now.getTime() + RETENTION_MS);
-        const recorded = await records.appendUnique({
-            moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
-            collection: "attempts",
-            uniqueBy: ["guild_id", "session_id", "challenge_type"],
-            values: {
-                attempt_id: attemptId,
-                guild_id: guildId,
-                member_user_id: userId,
-                session_id: sessionId,
-                challenge_type: challengeType,
-                outcome: "expired",
-                reason_code: "session_expired",
-                duration_ms: Math.max(0, now.getTime() - Date.parse(expiredState.startedAt)),
-                retention_until: retentionUntil,
-                created_at: now,
-            },
-        });
-        if (recorded.created)
-            await armRecordRetention(records, guildId, "attempts", "attempt_id", attemptId, retentionUntil);
-    }
-    return { outcome: "completed" };
-}
-export async function ensureTerminalFinalization(services, guildId, memberUserId, sessionId, state, outcome) {
-    const records = services.get(HELYX_SERVICE_NAMES.records);
-    const summary = await loadMemberSummary(records, guildId, memberUserId);
-    if (!summary ||
-        !["pending", "finalizing"].includes(stringValue(summary.last_decision)))
-        return false;
-    const generation = state.joinGeneration;
-    if (numberValue(summary.join_generation) !== generation)
-        return false;
-    const challenge = outcome === "passed" ? state.chain.at(-1) : state.chain[state.currentStep];
-    if (!challenge)
-        return false;
-    const now = new Date();
-    const retentionUntil = new Date(now.getTime() + RETENTION_MS);
-    const created = await records.appendUnique({
-        moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
-        collection: "terminal_finalizations",
-        uniqueBy: ["guild_id", "session_id"],
-        values: {
-            finalization_id: sessionId,
-            guild_id: guildId,
-            member_user_id: memberUserId,
-            session_id: sessionId,
-            join_generation: generation,
-            outcome,
-            challenge_type: challenge.type,
-            challenge_types_json: JSON.stringify(state.chain.map(({ type }) => type)),
-            work_created_at: new Date(state.startedAt),
-            status: "pending",
-            revision: 1,
-            retention_until: retentionUntil,
-            created_at: now,
-            updated_at: now,
-        },
-    });
-    if (created.created)
-        await armRecordRetention(records, guildId, "terminal_finalizations", "finalization_id", sessionId, retentionUntil);
-    if (summary.last_decision === "pending") {
-        const revision = numberValue(summary.revision);
-        const claimed = await records.updateOne({
-            moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
-            collection: "member_summaries",
-            where: { guild_id: guildId, member_user_id: memberUserId },
-            expected: { field: "revision", value: revision },
-            values: {
-                last_decision: "finalizing",
-                revision: revision + 1,
-                updated_at: now,
-            },
-            schedule: {
-                taskKind: TERMINAL_FINALIZATION_TASK,
-                guildId,
-                idempotencyKey: `${guildId}:${sessionId}:terminal`,
-                payload: { guildId, finalizationId: sessionId },
-                scheduledFor: now,
-            },
-        });
-        if (!claimed.updated)
-            return false;
-    }
-    else {
-        await scheduleTerminalFinalization(services, guildId, sessionId, now);
-    }
-    return true;
-}
-function validateTerminalFinalizationPayload(input) {
-    if (!input || typeof input !== "object" || Array.isArray(input))
-        throw new Error("Account Gate terminal-finalization payload is invalid");
-    const value = input;
-    if (typeof value.guildId !== "string" ||
-        typeof value.finalizationId !== "string" ||
-        value.finalizationId.length > 100)
-        throw new Error("Account Gate terminal-finalization payload is invalid");
-    return {
-        guildId: value.guildId,
-        finalizationId: value.finalizationId,
-    };
-}
-async function runTerminalFinalizationTask(context, task) {
-    await finalizeTerminalFinalization(context.services, task.payload.guildId, task.payload.finalizationId);
-    return { outcome: "completed" };
-}
-async function finalizeTerminalFinalization(services, guildId, finalizationId) {
-    const records = services.get(HELYX_SERVICE_NAMES.records);
-    const row = await records.findOne({
-        moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
-        collection: "terminal_finalizations",
-        select: accountGateRecords.terminal_finalizations.readableFields,
-        where: { guild_id: guildId, finalization_id: finalizationId },
-    });
-    if (!row || ["completed", "cancelled"].includes(stringValue(row.status)))
-        return;
-    const memberUserId = stringValue(row.member_user_id);
-    const generation = numberValue(row.join_generation);
-    const summary = await loadMemberSummary(records, guildId, memberUserId);
-    const enabled = await services
-        .get(HELYX_SERVICE_NAMES.installations)
-        .isModuleEnabled(guildId, ACCOUNT_GATE_IDENTITY.moduleId);
-    if (!enabled ||
-        !summary ||
-        numberValue(summary.join_generation) !== generation ||
-        !["finalizing", "failed", "passed", "review"].includes(stringValue(summary.last_decision)) ||
-        (await isAccountGateWorkSuppressed(services, guildId, memberUserId, dateValue(row.work_created_at) ?? new Date(0)))) {
-        await finishTerminalRecord(records, row, "cancelled");
-        return;
-    }
-    const configuration = await requiredRuntimeConfiguration(services, guildId);
-    const sessions = services.get(HELYX_SERVICE_NAMES.sessions);
-    if (row.outcome === "passed") {
-        if (summary.last_decision === "passed") {
-            await emitAccountGateCompletedLog(services, guildId, {
-                memberUserId,
-                roleOutcome: "already_applied",
-                idempotencyKey: `account-gate-completed:${finalizationId}`,
-            });
-            await sessions.delete(stringValue(row.session_id));
-            await finishTerminalRecord(records, row, "completed");
-            return;
-        }
-        const transition = await applyRoleTransition({
-            guildId,
-            memberUserId,
-            verifiedRoleId: configuration.verifiedRoleId,
-            temporaryRoleIds: configuration.temporaryRoleIds,
-            resources: services.get(HELYX_SERVICE_NAMES.discordResources),
-            roles: services.get(HELYX_SERVICE_NAMES.memberRoles),
-            revalidate: () => terminalPassStillCurrent(services, guildId, memberUserId, generation, dateValue(row.work_created_at) ?? new Date(0)),
-        });
-        if (transition.outcome === "stale") {
-            await finishTerminalRecord(records, row, "cancelled");
-            return;
-        }
-        if (transition.outcome === "blocked") {
-            await setSummaryDecision(records, guildId, memberUserId, generation, "review", "finalizing");
-            await createReview(services, guildId, memberUserId, "role_assignment_failed", null, generation, JSON.parse(stringValue(row.challenge_types_json)), dateValue(row.work_created_at) ?? new Date(0));
-        }
-        else {
-            if (transition.outcome === "partial")
-                await persistPartialTransition(services, guildId, memberUserId, configuration.verifiedRoleId, transition.pendingRoleIds, dateValue(row.work_created_at) ?? new Date(0));
-            if (!(await markSummaryPassed(records, guildId, memberUserId, new Date(), generation))) {
-                await compensateVerifiedRoleAddition(services, guildId, memberUserId, configuration.verifiedRoleId, transition);
-                await finishTerminalRecord(records, row, "cancelled");
-                return;
-            }
-            await emitAccountGateCompletedLog(services, guildId, {
-                memberUserId,
-                roleOutcome: transition.outcome,
-                idempotencyKey: `account-gate-completed:${finalizationId}`,
-            });
-        }
-    }
-    else {
-        const failures = await recordFailureSummary(records, guildId, memberUserId, new Date(), configuration.retryCooldownSeconds, configuration.attempts, finalizationId, generation);
-        if (failures === null) {
-            await finishTerminalRecord(records, row, "cancelled");
-            return;
-        }
-        await sessions.delete(stringValue(row.session_id));
-        if (failures >= configuration.attempts)
-            await applyDurableFailureAction(services, configuration, guildId, memberUserId, generation, row);
-    }
-    await sessions.delete(stringValue(row.session_id));
-    await finishTerminalRecord(records, row, "completed");
-}
-async function finishTerminalRecord(records, row, status) {
-    const revision = numberValue(row.revision);
-    await records.updateOne({
-        moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
-        collection: "terminal_finalizations",
-        where: { finalization_id: stringValue(row.finalization_id) },
-        expected: { field: "revision", value: revision },
-        values: { status, revision: revision + 1, updated_at: new Date() },
-    });
-}
-async function applyDurableFailureAction(services, configuration, guildId, memberUserId, generation, terminal) {
-    if (configuration.failureAction === "review") {
-        await createReview(services, guildId, memberUserId, "attempt_limit_reached", null, generation, JSON.parse(stringValue(terminal.challenge_types_json)), dateValue(terminal.work_created_at) ?? new Date(0));
-        return;
-    }
-    if (configuration.failureAction !== "kick")
-        return;
-    const records = services.get(HELYX_SERVICE_NAMES.records);
-    const result = await services
-        .get(HELYX_SERVICE_NAMES.memberEnforcement)
-        .kick({
-        guildId,
-        memberUserId,
-        moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
-        reason: "Access Control final failure",
-        directMessage: {
-            embed: {
-                title: "Removed after incomplete Access Control",
-                description: neutralKickDirectMessage(`Discord server ${guildId}`),
-                color: VIOLET,
-            },
-        },
-        revalidate: async () => {
-            const [enabled, summary, session] = await Promise.all([
-                services
-                    .get(HELYX_SERVICE_NAMES.installations)
-                    .isModuleEnabled(guildId, ACCOUNT_GATE_IDENTITY.moduleId),
-                loadMemberSummary(records, guildId, memberUserId),
-                services
-                    .get(HELYX_SERVICE_NAMES.sessions)
-                    .getFor(guildId, memberUserId, ACCOUNT_GATE_SESSION_PURPOSE),
-            ]);
-            if (!enabled || session !== null || !summary)
-                return false;
-            if (numberValue(summary.join_generation) !== generation ||
-                summary.last_decision !== "failed")
-                return false;
-            try {
-                await requiredRuntimeConfiguration(services, guildId);
-            }
-            catch {
-                return false;
-            }
-            return !(await isAccountGateWorkSuppressed(services, guildId, memberUserId, dateValue(terminal.work_created_at) ?? new Date(0)));
-        },
-    });
-    if (["kicked", "member_missing"].includes(result.outcome))
-        await emitAccountGateKickLog(services, guildId, {
-            memberUserId,
-            outcome: successfulKickOutcome(result.outcome),
-            directMessage: result.directMessage,
-            source: "Failed check",
-            idempotencyKey: `account-gate-kick:terminal:${stringValue(terminal.finalization_id)}`,
-        });
-}
-function validateReviewDeliveryPayload(input) {
-    if (!input || typeof input !== "object" || Array.isArray(input))
-        throw new Error("Account Gate review-delivery payload is invalid");
-    const value = input;
-    if (typeof value.guildId !== "string" ||
-        typeof value.reviewId !== "string" ||
-        value.reviewId.length > 100)
-        throw new Error("Account Gate review-delivery payload is invalid");
-    return { guildId: value.guildId, reviewId: value.reviewId };
-}
-async function deliverReview(context, task) {
-    const guildId = task.payload.guildId;
-    const reviewId = task.payload.reviewId;
-    const enabled = await context.services
-        .get(HELYX_SERVICE_NAMES.installations)
-        .isModuleEnabled(guildId, ACCOUNT_GATE_IDENTITY.moduleId);
-    if (!enabled)
-        return { outcome: "completed" };
-    const records = context.services.get(HELYX_SERVICE_NAMES.records);
-    const row = await records.findOne({
-        moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
-        collection: "reviews",
-        select: accountGateRecords.reviews.readableFields,
-        where: { guild_id: guildId, review_id: reviewId },
-    });
-    if (!row || row.status !== "pending" || row.delivery_status === "sent")
-        return { outcome: "completed" };
-    if (await isAccountGateWorkSuppressed(context.services, guildId, stringValue(row.member_user_id), dateValue(row.created_at) ?? new Date(0)))
-        return { outcome: "completed" };
-    const configuration = await getConfiguration(context.services, guildId);
-    if (!configuration?.reviewChannelId)
-        return {
-            outcome: "requires_review",
-            safeCode: "review-channel-unavailable",
-        };
-    try {
-        const sent = await context.services
-            .get(HELYX_SERVICE_NAMES.discordMessages)
-            .send({
-            guildId,
-            channelId: configuration.reviewChannelId,
-            response: reviewMessage(stringValue(row.member_user_id), stringValue(row.reason_code)),
-        });
-        const revision = numberValue(row.revision);
-        const stored = await records.updateOne({
-            moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
-            collection: "reviews",
-            where: { guild_id: guildId, review_id: reviewId },
-            expected: { field: "revision", value: revision },
-            values: {
-                delivery_status: "sent",
-                review_channel_id: configuration.reviewChannelId,
-                review_message_id: sent.messageId,
-                revision: revision + 1,
-                updated_at: new Date(),
-            },
-        });
-        return stored.updated
-            ? { outcome: "completed" }
-            : {
-                outcome: "retry",
-                delayMs: 5_000,
-                safeCode: "review-delivery-cas",
-            };
-    }
-    catch {
-        return {
-            outcome: "retry",
-            delayMs: 30_000,
-            safeCode: "review-delivery-failed",
-        };
-    }
-}
-function validateReviewClaimRecoveryPayload(input) {
-    if (!input || typeof input !== "object" || Array.isArray(input))
-        throw new Error("Account Gate review-claim payload is invalid");
-    const value = input;
-    if (typeof value.guildId !== "string" ||
-        !/^\d{17,20}$/u.test(value.guildId) ||
-        typeof value.reviewId !== "string")
-        throw new Error("Account Gate review-claim payload is invalid");
-    return {
-        guildId: value.guildId,
-        reviewId: value.reviewId,
-    };
-}
-async function recoverReviewClaim(context, task) {
-    const guildId = task.payload.guildId;
-    const reviewId = task.payload.reviewId;
-    const records = context.services.get(HELYX_SERVICE_NAMES.records);
-    const row = await records.findOne({
-        moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
-        collection: "reviews",
-        select: accountGateRecords.reviews.readableFields,
-        where: { guild_id: guildId, review_id: reviewId },
-    });
-    if (!row || !stringValue(row.status).startsWith("claim_"))
-        return { outcome: "completed" };
-    const claimExpiresAt = dateValue(row.claim_expires_at);
-    if (claimExpiresAt && claimExpiresAt.getTime() > Date.now())
-        return {
-            outcome: "deferred",
-            delayMs: Math.max(100, claimExpiresAt.getTime() - Date.now()),
-            safeCode: "review-claim-not-due",
-        };
-    const generation = numberValue(row.join_generation);
-    const claimRevision = numberValue(row.revision);
-    const summary = await loadMemberSummary(records, guildId, stringValue(row.member_user_id));
-    const memberUserId = stringValue(row.member_user_id);
-    const enabled = await context.services
-        .get(HELYX_SERVICE_NAMES.installations)
-        .isModuleEnabled(guildId, ACCOUNT_GATE_IDENTITY.moduleId);
-    if (!enabled ||
-        !summary ||
-        numberValue(summary.join_generation) !== generation ||
-        (await isAccountGateWorkSuppressed(context.services, guildId, memberUserId, dateValue(row.created_at) ?? new Date(0)))) {
-        await finalizeReviewClaim(records, guildId, reviewId, claimRevision, "dismissed", row);
-        return { outcome: "completed" };
-    }
-    let configuration;
-    try {
-        configuration = await requiredRuntimeConfiguration(context.services, guildId);
-    }
-    catch {
-        return {
-            outcome: "retry",
-            delayMs: 30_000,
-            safeCode: "review-claim-setup-invalid",
-        };
-    }
-    const action = stringValue(row.claim_action);
-    if (action === "approve") {
-        let completionRoleOutcome = null;
-        if (summary.last_decision !== "passed") {
-            const snapshots = await context.services
-                .get(HELYX_SERVICE_NAMES.discordResources)
-                .resolveMemberSnapshots({ guildId, userIds: [memberUserId] });
-            const verifiedRoleAlreadyApplied = snapshots[0]?.exists === true &&
-                snapshots[0].roleIds.includes(configuration.verifiedRoleId);
-            if (!verifiedRoleAlreadyApplied &&
-                !(await reviewStillCurrent(context.services, guildId, memberUserId, generation, configuration.verifiedRoleId))) {
-                await finalizeReviewClaim(records, guildId, reviewId, claimRevision, "dismissed", row);
-                return { outcome: "completed" };
-            }
-            const transition = await applyRoleTransition({
-                guildId,
-                memberUserId,
-                verifiedRoleId: configuration.verifiedRoleId,
-                temporaryRoleIds: configuration.temporaryRoleIds,
-                resources: context.services.get(HELYX_SERVICE_NAMES.discordResources),
-                roles: context.services.get(HELYX_SERVICE_NAMES.memberRoles),
-                revalidate: () => reviewStillCurrent(context.services, guildId, memberUserId, generation, configuration.verifiedRoleId, true),
-            });
-            if (transition.outcome === "stale") {
-                await finalizeReviewClaim(records, guildId, reviewId, claimRevision, "dismissed", row);
-                return { outcome: "completed" };
-            }
-            if (transition.outcome === "blocked")
-                return {
-                    outcome: "retry",
-                    delayMs: 30_000,
-                    safeCode: "review-approve-role-blocked",
-                };
-            if (transition.outcome === "partial")
-                await persistPartialTransition(context.services, guildId, memberUserId, configuration.verifiedRoleId, transition.pendingRoleIds, dateValue(row.created_at) ?? new Date(0));
-            if (!(await markSummaryPassed(records, guildId, memberUserId, new Date(), generation))) {
-                await compensateVerifiedRoleAddition(context.services, guildId, memberUserId, configuration.verifiedRoleId, transition);
-                await finalizeReviewClaim(records, guildId, reviewId, claimRevision, "dismissed", row);
-                return { outcome: "completed" };
-            }
-            completionRoleOutcome = transition.outcome;
-        }
-        const finalized = await finalizeReviewClaim(records, guildId, reviewId, claimRevision, "approved", row);
-        if (finalized && completionRoleOutcome)
-            await emitAccountGateCompletedLog(context.services, guildId, {
-                memberUserId,
-                roleOutcome: completionRoleOutcome,
-                idempotencyKey: `account-gate-completed:review:${reviewId}`,
-            });
-        return { outcome: "completed" };
-    }
-    if (action === "retry") {
-        if (summary.last_decision !== "pending") {
-            const reset = await resetSummaryForRetry(records, guildId, memberUserId, new Date(), generation);
-            if (!reset) {
-                await finalizeReviewClaim(records, guildId, reviewId, claimRevision, "dismissed", row);
-                return { outcome: "completed" };
-            }
-        }
-        await finalizeReviewClaim(records, guildId, reviewId, claimRevision, "retry", row);
-        return { outcome: "completed" };
-    }
-    if (action === "kick") {
-        const snapshots = await context.services
-            .get(HELYX_SERVICE_NAMES.discordResources)
-            .resolveMemberSnapshots({ guildId, userIds: [memberUserId] });
-        let kickOutcome = "member_missing";
-        let directMessage = "not_requested";
-        if (snapshots[0]?.exists === true) {
-            const result = await context.services
-                .get(HELYX_SERVICE_NAMES.memberEnforcement)
-                .kick({
-                guildId,
-                memberUserId,
-                moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
-                reason: "Access Control staff review decision recovery",
-                directMessage: {
-                    embed: {
-                        title: "Removed after an Access Control review",
-                        description: neutralKickDirectMessage(`Discord server ${guildId}`),
-                        color: VIOLET,
-                    },
-                },
-                revalidate: () => reviewStillCurrent(context.services, guildId, memberUserId, generation, configuration.verifiedRoleId),
-            });
-            if (!["kicked", "member_missing"].includes(result.outcome))
-                if (!(await reviewStillCurrent(context.services, guildId, memberUserId, generation, configuration.verifiedRoleId))) {
-                    await finalizeReviewClaim(records, guildId, reviewId, claimRevision, "dismissed", row);
-                    return { outcome: "completed" };
-                }
-                else
-                    return {
-                        outcome: "retry",
-                        delayMs: 30_000,
-                        safeCode: "review-kick-not-complete",
-                    };
-            kickOutcome = successfulKickOutcome(result.outcome);
-            directMessage = result.directMessage;
-        }
-        const finalized = await finalizeReviewClaim(records, guildId, reviewId, claimRevision, "kicked", row);
-        if (finalized)
-            await emitAccountGateKickLog(context.services, guildId, {
-                memberUserId,
-                outcome: kickOutcome,
-                directMessage,
-                source: "Staff review recovery",
-                idempotencyKey: `account-gate-kick:review:${reviewId}`,
-            });
-        return { outcome: "completed" };
-    }
-    await finalizeReviewClaim(records, guildId, reviewId, claimRevision, "dismissed", row);
-    return { outcome: "completed" };
-}
-async function finalizeReviewClaim(records, guildId, reviewId, claimRevision, status, row, expiredOnly = true) {
-    const now = new Date();
-    return (await records.updateOne({
-        moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
-        collection: "reviews",
-        where: { guild_id: guildId, review_id: reviewId },
-        expected: { field: "revision", value: claimRevision },
-        ...(expiredOnly
-            ? { dateAtOrBeforeNow: { field: "claim_expires_at" } }
-            : {}),
-        values: {
-            pending_key: `resolved:${reviewId}`,
-            status,
-            claim_action: "",
-            claim_expires_at: new Date(0),
-            decided_by_user_id: typeof row.decided_by_user_id === "string"
-                ? row.decided_by_user_id
-                : "system",
-            decided_at: dateValue(row.decided_at) ?? now,
-            revision: claimRevision + 1,
-            updated_at: now,
-        },
-    })).updated;
-}
-function validateRoleRetryPayload(input) {
-    if (!input || typeof input !== "object" || Array.isArray(input))
-        throw new Error("Account Gate role retry payload is invalid");
-    const value = input;
-    if (typeof value.guildId !== "string" ||
-        typeof value.transitionId !== "string" ||
-        value.transitionId.length > 100)
-        throw new Error("Account Gate role retry payload is invalid");
-    return { guildId: value.guildId, transitionId: value.transitionId };
-}
-async function retryRoleTransition(context, task) {
-    const records = context.services.get(HELYX_SERVICE_NAMES.records);
-    const row = await records.findOne({
-        moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
-        collection: "role_transitions",
-        select: accountGateRecords.role_transitions.readableFields,
-        where: {
-            guild_id: task.payload.guildId,
-            transition_id: task.payload.transitionId,
-        },
-    });
-    if (!row || row.status === "completed")
-        return { outcome: "completed" };
-    if (await isAccountGateWorkSuppressed(context.services, stringValue(row.guild_id), stringValue(row.member_user_id), dateValue(row.created_at) ?? new Date(0)))
-        return { outcome: "completed" };
-    const transition = await applyRoleTransition({
-        guildId: stringValue(row.guild_id),
-        memberUserId: stringValue(row.member_user_id),
-        verifiedRoleId: stringValue(row.verified_role_id),
-        temporaryRoleIds: JSON.parse(stringValue(row.pending_remove_role_ids_json)),
-        resources: context.services.get(HELYX_SERVICE_NAMES.discordResources),
-        roles: context.services.get(HELYX_SERVICE_NAMES.memberRoles),
-        revalidate: () => roleRetryStillCurrent(context.services, stringValue(row.guild_id), stringValue(row.member_user_id), dateValue(row.created_at) ?? new Date(0)),
-    });
-    const revision = numberValue(row.revision);
-    await records.updateOne({
-        moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
-        collection: "role_transitions",
-        where: { transition_id: task.payload.transitionId },
-        expected: { field: "revision", value: revision },
-        values: {
-            pending_remove_role_ids_json: JSON.stringify(transition.pendingRoleIds),
-            status: ["completed", "stale"].includes(transition.outcome)
-                ? "completed"
-                : transition.outcome === "blocked"
-                    ? "review"
-                    : "partial",
-            revision: revision + 1,
-            completed_at: ["completed", "stale"].includes(transition.outcome)
-                ? new Date()
-                : new Date(0),
-            updated_at: new Date(),
-        },
-    });
-    return transition.outcome === "partial"
-        ? {
-            outcome: "retry",
-            delayMs: 30_000,
-            safeCode: "role-removal-pending",
-        }
-        : transition.outcome === "blocked"
-            ? {
-                outcome: "requires_review",
-                safeCode: "role-transition-blocked",
-            }
-            : { outcome: "completed" };
-}
-async function persistPartialTransition(services, guildId, memberUserId, verifiedRoleId, pendingRoleIds, workCreatedAt = new Date()) {
-    if (await isAccountGateWorkSuppressed(services, guildId, memberUserId, workCreatedAt))
-        return;
-    const now = new Date();
-    const records = services.get(HELYX_SERVICE_NAMES.records);
-    const existing = await records.findOne({
-        moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
-        collection: "role_transitions",
-        select: accountGateRecords.role_transitions.readableFields,
-        where: { guild_id: guildId, member_user_id: memberUserId },
-    });
-    const id = existing ? stringValue(existing.transition_id) : randomUUID();
-    const revision = existing ? numberValue(existing.revision) + 1 : 1;
-    const stored = existing
-        ? await records.updateOne({
-            moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
-            collection: "role_transitions",
-            where: { guild_id: guildId, transition_id: id },
-            expected: {
-                field: "revision",
-                value: numberValue(existing.revision),
-            },
-            values: {
-                verified_role_id: verifiedRoleId,
-                pending_remove_role_ids_json: JSON.stringify(pendingRoleIds),
-                status: "partial",
-                revision,
-                next_retry_at: new Date(now.getTime() + 30_000),
-                updated_at: now,
-            },
-        })
-        : await records.appendUnique({
-            moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
-            collection: "role_transitions",
-            uniqueBy: ["guild_id", "member_user_id"],
-            values: {
-                transition_id: id,
-                guild_id: guildId,
-                member_user_id: memberUserId,
-                verified_role_id: verifiedRoleId,
-                pending_remove_role_ids_json: JSON.stringify(pendingRoleIds),
-                status: "partial",
-                revision,
-                next_retry_at: new Date(now.getTime() + 30_000),
-                created_at: now,
-                updated_at: now,
-            },
-        });
-    if (!("updated" in stored ? stored.updated : stored.created))
-        return;
-    await services
-        .get(HELYX_SERVICE_NAMES.scheduledTasks)
-        .schedule({
-        moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
-        taskKind: ROLE_RETRY_TASK,
-        guildId,
-        idempotencyKey: `${guildId}:${memberUserId}:role-transition:${revision}`,
-        payload: { guildId, transitionId: id },
-        scheduledFor: new Date(now.getTime() + 30_000),
-    });
-}
-async function createReview(services, guildId, memberUserId, reasonCode, state, expectedJoinGeneration, boundedChallengeTypes, workCreatedAtOverride) {
-    const records = services.get(HELYX_SERVICE_NAMES.records);
-    const summary = await loadMemberSummary(records, guildId, memberUserId);
-    if (!summary)
-        return;
-    const joinGeneration = numberValue(summary.join_generation);
-    if (expectedJoinGeneration !== undefined &&
-        joinGeneration !== expectedJoinGeneration)
-        return;
-    const workCreatedAt = workCreatedAtOverride ?? (state ? new Date(state.startedAt) : new Date());
-    if (await isAccountGateWorkSuppressed(services, guildId, memberUserId, workCreatedAt))
-        return;
-    const now = new Date();
-    const retentionUntil = new Date(now.getTime() + RETENTION_MS);
-    const reviewId = randomUUID();
-    const created = await services
-        .get(HELYX_SERVICE_NAMES.records)
-        .appendUnique({
-        moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
-        collection: "reviews",
-        uniqueBy: ["pending_key"],
-        values: {
-            review_id: reviewId,
-            pending_key: `pending:${guildId}:${memberUserId}`,
-            guild_id: guildId,
-            member_user_id: memberUserId,
-            join_generation: joinGeneration,
-            status: "pending",
-            delivery_status: "pending",
-            reason_code: reasonCode,
-            challenge_types_json: JSON.stringify(boundedChallengeTypes ?? state?.chain.map(({ type }) => type) ?? []),
-            failed_attempts: 0,
-            expired_attempts: 0,
-            revision: 1,
-            retention_until: retentionUntil,
-            created_at: now,
-            updated_at: now,
-        },
-    });
-    if (created.created)
-        await armRecordRetention(services.get(HELYX_SERVICE_NAMES.records), guildId, "reviews", "review_id", reviewId, retentionUntil);
-    const pending = created.created
-        ? { review_id: reviewId }
-        : await services
-            .get(HELYX_SERVICE_NAMES.records)
-            .findOne({
-            moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
-            collection: "reviews",
-            select: ["review_id", "delivery_status"],
-            where: { pending_key: `pending:${guildId}:${memberUserId}` },
-        });
-    if (pending && pending.delivery_status !== "sent")
-        await scheduleReviewDelivery(services, guildId, stringValue(pending.review_id), now);
-    await emitLog(services, guildId, {
-        eventId: "account-gate-review-created",
-        summary: "An Access Control check requires staff review.",
-        details: [
-            { label: "Member ID", value: memberUserId },
-            { label: "Reason", value: reasonCode },
-        ],
-    });
-}
-async function handleReviewDecision(context, decision) {
-    if (!context.serverId || !context.messageId) {
-        await replyError(context, "This review action is unavailable.");
-        return;
-    }
-    const authorised = await context.services
-        .get(HELYX_SERVICE_NAMES.resourceAuthorization)
-        .canUse({
-        guildId: context.serverId,
-        moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
-        permissionId: "account-gate.review",
-        actor: {
-            userId: context.userId,
-            roleIds: context.userRoleIds,
-            permissions: context.userPermissions ?? [],
-            isServerOwner: context.isServerOwner ?? false,
-            isAdministrator: context.isAdministrator,
-        },
-    });
-    if (!authorised) {
-        await replyError(context, "You are not authorised to manage Access Control reviews.");
-        return;
-    }
-    const records = context.services.get(HELYX_SERVICE_NAMES.records);
-    const row = await records.findOne({
-        moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
-        collection: "reviews",
-        select: accountGateRecords.reviews.readableFields,
-        where: {
-            guild_id: context.serverId,
-            review_message_id: context.messageId,
-        },
-    });
-    if (!row) {
-        await replyError(context, "This review record is no longer available.");
-        return;
-    }
-    if (row.status !== "pending") {
-        await context.reply({
-            ephemeral: true,
-            embed: {
-                title: "Review already handled",
-                description: `This review is already ${stringValue(row.status)}.`,
-                color: VIOLET,
-            },
-        });
-        return;
-    }
-    const memberUserId = stringValue(row.member_user_id);
-    if (await isAccountGateWorkSuppressed(context.services, context.serverId, memberUserId, dateValue(row.created_at) ?? new Date(0))) {
-        await replyError(context, "This review was removed by a privacy request. No Discord action was taken.");
-        return;
-    }
-    const revision = numberValue(row.revision);
-    const configuration = await requiredRuntimeConfiguration(context.services, context.serverId);
-    const reviewGeneration = numberValue(row.join_generation);
-    if (!(await reviewStillCurrent(context.services, context.serverId, memberUserId, reviewGeneration, configuration.verifiedRoleId))) {
-        await replyError(context, "This review belongs to an older join or is no longer actionable.");
-        return;
-    }
-    const claimStatus = `claim_${decision}`;
-    const claimExpiresAt = new Date(Date.now() + 2 * 60_000);
-    const claimed = await records.updateOne({
-        moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
-        collection: "reviews",
-        where: {
-            guild_id: context.serverId,
-            review_id: stringValue(row.review_id),
-        },
-        expected: { field: "revision", value: revision },
-        values: {
-            pending_key: `resolved:${stringValue(row.review_id)}`,
-            status: claimStatus,
-            claim_action: decision,
-            claim_expires_at: claimExpiresAt,
-            decided_by_user_id: context.userId,
-            decided_at: new Date(),
-            revision: revision + 1,
-            updated_at: new Date(),
-        },
-        schedule: {
-            taskKind: REVIEW_CLAIM_RECOVERY_TASK,
-            guildId: context.serverId,
-            idempotencyKey: `${context.serverId}:${stringValue(row.review_id)}:claim:${revision + 1}`,
-            payload: {
-                guildId: context.serverId,
-                reviewId: stringValue(row.review_id),
-            },
-            scheduledFor: claimExpiresAt,
-        },
-    });
-    if (!claimed.updated) {
-        await replyError(context, "This review changed in another session. Reload it before trying again.");
-        return;
-    }
-    const claimRevision = revision + 1;
-    if (!(await reviewStillCurrent(context.services, context.serverId, memberUserId, reviewGeneration, configuration.verifiedRoleId))) {
-        await finalizeReviewClaim(records, context.serverId, stringValue(row.review_id), claimRevision, "dismissed", { ...row, decided_by_user_id: context.userId, decided_at: new Date() }, false);
-        await replyError(context, "This review changed before the Discord action could begin.");
-        return;
-    }
-    if (await isAccountGateWorkSuppressed(context.services, context.serverId, memberUserId, dateValue(row.created_at) ?? new Date(0))) {
-        await finalizeReviewClaim(records, context.serverId, stringValue(row.review_id), claimRevision, "dismissed", { ...row, decided_by_user_id: context.userId, decided_at: new Date() }, false);
-        await replyError(context, "This review was removed by a privacy request. No Discord action was taken.");
-        return;
-    }
-    let status;
-    let completionRoleOutcome = null;
-    let kickResult = null;
-    if (decision === "approve") {
-        const transition = await applyRoleTransition({
-            guildId: context.serverId,
-            memberUserId,
-            verifiedRoleId: configuration.verifiedRoleId,
-            temporaryRoleIds: configuration.temporaryRoleIds,
-            resources: context.services.get(HELYX_SERVICE_NAMES.discordResources),
-            roles: context.services.get(HELYX_SERVICE_NAMES.memberRoles),
-            revalidate: () => reviewStillCurrent(context.services, context.serverId, memberUserId, reviewGeneration, configuration.verifiedRoleId, true),
-        });
-        if (transition.outcome === "stale") {
-            await finalizeReviewClaim(records, context.serverId, stringValue(row.review_id), claimRevision, "dismissed", { ...row, decided_by_user_id: context.userId, decided_at: new Date() }, false);
-            await replyError(context, "The member rejoined before approval could mutate roles; the old review was dismissed.");
-            return;
-        }
-        if (transition.outcome === "blocked") {
-            await replyError(context, "Helyx still cannot apply the access role. The claimed approval remains queued for safe recovery.");
-            return;
-        }
-        if (transition.outcome === "partial") {
-            await persistPartialTransition(context.services, context.serverId, memberUserId, configuration.verifiedRoleId, transition.pendingRoleIds, dateValue(row.created_at) ?? new Date(0));
-        }
-        if (!(await markSummaryPassed(records, context.serverId, memberUserId, new Date(), reviewGeneration))) {
-            await compensateVerifiedRoleAddition(context.services, context.serverId, memberUserId, configuration.verifiedRoleId, transition);
-            await finalizeReviewClaim(records, context.serverId, stringValue(row.review_id), claimRevision, "dismissed", { ...row, decided_by_user_id: context.userId, decided_at: new Date() }, false);
-            await replyError(context, "The member rejoined before approval completed; the old review was dismissed.");
-            return;
-        }
-        completionRoleOutcome = transition.outcome;
-        status = "approved";
-    }
-    else if (decision === "retry") {
-        const active = await context.services
-            .get(HELYX_SERVICE_NAMES.sessions)
-            .getFor(context.serverId, memberUserId, ACCOUNT_GATE_SESSION_PURPOSE);
-        if (active) {
-            await context.services
-                .get(HELYX_SERVICE_NAMES.sessions)
-                .delete(active.sessionId);
-        }
-        const reset = await resetSummaryForRetry(records, context.serverId, memberUserId, new Date(), reviewGeneration);
-        if (!reset) {
-            await finalizeReviewClaim(records, context.serverId, stringValue(row.review_id), claimRevision, "dismissed", { ...row, decided_by_user_id: context.userId, decided_at: new Date() }, false);
-            await replyError(context, "This review belongs to an older join and was not changed.");
-            return;
-        }
-        status = "retry";
-    }
-    else if (decision === "kick") {
-        const result = await context.services
-            .get(HELYX_SERVICE_NAMES.memberEnforcement)
-            .kick({
-            guildId: context.serverId,
-            memberUserId,
-            moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
-            reason: "Access Control staff review decision",
-            directMessage: {
-                embed: {
-                    title: "Removed after an Access Control review",
-                    description: neutralKickDirectMessage(`Discord server ${context.serverId}`),
-                    color: VIOLET,
-                },
-            },
-            revalidate: async () => {
-                const [enabled, current, session] = await Promise.all([
-                    context.services
-                        .get(HELYX_SERVICE_NAMES.installations)
-                        .isModuleEnabled(context.serverId, ACCOUNT_GATE_IDENTITY.moduleId),
-                    records.findOne({
-                        moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
-                        collection: "reviews",
-                        select: ["status", "revision"],
-                        where: {
-                            guild_id: context.serverId,
-                            review_id: stringValue(row.review_id),
-                        },
-                    }),
-                    context.services
-                        .get(HELYX_SERVICE_NAMES.sessions)
-                        .getFor(context.serverId, memberUserId, ACCOUNT_GATE_SESSION_PURPOSE),
-                ]);
-                return (enabled &&
-                    current?.status === claimStatus &&
-                    current.revision === claimRevision &&
-                    session === null &&
-                    (await reviewStillCurrent(context.services, context.serverId, memberUserId, reviewGeneration, configuration.verifiedRoleId)) &&
-                    !(await isAccountGateWorkSuppressed(context.services, context.serverId, memberUserId, dateValue(row.created_at) ?? new Date(0))));
-            },
-        });
-        if (!["kicked", "member_missing"].includes(result.outcome)) {
-            await replyError(context, `The member was not kicked (${result.outcome.replaceAll("_", " ")}). The claimed decision remains queued for safe recovery.`);
-            return;
-        }
-        kickResult = {
-            outcome: successfulKickOutcome(result.outcome),
-            directMessage: result.directMessage,
-        };
-        status = "kicked";
-    }
-    else {
-        status = "dismissed";
-    }
-    const now = new Date();
-    const updated = await records.updateOne({
-        moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
-        collection: "reviews",
-        where: {
-            guild_id: context.serverId,
-            review_id: stringValue(row.review_id),
-        },
-        expected: { field: "revision", value: claimRevision },
-        values: {
-            pending_key: `resolved:${stringValue(row.review_id)}`,
-            status,
-            claim_action: "",
-            claim_expires_at: new Date(0),
-            decided_by_user_id: context.userId,
-            decided_at: now,
-            revision: claimRevision + 1,
-            updated_at: now,
-        },
-        audit: {
-            guildId: context.serverId,
-            actorUserId: context.userId,
-            action: `account_gate.review_${status}`,
-            source: "discord",
-            correlationId: context.interactionId,
-            idempotencyKey: context.interactionId,
-            targetType: "account_gate_review",
-            targetId: stringValue(row.review_id),
-            metadata: { memberUserId, decision: status },
-        },
-    });
-    if (!updated.updated) {
-        await replyError(context, "This review changed in another session. Reload it before trying again.");
-        return;
-    }
-    if (status === "kicked" && kickResult)
-        await emitAccountGateKickLog(context.services, context.serverId, {
-            memberUserId,
-            ...kickResult,
-            source: "Staff review",
-            idempotencyKey: `account-gate-kick:review:${stringValue(row.review_id)}`,
-        });
-    if (status === "approved" && completionRoleOutcome)
-        await emitAccountGateCompletedLog(context.services, context.serverId, {
-            memberUserId,
-            roleOutcome: completionRoleOutcome,
-            idempotencyKey: `account-gate-completed:review:${stringValue(row.review_id)}`,
-        });
-    if (context.channelId) {
-        await context.editChannelMessage(context.channelId, context.messageId, {
-            allowedUserMentionIds: [],
-            componentsV2: {
-                accentColor: VIOLET,
-                text: [
-                    { content: "## Access Control review resolved" },
-                    { content: `Member ID: ${memberUserId}`, markdown: false },
-                    { content: `Decision: ${status}`, markdown: false },
-                ],
-            },
-        });
-    }
-    await context.reply({
-        ephemeral: true,
-        embed: {
-            title: "Review updated",
-            description: `The review is now ${status}.`,
-            color: GREEN,
-        },
-    });
-}
-async function reviewStillCurrent(services, guildId, memberUserId, joinGeneration, verifiedRoleId, allowVerifiedRole = false) {
-    const [enabled, summary, members] = await Promise.all([
-        services
-            .get(HELYX_SERVICE_NAMES.installations)
-            .isModuleEnabled(guildId, ACCOUNT_GATE_IDENTITY.moduleId),
-        loadMemberSummary(services.get(HELYX_SERVICE_NAMES.records), guildId, memberUserId),
-        services
-            .get(HELYX_SERVICE_NAMES.discordResources)
-            .resolveMemberSnapshots({ guildId, userIds: [memberUserId] }),
-    ]);
-    const member = members[0];
-    return (enabled &&
-        summary !== null &&
-        numberValue(summary.join_generation) === joinGeneration &&
-        ["review", "failed", "finalizing"].includes(stringValue(summary.last_decision)) &&
-        member?.exists === true &&
-        !member.isBot &&
-        (allowVerifiedRole || !member.roleIds.includes(verifiedRoleId)));
-}
-async function terminalPassStillCurrent(services, guildId, memberUserId, joinGeneration, workCreatedAt) {
-    const [enabled, summary, members, suppressed] = await Promise.all([
-        services
-            .get(HELYX_SERVICE_NAMES.installations)
-            .isModuleEnabled(guildId, ACCOUNT_GATE_IDENTITY.moduleId),
-        loadMemberSummary(services.get(HELYX_SERVICE_NAMES.records), guildId, memberUserId),
-        services
-            .get(HELYX_SERVICE_NAMES.discordResources)
-            .resolveMemberSnapshots({ guildId, userIds: [memberUserId] }),
-        isAccountGateWorkSuppressed(services, guildId, memberUserId, workCreatedAt),
-    ]);
-    const member = members[0];
-    return (enabled &&
-        !suppressed &&
-        summary !== null &&
-        numberValue(summary.join_generation) === joinGeneration &&
-        summary.last_decision === "finalizing" &&
-        member?.exists === true &&
-        !member.isBot);
-}
-async function compensateVerifiedRoleAddition(services, guildId, memberUserId, verifiedRoleId, transition) {
-    if (!transition.accessRoleAdded)
-        return;
-    await services
-        .get(HELYX_SERVICE_NAMES.memberRoles)
-        .removeApprovedRole({
-        guildId,
-        memberUserId,
-        roleId: verifiedRoleId,
-        moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
-        reason: "Access Control stale-generation compensation",
-    });
-}
-async function roleRetryStillCurrent(services, guildId, memberUserId, workCreatedAt) {
-    const [enabled, summary, members, suppressed] = await Promise.all([
-        services
-            .get(HELYX_SERVICE_NAMES.installations)
-            .isModuleEnabled(guildId, ACCOUNT_GATE_IDENTITY.moduleId),
-        loadMemberSummary(services.get(HELYX_SERVICE_NAMES.records), guildId, memberUserId),
-        services
-            .get(HELYX_SERVICE_NAMES.discordResources)
-            .resolveMemberSnapshots({ guildId, userIds: [memberUserId] }),
-        isAccountGateWorkSuppressed(services, guildId, memberUserId, workCreatedAt),
-    ]);
-    return (enabled &&
-        !suppressed &&
-        summary?.last_decision === "passed" &&
-        members[0]?.exists === true &&
-        !members[0].isBot);
-}
-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;
-}
-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;
-    }
-}
-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,
-    }));
-}
-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));
-}
-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;
-}
-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;
-}
-function secureRandom(services) {
-    const random = services.get(HELYX_SERVICE_NAMES.secureRandom);
-    return {
-        integer(maximumExclusive, operationContext) {
-            return random.boundedInteger({ maximumExclusive, operationContext })
-                .value;
-        },
-    };
-}
-async function replyError(context, description) {
-    await context.reply({
-        ephemeral: true,
-        componentsV2: {
-            accentColor: RED,
-            text: [
-                { content: "## Account gate unavailable" },
-                { content: description, markdown: false },
-            ],
-        },
-    });
-}
-function stringValue(value) {
-    if (typeof value !== "string")
-        throw new Error("Account Gate record is invalid");
-    return value;
-}
-function numberValue(value) {
-    if (typeof value !== "number" || !Number.isSafeInteger(value))
-        throw new Error("Account Gate record is invalid");
-    return value;
-}
-function dateValue(value) {
-    return value instanceof Date ? value : null;
-}
-function canonicalEmojiKey(value) {
-    if (/^(?:custom|unicode):/u.test(value))
-        return value.normalize("NFKC");
-    const custom = /^([A-Za-z0-9_]{2,32}):(\d{17,20})$/u.exec(value);
-    return custom ? `custom:${custom[2]}` : `unicode:${value.normalize("NFKC")}`;
-}
-export function boundComponentId(prefix, binding) {
-    return `${prefix}${binding.sessionId}:${String(binding.version)}:${binding.step}${binding.value === undefined ? "" : `:${binding.value}`}`;
-}
-export function parseComponentBinding(customId, prefix) {
-    if (!customId?.startsWith(prefix))
-        return null;
-    const [sessionId, version, step, value] = customId
-        .slice(prefix.length)
-        .split(":");
-    if (!sessionId ||
-        !version ||
-        !/^\d+$/u.test(version) ||
-        !step ||
-        !/^\d+$/u.test(step))
-        return null;
-    return {
-        sessionId,
-        version: BigInt(version),
-        step: Number(step),
-        ...(value === undefined ? {} : { value }),
-    };
-}
-export function staticResumeMessage(guildId, gateChannelId) {
-    return {
-        embed: {
-            title: "Continue your Access Control check",
-            description: `Your existing check for Discord server ${guildId} is ready to continue. Return to <#${gateChannelId}> and press **Start check** to resume it.`,
-            color: VIOLET,
-        },
-        allowedUserMentionIds: [],
-    };
-}
-async function loadMemberSummary(records, guildId, memberUserId) {
-    return records.findOne({
-        moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
-        collection: "member_summaries",
-        select: accountGateRecords.member_summaries.readableFields,
-        where: { guild_id: guildId, member_user_id: memberUserId },
-    });
-}
-async function isCurrentPendingMember(services, guildId, memberUserId, verifiedRoleId) {
-    const [summary, members] = await Promise.all([
-        loadMemberSummary(services.get(HELYX_SERVICE_NAMES.records), guildId, memberUserId),
-        services
-            .get(HELYX_SERVICE_NAMES.discordResources)
-            .resolveMemberSnapshots({ guildId, userIds: [memberUserId] }),
-    ]);
-    const member = members[0];
-    return (summary?.last_decision === "pending" &&
-        member?.exists === true &&
-        !member.isBot &&
-        !member.roleIds.includes(verifiedRoleId));
-}
-function summaryValues(input) {
-    return {
-        summary_id: typeof input.previous?.summary_id === "string"
-            ? input.previous.summary_id
-            : randomUUID(),
-        guild_id: input.guildId,
-        member_user_id: input.memberUserId,
-        previous_success_at: input.previousSuccessAt ??
-            dateValue(input.previous?.previous_success_at) ??
-            new Date(0),
-        failure_count: input.failureCount,
-        lockout_until: input.lockoutUntil,
-        rejoin_count: input.rejoinCount,
-        join_generation: input.joinGeneration,
-        account_created_at: input.accountCreatedAt,
-        joined_at: input.joinedAt,
-        deadline_at: input.deadlineAt,
-        pending_reason: input.pendingReason,
-        last_failure_terminal_id: input.lastFailureTerminalId ??
-            (typeof input.previous?.last_failure_terminal_id === "string"
-                ? input.previous.last_failure_terminal_id
-                : ""),
-        left_at: input.leftAt ?? new Date(0),
-        last_decision: input.lastDecision,
-        revision: input.previous ? numberValue(input.previous.revision) + 1 : 1,
-        retention_until: new Date(input.now.getTime() + RETENTION_MS),
-        created_at: dateValue(input.previous?.created_at) ?? input.now,
-        updated_at: input.now,
-    };
-}
-function summaryUpdateValues(values) {
-    return {
-        previous_success_at: values.previous_success_at,
-        failure_count: values.failure_count,
-        lockout_until: values.lockout_until,
-        rejoin_count: values.rejoin_count,
-        join_generation: values.join_generation,
-        account_created_at: values.account_created_at,
-        joined_at: values.joined_at,
-        deadline_at: values.deadline_at,
-        pending_reason: values.pending_reason,
-        last_failure_terminal_id: values.last_failure_terminal_id,
-        left_at: values.left_at,
-        last_decision: values.last_decision,
-        revision: values.revision,
-        retention_until: values.retention_until,
-        updated_at: values.updated_at,
-    };
-}
-async function setSummaryDecision(records, guildId, memberUserId, generation, decision, expectedDecision = "pending") {
-    const row = await loadMemberSummary(records, guildId, memberUserId);
-    if (!row ||
-        numberValue(row.join_generation) !== generation ||
-        row.last_decision !== expectedDecision)
-        return false;
-    return (await records.updateOne({
-        moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
-        collection: "member_summaries",
-        where: { guild_id: guildId, member_user_id: memberUserId },
-        expected: { field: "revision", value: numberValue(row.revision) },
-        values: {
-            last_decision: decision,
-            revision: numberValue(row.revision) + 1,
-            updated_at: new Date(),
-        },
-    })).updated;
-}
-async function recordFailureSummary(records, guildId, memberUserId, now, cooldownSeconds, attemptLimit, terminalId, expectedGeneration) {
-    for (let retry = 0; retry < 4; retry += 1) {
-        const previous = await loadMemberSummary(records, guildId, memberUserId);
-        if (!previous ||
-            numberValue(previous.join_generation) !== expectedGeneration)
-            return null;
-        if (previous?.last_failure_terminal_id === terminalId)
-            return numberValue(previous.failure_count);
-        const failureCount = (previous ? numberValue(previous.failure_count) : 0) + 1;
-        const requestedLockout = new Date(now.getTime() + cooldownSeconds * 1_000);
-        const existingLockout = dateValue(previous?.lockout_until);
-        const lockoutUntil = existingLockout && existingLockout.getTime() > requestedLockout.getTime()
-            ? existingLockout
-            : requestedLockout;
-        const values = summaryValues({
-            guildId,
-            memberUserId,
-            now,
-            previous,
-            failureCount,
-            lockoutUntil,
-            rejoinCount: previous ? numberValue(previous.rejoin_count) : 0,
-            joinGeneration: expectedGeneration,
-            accountCreatedAt: dateValue(previous?.account_created_at) ?? now,
-            joinedAt: dateValue(previous?.joined_at) ?? now,
-            deadlineAt: dateValue(previous?.deadline_at) ?? now,
-            pendingReason: previous?.pending_reason === "account_too_new"
-                ? "account_too_new"
-                : "none",
-            lastDecision: failureCount >= attemptLimit ? "failed" : "pending",
-            lastFailureTerminalId: terminalId,
-        });
-        const result = await records.updateOne({
-            moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
-            collection: "member_summaries",
-            where: { guild_id: guildId, member_user_id: memberUserId },
-            expected: {
-                field: "revision",
-                value: numberValue(previous.revision),
-            },
-            values: summaryUpdateValues(values),
-        });
-        if (result.updated)
-            return failureCount;
-    }
-    const current = await loadMemberSummary(records, guildId, memberUserId);
-    return current &&
-        numberValue(current.join_generation) === expectedGeneration &&
-        current.last_failure_terminal_id === terminalId
-        ? numberValue(current.failure_count)
-        : null;
-}
-async function markSummaryPassed(records, guildId, memberUserId, now, expectedGeneration) {
-    const previous = await loadMemberSummary(records, guildId, memberUserId);
-    if (!previous || numberValue(previous.join_generation) !== expectedGeneration)
-        return false;
-    const values = summaryValues({
-        guildId,
-        memberUserId,
-        now,
-        previous,
-        previousSuccessAt: now,
-        failureCount: 0,
-        lockoutUntil: new Date(0),
-        rejoinCount: previous ? numberValue(previous.rejoin_count) : 0,
-        joinGeneration: expectedGeneration,
-        accountCreatedAt: dateValue(previous?.account_created_at) ?? now,
-        joinedAt: dateValue(previous?.joined_at) ?? now,
-        deadlineAt: dateValue(previous?.deadline_at) ?? now,
-        pendingReason: "none",
-        lastDecision: "passed",
-    });
-    return (await records.updateOne({
-        moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
-        collection: "member_summaries",
-        where: { guild_id: guildId, member_user_id: memberUserId },
-        expected: { field: "revision", value: numberValue(previous.revision) },
-        values: summaryUpdateValues(values),
-    })).updated;
-}
-async function resetSummaryForRetry(records, guildId, memberUserId, now, expectedGeneration) {
-    const previous = await loadMemberSummary(records, guildId, memberUserId);
-    if (!previous || numberValue(previous.join_generation) !== expectedGeneration)
-        return false;
-    const values = summaryValues({
-        guildId,
-        memberUserId,
-        now,
-        previous,
-        failureCount: 0,
-        lockoutUntil: new Date(0),
-        rejoinCount: previous ? numberValue(previous.rejoin_count) : 0,
-        joinGeneration: expectedGeneration,
-        accountCreatedAt: dateValue(previous?.account_created_at) ?? now,
-        joinedAt: dateValue(previous?.joined_at) ?? now,
-        deadlineAt: dateValue(previous?.deadline_at) ?? now,
-        pendingReason: previous?.pending_reason === "account_too_new"
-            ? "account_too_new"
-            : "none",
-        lastDecision: "pending",
-    });
-    return (await records.updateOne({
-        moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
-        collection: "member_summaries",
-        where: { guild_id: guildId, member_user_id: memberUserId },
-        expected: { field: "revision", value: numberValue(previous.revision) },
-        values: summaryUpdateValues(values),
-    })).updated;
-}
-async function scheduleJoinDeadline(services, guildId, memberUserId, generation, deadlineAt) {
-    await services
-        .get(HELYX_SERVICE_NAMES.scheduledTasks)
-        .schedule({
-        moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
-        taskKind: JOIN_DEADLINE_TASK,
-        guildId,
-        idempotencyKey: `${guildId}:${memberUserId}:join:${generation}`,
-        payload: {
-            guildId,
-            memberUserId,
-        },
-        scheduledFor: deadlineAt,
-    });
-}
-async function scheduleSessionExpiry(services, input) {
-    await services
-        .get(HELYX_SERVICE_NAMES.scheduledTasks)
-        .schedule({
-        moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
-        taskKind: SESSION_EXPIRY_TASK,
-        guildId: input.guildId,
-        idempotencyKey: `${input.sessionId}:expiry`,
-        payload: {
-            guildId: input.guildId,
-            userId: input.userId,
-            sessionId: input.sessionId,
-        },
-        scheduledFor: input.expiredAt,
-    });
-}
-async function scheduleReviewDelivery(services, guildId, reviewId, scheduledFor) {
-    await services
-        .get(HELYX_SERVICE_NAMES.scheduledTasks)
-        .schedule({
-        moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
-        taskKind: REVIEW_DELIVERY_TASK,
-        guildId,
-        idempotencyKey: `${guildId}:${reviewId}:delivery`,
-        payload: { guildId, reviewId },
-        scheduledFor,
-    });
-}
-async function scheduleTerminalFinalization(services, guildId, finalizationId, scheduledFor) {
-    await services
-        .get(HELYX_SERVICE_NAMES.scheduledTasks)
-        .schedule({
-        moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
-        taskKind: TERMINAL_FINALIZATION_TASK,
-        guildId,
-        idempotencyKey: `${guildId}:${finalizationId}:terminal`,
-        payload: { guildId, finalizationId },
-        scheduledFor,
-    });
-}
-async function armRecordRetention(records, guildId, collection, idField, id, scheduledFor) {
-    await records.updateOne({
-        moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
-        collection,
-        where: { [idField]: id },
-        expected: { field: idField, value: id },
-        values: { retention_until: scheduledFor },
-        retention: [
-            {
-                collection,
-                where: { guild_id: guildId, [idField]: id },
-                scheduledFor,
-                idempotencyKey: `account-gate-retention:${collection}:${id}`,
-                audit: {
-                    action: `account_gate.${collection}_retention`,
-                    targetType: `account_gate_${collection}`,
-                    targetId: id,
-                },
-            },
-        ],
-    });
-}
+export { hasPreviousSuccess, isAccountTooYoung } from "./member-lifecycle.js";
+export { recordAccountGateAttempt, resumeRevokedMember, } from "./member-restart.js";
+export { ensureTerminalFinalization };
+export { validateAccountGateSetup };
+export { boundComponentId, parseComponentBinding, staticResumeMessage, } from "./runtime-support.js";
 //# sourceMappingURL=index.js.map