@helyx/module-account-gate 1.0.15 → 1.1.3

package/dist/member-lifecycle.d.ts

@@ -0,0 +1,21 @@
+import type { CommandInteractionContext, ServiceAccess } from "./runtime-dependencies.js";
+export declare function handleGuildMemberAdd(context: {
+    serverId: string;
+    serverName: string;
+    memberId: string;
+    memberIsBot: boolean;
+    accountCreatedAt: Date;
+    joinedAt: Date;
+    services: ServiceAccess;
+}): Promise<void>;
+export declare function handleGuildMemberRemove(context: {
+    serverId: string;
+    memberId: string;
+    memberIsBot: boolean;
+    joinedAt: Date | null;
+    services: ServiceAccess;
+}): Promise<void>;
+export declare function isAccountTooYoung(accountCreatedAt: Date, joinedAt: Date, minimumAccountAgeDays: number): boolean;
+export declare function hasPreviousSuccess(value: unknown): boolean;
+export declare function resetOwnAccess(context: CommandInteractionContext): Promise<void>;
+//# sourceMappingURL=member-lifecycle.d.ts.map

package/dist/member-lifecycle.js

@@ -0,0 +1,305 @@
+import { HELYX_SERVICE_NAMES, ACCOUNT_GATE_IDENTITY, ACCOUNT_GATE_SESSION_PURPOSE, isAccountGateWorkSuppressed, parseAccountGateSessionState, VIOLET, JOIN_DEADLINE_TASK, LEAVE_RETENTION_TASK, RETENTION_MS, } from "./runtime-dependencies.js";
+import { loadMemberSummary, setSummaryDecision, summaryUpdateValues, summaryValues, } from "./member-summary.js";
+import { createReview } from "./review-store.js";
+import { dateValue, numberValue, replyError, stringValue, } from "./runtime-support.js";
+import { getConfiguration, requiredRuntimeConfiguration, } from "./setup-presentation.js";
+import { scheduleJoinDeadline } from "./task-scheduling.js";
+export 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 sameJoin = dateValue(previous?.joined_at)?.getTime() === context.joinedAt.getTime() &&
+        (dateValue(previous?.left_at)?.getTime() ?? 0) === 0;
+    const generation = sameJoin
+        ? numberValue(previous?.join_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 = sameJoin
+        ? { updated: true }
+        : 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);
+}
+export async function handleGuildMemberRemove(context) {
+    if (context.memberIsBot)
+        return;
+    const records = context.services.get(HELYX_SERVICE_NAMES.records);
+    const row = await loadMemberSummary(records, context.serverId, context.memberId);
+    if (!row)
+        return;
+    if (context.joinedAt &&
+        dateValue(row.joined_at)?.getTime() !== context.joinedAt.getTime())
+        return;
+    const [member] = await context.services
+        .get(HELYX_SERVICE_NAMES.discordResources)
+        .resolveMemberSnapshots({
+        guildId: context.serverId,
+        userIds: [context.memberId],
+    });
+    if (member?.exists)
+        return;
+    const now = new Date();
+    const retentionUntil = new Date(now.getTime() + RETENTION_MS);
+    const generation = numberValue(row.join_generation);
+    const stored = 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,
+        },
+    });
+    if (!stored.updated)
+        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)
+        return;
+    try {
+        if (parseAccountGateSessionState(active.state).joinGeneration !== generation)
+            return;
+    }
+    catch {
+        // Invalid module-owned state is safe to discard after the fenced leave.
+    }
+    await sessions.delete(active.sessionId).catch(() => undefined);
+}
+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;
+}
+export 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);
+    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),
+        schedule: {
+            taskKind: JOIN_DEADLINE_TASK,
+            guildId: context.serverId,
+            idempotencyKey: `${context.serverId}:${context.userId}:join:${generation}`,
+            payload: {
+                guildId: context.serverId,
+                memberUserId: context.userId,
+            },
+            scheduledFor: deadlineAt,
+        },
+        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;
+    }
+    if (activeSession)
+        await sessions.delete(activeSession.sessionId).catch(() => undefined);
+    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,
+                },
+            ],
+        },
+    });
+}
+//# sourceMappingURL=member-lifecycle.js.map

package/dist/member-resource.js

@@ -1,11 +1,11 @@
 import { createHash } from "node:crypto";
 import { DashboardActionValidationError, HELYX_SERVICE_NAMES, } from "@helyx/sdk";
 import { parseAccountGateConfiguration } from "./configuration.js";
-import { ACCOUNT_GATE_IDENTITY, ACCOUNT_GATE_SESSION_PURPOSE, } from "./contracts.js";
+import { ACCOUNT_GATE_IDENTITY } from "./contracts.js";
+import { revokeMemberAccess } from "./member-revocation.js";
 import { accountGateRecords } from "./records.js";
 const PAGE_SIZE = 10;
 const SEARCH_RESULT_LIMIT = 25;
-const RETENTION_MS = 90 * 24 * 60 * 60 * 1_000;
 const DISCORD_SNOWFLAKE = /^\d{17,20}$/u;
 export const accountGateMemberResource = {
     id: "members",
@@ -83,79 +83,19 @@ export const accountGateMemberResource = {
         if (!configurationRecord)
             throw new DashboardActionValidationError("Save the Access Control settings before revoking access.");
         const configuration = parseAccountGateConfiguration(configurationRecord.value);
-        const roles = context.services.get(HELYX_SERVICE_NAMES.memberRoles);
-        try {
-            await roles.removeApprovedRole({
-                guildId: context.guildId,
-                memberUserId: input.resourceId,
-                roleId: configuration.verifiedRoleId,
-                moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
-                reason: "Access Control dashboard access revocation",
-            });
-        }
-        catch {
-            throw new DashboardActionValidationError("Discord did not remove the configured access role. Check the bot role hierarchy and try again.");
-        }
-        let temporaryRolesRestored = true;
-        try {
-            await roles.reconcileApprovedRoles({
-                guildId: context.guildId,
-                memberUserId: input.resourceId,
-                allowedRoleIds: [
-                    configuration.verifiedRoleId,
-                    ...configuration.temporaryRoleIds,
-                ],
-                desiredRoleIds: configuration.temporaryRoleIds,
-                moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
-                reason: "Access Control dashboard access revocation",
-            });
-        }
-        catch {
-            temporaryRolesRestored = false;
-        }
-        const now = new Date();
-        const updated = await memberRecords(context).updateOne({
-            moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
-            collection: "member_summaries",
-            where: {
-                guild_id: context.guildId,
-                member_user_id: input.resourceId,
-            },
-            expected: { field: "revision", value: revision },
-            requireModuleEnabledForGuildId: context.guildId,
-            values: {
-                join_generation: numberValue(row.join_generation) + 1,
-                deadline_at: now,
-                pending_reason: "none",
-                left_at: new Date(0),
-                last_decision: "revoked",
-                revision: revision + 1,
-                retention_until: new Date(now.getTime() + RETENTION_MS),
-                updated_at: now,
-            },
-            audit: {
-                guildId: context.guildId,
-                actorUserId: context.actor.userId,
-                action: "account_gate.access_revoked",
-                source: "dashboard",
-                correlationId: context.correlationId,
-                idempotencyKey: context.correlationId,
-                targetType: "account_gate_member",
-                targetId: input.resourceId,
-                metadata: { temporaryRolesRestored },
-            },
-        });
-        if (!updated.updated)
-            throw new DashboardActionValidationError("Discord access was removed, but the member state changed concurrently. Refresh before taking another action.");
-        const sessions = context.services.get(HELYX_SERVICE_NAMES.sessions);
-        const session = await sessions.getFor(context.guildId, input.resourceId, ACCOUNT_GATE_SESSION_PURPOSE);
-        if (session)
-            await sessions.delete(session.sessionId);
-        const refreshed = await loadMemberSummary(context, input.resourceId);
-        if (!refreshed)
-            throw new Error("Revoked Access Control member disappeared");
         const identities = await resolveLiveIdentities(context, [input.resourceId]);
-        return memberDetail(refreshed, identities.get(input.resourceId));
+        const revoked = await revokeMemberAccess({
+            services: context.services,
+            guildId: context.guildId,
+            memberUserId: input.resourceId,
+            actorUserId: context.actor.userId,
+            correlationId: context.correlationId,
+            current: row,
+            configuration,
+        });
+        if (!revoked)
+            throw new DashboardActionValidationError("This member changed in another session. Refresh and try again.");
+        return memberDetail(revoked, identities.get(input.resourceId));
     },
 };
 async function searchKnownMembers(context, search, cursor) {

package/dist/member-restart.d.ts

@@ -0,0 +1,4 @@
+import type { ModuleRecordService, ModuleRecordValue, ServiceAccess, AccountGateSessionState, Challenge, AccountGateConfiguration } from "./runtime-dependencies.js";
+export declare function resumeRevokedMember(services: ServiceAccess, guildId: string, memberUserId: string, summary: Readonly<Record<string, ModuleRecordValue>>, configuration: AccountGateConfiguration, correlationId: string, now?: Date): Promise<Readonly<Record<string, ModuleRecordValue>> | null>;
+export declare function recordAccountGateAttempt(records: ModuleRecordService, guildId: string, memberUserId: string, sessionId: string, state: AccountGateSessionState, challengeType: Challenge["type"], outcome: "passed" | "failed", now?: Date): Promise<void>;
+//# sourceMappingURL=member-restart.d.ts.map

package/dist/member-restart.js

@@ -0,0 +1,76 @@
+import { randomUUID, HELYX_SERVICE_NAMES, ACCOUNT_GATE_IDENTITY, JOIN_DEADLINE_TASK, RETENTION_MS, } from "./runtime-dependencies.js";
+import { loadMemberSummary } from "./member-summary.js";
+import { numberValue } from "./runtime-support.js";
+import { armRecordRetention } from "./task-scheduling.js";
+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,
+        },
+        schedule: {
+            taskKind: JOIN_DEADLINE_TASK,
+            guildId,
+            idempotencyKey: `${guildId}:${memberUserId}:join:${generation}`,
+            payload: { guildId, memberUserId },
+            scheduledFor: deadlineAt,
+        },
+        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;
+    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);
+}
+//# sourceMappingURL=member-restart.js.map

package/dist/member-revocation.d.ts

@@ -0,0 +1,21 @@
+import type { RuntimeContext, ScheduledTaskPayload, ServiceAccess, AccountGateConfiguration } from "./runtime-dependencies.js";
+export declare function revokeMemberAccess(input: {
+    services: ServiceAccess;
+    guildId: string;
+    memberUserId: string;
+    actorUserId: string;
+    correlationId: string;
+    current: Readonly<Record<string, unknown>>;
+    configuration: AccountGateConfiguration;
+}): Promise<Readonly<Record<string, unknown>> | null>;
+export declare function validateRevocationPayload(input: unknown): ScheduledTaskPayload;
+export declare function reconcileRevocationTask(context: RuntimeContext, task: {
+    payload: ScheduledTaskPayload;
+}): Promise<{
+    outcome: "requires_review";
+    safeCode: string;
+} | {
+    outcome: "completed";
+    safeCode?: never;
+}>;
+//# sourceMappingURL=member-revocation.d.ts.map

package/dist/member-revocation.js

@@ -0,0 +1,127 @@
+import { HELYX_SERVICE_NAMES, ACCOUNT_GATE_IDENTITY, ACCOUNT_GATE_SESSION_PURPOSE, REVOCATION_RECONCILE_TASK, RETENTION_MS, parseAccountGateSessionState, } from "./runtime-dependencies.js";
+import { parseAccountGateConfiguration } from "./configuration.js";
+import { loadMemberSummary } from "./member-summary.js";
+import { numberValue } from "./runtime-support.js";
+export async function revokeMemberAccess(input) {
+    const expectedRevision = numberValue(input.current.revision);
+    const generation = numberValue(input.current.join_generation) + 1;
+    const now = new Date();
+    const records = input.services.get(HELYX_SERVICE_NAMES.records);
+    const updated = await records.updateOne({
+        moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
+        collection: "member_summaries",
+        where: {
+            guild_id: input.guildId,
+            member_user_id: input.memberUserId,
+        },
+        expected: { field: "revision", value: expectedRevision },
+        requireModuleEnabledForGuildId: input.guildId,
+        values: {
+            join_generation: generation,
+            deadline_at: now,
+            pending_reason: "none",
+            left_at: new Date(0),
+            last_decision: "revoked",
+            revision: expectedRevision + 1,
+            retention_until: new Date(now.getTime() + RETENTION_MS),
+            updated_at: now,
+        },
+        schedule: {
+            taskKind: REVOCATION_RECONCILE_TASK,
+            guildId: input.guildId,
+            idempotencyKey: `${input.guildId}:${input.memberUserId}:revoke:${generation}`,
+            payload: {
+                guildId: input.guildId,
+                memberUserId: input.memberUserId,
+                generation: String(generation),
+            },
+            scheduledFor: now,
+        },
+        audit: {
+            guildId: input.guildId,
+            actorUserId: input.actorUserId,
+            action: "account_gate.access_revoked",
+            source: "dashboard",
+            correlationId: input.correlationId,
+            idempotencyKey: input.correlationId,
+            targetType: "account_gate_member",
+            targetId: input.memberUserId,
+            metadata: { reconciliation: "durable" },
+        },
+    });
+    if (!updated.updated)
+        return null;
+    await reconcileRevokedMember(input.services, input.guildId, input.memberUserId, generation, input.configuration).catch(() => undefined);
+    return {
+        ...input.current,
+        join_generation: generation,
+        deadline_at: now,
+        pending_reason: "none",
+        left_at: new Date(0),
+        last_decision: "revoked",
+        revision: expectedRevision + 1,
+        retention_until: new Date(now.getTime() + RETENTION_MS),
+        updated_at: now,
+    };
+}
+export function validateRevocationPayload(input) {
+    if (!input || typeof input !== "object" || Array.isArray(input))
+        throw new Error("Account Gate revocation 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.generation !== "string" ||
+        !/^[1-9]\d{0,9}$/u.test(value.generation))
+        throw new Error("Account Gate revocation payload is invalid");
+    return {
+        guildId: value.guildId,
+        memberUserId: value.memberUserId,
+        generation: value.generation,
+    };
+}
+export async function reconcileRevocationTask(context, task) {
+    const configurationRecord = await context.services
+        .get(HELYX_SERVICE_NAMES.configuration)
+        .get(task.payload.guildId, ACCOUNT_GATE_IDENTITY.moduleId);
+    if (!configurationRecord)
+        return {
+            outcome: "requires_review",
+            safeCode: "revocation-configuration-missing",
+        };
+    await reconcileRevokedMember(context.services, task.payload.guildId, task.payload.memberUserId, Number(task.payload.generation), parseAccountGateConfiguration(configurationRecord.value));
+    return { outcome: "completed" };
+}
+async function reconcileRevokedMember(services, guildId, memberUserId, generation, configuration) {
+    const summary = await loadMemberSummary(services.get(HELYX_SERVICE_NAMES.records), guildId, memberUserId);
+    if (summary?.last_decision !== "revoked" ||
+        numberValue(summary.join_generation) !== generation)
+        return;
+    await services
+        .get(HELYX_SERVICE_NAMES.memberRoles)
+        .reconcileApprovedRoles({
+        guildId,
+        memberUserId,
+        allowedRoleIds: [
+            configuration.verifiedRoleId,
+            ...configuration.temporaryRoleIds,
+        ],
+        desiredRoleIds: configuration.temporaryRoleIds,
+        moduleId: ACCOUNT_GATE_IDENTITY.moduleId,
+        reason: "Access Control dashboard access revocation",
+    });
+    const sessions = services.get(HELYX_SERVICE_NAMES.sessions);
+    const session = await sessions.getFor(guildId, memberUserId, ACCOUNT_GATE_SESSION_PURPOSE);
+    if (!session)
+        return;
+    try {
+        if (parseAccountGateSessionState(session.state).joinGeneration >= generation)
+            return;
+    }
+    catch {
+        // Invalid module-owned state is safe to discard after revocation committed.
+    }
+    await sessions.delete(session.sessionId);
+}
+//# sourceMappingURL=member-revocation.js.map

package/dist/member-start.d.ts

@@ -0,0 +1,5 @@
+import type { CommandInteractionContext, MessageResponse, ModalCapableInteractionContext } from "./runtime-dependencies.js";
+export declare function startCheck(context: CommandInteractionContext | ModalCapableInteractionContext): Promise<void>;
+export declare function startPanelId(customId: string | undefined): string | null;
+export declare function terminalRecoveryMessage(outcome: "passed" | "failed", decision: string): MessageResponse;
+//# sourceMappingURL=member-start.d.ts.map