@helyx/module-account-gate 1.0.15 → 1.1.3

package/dist/expiry-workflows.js

@@ -0,0 +1,281 @@
+import { randomUUID, HELYX_SERVICE_NAMES, ACCOUNT_GATE_IDENTITY, ACCOUNT_GATE_SESSION_PURPOSE, neutralKickDirectMessage, accountGateRecords, isAccountGateWorkSuppressed, parseAccountGateSessionState, emitAccountGateKickLog, successfulKickOutcome, VIOLET, RETENTION_MS, } from "./runtime-dependencies.js";
+import { isCurrentPendingMember, loadMemberSummary, setSummaryDecision, } from "./member-summary.js";
+import { createReview } from "./review-store.js";
+import { dateValue, numberValue } from "./runtime-support.js";
+import { requiredRuntimeConfiguration } from "./setup-presentation.js";
+import { armRecordRetention } from "./task-scheduling.js";
+import { ensureTerminalFinalization, finalizeTerminalFinalization, } from "./terminal-finalization.js";
+export 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,
+    };
+}
+export 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,
+    };
+}
+export 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" };
+}
+export 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" };
+}
+export 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,
+    };
+}
+export 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" };
+}
+//# sourceMappingURL=expiry-workflows.js.map

package/dist/gateway-interactions.d.ts

@@ -0,0 +1,5 @@
+import type { InteractionSessionService, MessageReactionAddContext, PrivilegedMessageCreateContext, ServiceAccess, ChallengeAction } from "./runtime-dependencies.js";
+export declare function handlePasswordEntry(context: PrivilegedMessageCreateContext): Promise<void>;
+export declare function handleEmojiEntry(context: MessageReactionAddContext): Promise<void>;
+export declare function processGatewayAction(services: ServiceAccess, guildId: string, userId: string, session: Awaited<ReturnType<InteractionSessionService["getFor"]>> & {}, action: ChallengeAction): Promise<void>;
+//# sourceMappingURL=gateway-interactions.d.ts.map

package/dist/gateway-interactions.js

@@ -0,0 +1,124 @@
+import { HELYX_SERVICE_NAMES, ACCOUNT_GATE_SESSION_PURPOSE, applyChallengeAction, getGatePanelRuntime, parseAccountGateSessionState, verifyPasswordEntry, emitLog, } from "./runtime-dependencies.js";
+import { isCurrentPendingMember } from "./member-summary.js";
+import { recordAccountGateAttempt } from "./member-restart.js";
+import { canonicalEmojiKey, staticResumeMessage } from "./runtime-support.js";
+import { configurationForPanel, getConfiguration, requiredRuntimeConfiguration, validateAccountGateSetup, } from "./setup-presentation.js";
+import { scheduleSessionExpiry } from "./task-scheduling.js";
+import { ensureTerminalFinalization, finalizeTerminalFinalization, } from "./terminal-finalization.js";
+export 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" });
+}
+export 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?.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" });
+}
+export 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;
+    }
+    await finalizeTerminalFinalization(services, guildId, session.sessionId);
+}
+//# sourceMappingURL=gateway-interactions.js.map

package/dist/health.d.ts

@@ -0,0 +1,10 @@
+import type { HealthResult, RuntimeContext } from "@helyx/sdk";
+export declare class AccountGateHealth {
+    #private;
+    start(context: RuntimeContext): void;
+    stop(): void;
+    recordTaskSuccess(taskKind: string): void;
+    recordTaskFailure(taskKind: string, code: string): void;
+    snapshot(): HealthResult;
+}
+//# sourceMappingURL=health.d.ts.map

package/dist/health.js

@@ -0,0 +1,55 @@
+import { HELYX_SERVICE_NAMES } from "@helyx/sdk";
+const REQUIRED_SERVICES = [
+    HELYX_SERVICE_NAMES.configuration,
+    HELYX_SERVICE_NAMES.discordMessages,
+    HELYX_SERVICE_NAMES.discordResources,
+    HELYX_SERVICE_NAMES.installations,
+    HELYX_SERVICE_NAMES.memberEnforcement,
+    HELYX_SERVICE_NAMES.memberRoles,
+    HELYX_SERVICE_NAMES.records,
+    HELYX_SERVICE_NAMES.resourceAuthorization,
+    HELYX_SERVICE_NAMES.scheduledTasks,
+    HELYX_SERVICE_NAMES.secureRandom,
+    HELYX_SERVICE_NAMES.sessions,
+];
+export class AccountGateHealth {
+    #running = false;
+    #missingServices = [];
+    #taskFailures = new Map();
+    start(context) {
+        this.#running = true;
+        this.#missingServices = REQUIRED_SERVICES.filter((service) => !context.services.has(service));
+        this.#taskFailures.clear();
+    }
+    stop() {
+        this.#running = false;
+        this.#missingServices = [];
+        this.#taskFailures.clear();
+    }
+    recordTaskSuccess(taskKind) {
+        this.#taskFailures.delete(taskKind);
+    }
+    recordTaskFailure(taskKind, code) {
+        this.#taskFailures.set(taskKind, code);
+    }
+    snapshot() {
+        if (!this.#running)
+            return { status: "unhealthy", message: "Access Control is stopped" };
+        if (this.#missingServices.length > 0)
+            return {
+                status: "unhealthy",
+                message: "Access Control runtime services are unavailable",
+            };
+        const failureCode = this.#taskFailures.values().next().value;
+        if (failureCode)
+            return {
+                status: "degraded",
+                message: `Access Control recovery requires attention (${failureCode})`,
+            };
+        return {
+            status: "healthy",
+            message: "Access Control durable workflows are registered",
+        };
+    }
+}
+//# sourceMappingURL=health.js.map

package/dist/index.d.ts

@@ -1,27 +1,16 @@
-import type { MessageResponse, ModuleRecordService, ModuleRecordValue, ServiceAccess } from "@helyx/sdk";
 import { generateChallengeChain, validateServerQuestion } from "./challenges.js";
-import { ACCOUNT_GATE_IDENTITY } from "./contracts.js";
-import type { AccountGateSessionState, Challenge } from "./contracts.js";
 import { parseAccountGateConfiguration, validateRuntimeCapabilities } from "./configuration.js";
-import type { AccountGateConfiguration } from "./configuration.js";
+import { ACCOUNT_GATE_IDENTITY } from "./contracts.js";
 import { accountGateRecords } from "./records.js";
+import { validateAccountGateSetup } from "./setup-presentation.js";
+import { ensureTerminalFinalization } from "./terminal-finalization.js";
 import { applyChallengeAction, createAccountGateSessionState } from "./workflow.js";
 export declare const accountGateModule: import("@helyx/sdk").ModuleDefinition;
 export default accountGateModule;
 export { ACCOUNT_GATE_IDENTITY, accountGateRecords, applyChallengeAction, createAccountGateSessionState, generateChallengeChain, parseAccountGateConfiguration, validateRuntimeCapabilities, validateServerQuestion, };
-export declare function isAccountTooYoung(accountCreatedAt: Date, joinedAt: Date, minimumAccountAgeDays: number): boolean;
-export declare function hasPreviousSuccess(value: unknown): boolean;
-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>;
-export declare function ensureTerminalFinalization(services: ServiceAccess, guildId: string, memberUserId: string, sessionId: string, state: AccountGateSessionState, outcome: "passed" | "failed"): Promise<boolean>;
-export declare function validateAccountGateSetup(services: ServiceAccess, guildId: string, configuration: AccountGateConfiguration, throwOnError?: boolean, allowMissingPanel?: boolean): Promise<readonly string[]>;
-interface ComponentBinding {
-    sessionId: string;
-    version: bigint;
-    step: number;
-    value?: string;
-}
-export declare function boundComponentId(prefix: string, binding: ComponentBinding): string;
-export declare function parseComponentBinding(customId: string | undefined, prefix: string): ComponentBinding | null;
-export declare function staticResumeMessage(guildId: string, gateChannelId: string): MessageResponse;
+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.d.ts.map