@helyx/module-account-gate 1.0.15 → 1.1.3

package/dist/records.js

@@ -11,6 +11,7 @@ export const accountGateRecords = {
             password_hash: { type: "string", optional: true },
             password_ignore_case: { type: "boolean", optional: true },
             password_trim_whitespace: { type: "boolean", optional: true },
+            status: { type: "string" },
             revision: { type: "number" },
             created_at: { type: "date" },
             updated_at: { type: "date" },
@@ -26,6 +27,7 @@ export const accountGateRecords = {
             "password_hash",
             "password_ignore_case",
             "password_trim_whitespace",
+            "status",
             "revision",
             "created_at",
             "updated_at",
@@ -38,11 +40,40 @@ export const accountGateRecords = {
             "password_hash",
             "password_ignore_case",
             "password_trim_whitespace",
+            "status",
             "revision",
             "updated_at",
         ],
         orderKeys: [["guild_id", "created_at", "panel_id"]],
     },
+    panel_message_cleanup: {
+        table: "account_gate_panel_message_cleanup",
+        fields: {
+            cleanup_id: { type: "string" },
+            guild_id: { type: "string" },
+            panel_id: { type: "string" },
+            channel_id: { type: "string" },
+            message_id: { type: "string" },
+            attempts: { type: "number" },
+            next_attempt_at: { type: "date" },
+            completed_at: { type: "date", optional: true },
+            created_at: { type: "date" },
+        },
+        uniqueKeys: [["cleanup_id"], ["guild_id", "channel_id", "message_id"]],
+        readableFields: [
+            "cleanup_id",
+            "guild_id",
+            "panel_id",
+            "channel_id",
+            "message_id",
+            "attempts",
+            "next_attempt_at",
+            "completed_at",
+            "created_at",
+        ],
+        writableFields: ["attempts", "next_attempt_at", "completed_at"],
+        orderKeys: [["next_attempt_at", "cleanup_id"]],
+    },
     questions: {
         table: "account_gate_questions",
         fields: {

package/dist/review-decisions.d.ts

@@ -0,0 +1,3 @@
+import type { ModalCapableInteractionContext } from "./runtime-dependencies.js";
+export declare function handleReviewDecision(context: ModalCapableInteractionContext, decision: "approve" | "retry" | "kick" | "dismiss"): Promise<void>;
+//# sourceMappingURL=review-decisions.d.ts.map

package/dist/review-decisions.js

@@ -0,0 +1,274 @@
+import { HELYX_SERVICE_NAMES, ACCOUNT_GATE_IDENTITY, ACCOUNT_GATE_SESSION_PURPOSE, applyRoleTransition, neutralKickDirectMessage, accountGateRecords, isAccountGateWorkSuppressed, parseAccountGateSessionState, emitAccountGateCompletedLog, emitAccountGateKickLog, successfulKickOutcome, VIOLET, REVIEW_CLAIM_RECOVERY_TASK, } from "./runtime-dependencies.js";
+import { markSummaryPassed, resetSummaryForRetry } from "./member-summary.js";
+import { finalizeReviewClaim } from "./review-store.js";
+import { completeReviewInteraction } from "./review-presentation.js";
+import { persistPartialTransition } from "./role-recovery.js";
+import { dateValue, numberValue, replyError, stringValue, } from "./runtime-support.js";
+import { requiredRuntimeConfiguration } from "./setup-presentation.js";
+import { compensateVerifiedRoleAddition, reviewStillCurrent, } from "./workflow-fences.js";
+export 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 sessions = context.services.get(HELYX_SERVICE_NAMES.sessions);
+        const active = await sessions.getFor(context.serverId, memberUserId, ACCOUNT_GATE_SESSION_PURPOSE);
+        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;
+        }
+        if (active) {
+            try {
+                if (parseAccountGateSessionState(active.state).joinGeneration ===
+                    reviewGeneration)
+                    await sessions.delete(active.sessionId).catch(() => undefined);
+            }
+            catch {
+                await sessions.delete(active.sessionId).catch(() => undefined);
+            }
+        }
+        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)}`,
+        });
+    await completeReviewInteraction(context, context.messageId, memberUserId, status);
+}
+//# sourceMappingURL=review-decisions.js.map

package/dist/review-delivery.d.ts

@@ -0,0 +1,34 @@
+import type { RuntimeContext, ScheduledTaskPayload } from "./runtime-dependencies.js";
+export declare function validateReviewDeliveryPayload(input: unknown): ScheduledTaskPayload;
+export declare function deliverReview(context: RuntimeContext, task: {
+    payload: ScheduledTaskPayload;
+}): Promise<{
+    outcome: "completed";
+    safeCode?: never;
+    delayMs?: never;
+} | {
+    outcome: "requires_review";
+    safeCode: string;
+    delayMs?: never;
+} | {
+    outcome: "retry";
+    delayMs: number;
+    safeCode: string;
+}>;
+export declare function validateReviewClaimRecoveryPayload(input: unknown): ScheduledTaskPayload;
+export declare function recoverReviewClaim(context: RuntimeContext, task: {
+    payload: ScheduledTaskPayload;
+}): Promise<{
+    outcome: "completed";
+    delayMs?: never;
+    safeCode?: never;
+} | {
+    outcome: "deferred";
+    delayMs: number;
+    safeCode: string;
+} | {
+    outcome: "retry";
+    delayMs: number;
+    safeCode: string;
+}>;
+//# sourceMappingURL=review-delivery.d.ts.map

package/dist/review-delivery.js

@@ -0,0 +1,252 @@
+import { HELYX_SERVICE_NAMES, ACCOUNT_GATE_IDENTITY, applyRoleTransition, neutralKickDirectMessage, accountGateRecords, isAccountGateWorkSuppressed, emitAccountGateCompletedLog, emitAccountGateKickLog, successfulKickOutcome, VIOLET, } from "./runtime-dependencies.js";
+import { loadMemberSummary, markSummaryPassed, resetSummaryForRetry, } from "./member-summary.js";
+import { finalizeReviewClaim } from "./review-store.js";
+import { compensateVerifiedRoleAddition, reviewStillCurrent, } from "./workflow-fences.js";
+import { persistPartialTransition } from "./role-recovery.js";
+import { dateValue, numberValue, stringValue } from "./runtime-support.js";
+import { getConfiguration, requiredRuntimeConfiguration, reviewMessage, } from "./setup-presentation.js";
+export 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 };
+}
+export 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,
+            idempotencyKey: `account-gate-review:${guildId}:${reviewId}`,
+            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",
+        };
+    }
+}
+export 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,
+    };
+}
+export 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" };
+}
+//# sourceMappingURL=review-delivery.js.map

package/dist/review-presentation.d.ts

@@ -0,0 +1,3 @@
+import type { ModalCapableInteractionContext } from "./runtime-dependencies.js";
+export declare function completeReviewInteraction(context: ModalCapableInteractionContext, messageId: string, memberUserId: string, status: "approved" | "retry" | "kicked" | "dismissed"): Promise<void>;
+//# sourceMappingURL=review-presentation.d.ts.map

package/dist/review-presentation.js

@@ -0,0 +1,28 @@
+import { GREEN, VIOLET } from "./runtime-dependencies.js";
+export async function completeReviewInteraction(context, messageId, memberUserId, status) {
+    if (context.channelId)
+        await context
+            .editChannelMessage(context.channelId, messageId, {
+            allowedUserMentionIds: [],
+            componentsV2: {
+                accentColor: VIOLET,
+                text: [
+                    { content: "## Access Control review resolved" },
+                    { content: `Member ID: ${memberUserId}`, markdown: false },
+                    { content: `Decision: ${status}`, markdown: false },
+                ],
+            },
+        })
+            .catch(() => undefined);
+    await context
+        .reply({
+        ephemeral: true,
+        embed: {
+            title: "Review updated",
+            description: `The review is now ${status}.`,
+            color: GREEN,
+        },
+    })
+        .catch(() => undefined);
+}
+//# sourceMappingURL=review-presentation.js.map

package/dist/review-store.d.ts

@@ -0,0 +1,4 @@
+import type { ModuleRecordService, ServiceAccess, AccountGateSessionState } from "./runtime-dependencies.js";
+export declare function createReview(services: ServiceAccess, guildId: string, memberUserId: string, reasonCode: string, state: AccountGateSessionState | null, expectedJoinGeneration?: number, boundedChallengeTypes?: readonly string[], workCreatedAtOverride?: Date): Promise<void>;
+export declare function finalizeReviewClaim(records: ModuleRecordService, guildId: string, reviewId: string, claimRevision: number, status: "approved" | "retry" | "kicked" | "dismissed", row: Readonly<Record<string, unknown>>, expiredOnly?: boolean): Promise<boolean>;
+//# sourceMappingURL=review-store.d.ts.map