@helyx/module-moderation 1.0.1

package/dist/thread-delivery.js

@@ -0,0 +1,427 @@
+import { randomUUID } from "node:crypto";
+import { HELYX_SERVICE_NAMES, } from "@helyx/sdk";
+import { DEFAULT_MODERATION_CONFIGURATION, parseModerationConfiguration, } from "./configuration.js";
+import { MODERATION_MODULE_ID } from "./constants.js";
+import { moderationThreadName } from "./case-naming.js";
+import { initialThreadControls, violationOpeningMessage, } from "./components.js";
+import { ModerationRepository, } from "./repository.js";
+import { scheduleModerationThreadRetry } from "./tasks.js";
+export class ModerationThreadDelivery {
+    async deliver(input) {
+        const configuration = await settings(input.services, input.guildId);
+        if (!configuration.violationThreadChannelId ||
+            !configuration.violationAccessRoleId ||
+            !configuration.violationOpeningMessageTemplate.trim())
+            return "review_required";
+        const repository = new ModerationRepository(input.services);
+        let delivery = await repository.findThreadDelivery(input.guildId, input.caseId);
+        if (delivery?.resolutionState === "closed")
+            return "already_exists";
+        if (delivery && !isActiveDelivery(delivery))
+            return "review_required";
+        if (delivery && deliveryComplete(delivery))
+            return delivery.evidenceState === "failed"
+                ? "review_required"
+                : "already_exists";
+        if (delivery && delivery.attemptCount >= 6)
+            return "review_required";
+        if (!delivery) {
+            const token = controlToken(input.services);
+            if (!token)
+                return "review_required";
+            const now = new Date();
+            delivery = {
+                deliveryId: randomUUID(),
+                guildId: input.guildId,
+                caseId: input.caseId,
+                caseRevision: input.caseRevision,
+                operationKey: input.operationKey,
+                parentChannelId: configuration.violationThreadChannelId,
+                accessRoleId: configuration.violationAccessRoleId,
+                threadId: null,
+                controlToken: token,
+                controlMessageId: null,
+                memberState: "pending",
+                evidenceState: input.evidence ? "pending" : "not_requested",
+                openingState: "pending",
+                notificationState: "pending",
+                closeState: "not_requested",
+                resolutionState: "awaiting_staff",
+                attemptCount: 0,
+                fenceToken: 0,
+                safeCode: null,
+                retryAt: null,
+                createdAt: now,
+                updatedAt: now,
+            };
+            delivery = await repository.createThreadDelivery(delivery);
+            if (delivery.resolutionState === "closed")
+                return "already_exists";
+            if (!isActiveDelivery(delivery))
+                return "review_required";
+            if (deliveryComplete(delivery))
+                return delivery.evidenceState === "failed"
+                    ? "review_required"
+                    : "already_exists";
+            if (delivery.attemptCount >= 6)
+                return "review_required";
+        }
+        try {
+            delivery = await continueDelivery(repository, delivery, configuration, {
+                subjectUserId: input.subjectUserId,
+                caseNumber: input.caseNumber,
+                evidence: input.evidence,
+                services: input.services,
+            });
+            return delivery.evidenceState === "failed"
+                ? "review_required"
+                : delivery.attemptCount > 1
+                    ? "already_exists"
+                    : "created";
+        }
+        catch (error) {
+            if (threadFailureCode(error) === "thread_delivery_fence_changed")
+                return "retry_pending";
+            const failed = await markRetry(repository, input.services, input.guildId, input.caseId, input.subjectUserId, error);
+            if (failed && failed.attemptCount < 6)
+                await scheduleModerationThreadRetry(input.services, {
+                    guildId: input.guildId,
+                    caseId: input.caseId,
+                    operationKey: input.operationKey,
+                }).catch(() => undefined);
+            return failed && failed.attemptCount < 6
+                ? "retry_pending"
+                : "review_required";
+        }
+    }
+    async deliverPending(services, input) {
+        const repository = new ModerationRepository(services);
+        const [moderationCase, delivery] = await Promise.all([
+            repository.findCase(input.guildId, input.caseId),
+            repository.findThreadDelivery(input.guildId, input.caseId),
+        ]);
+        if (!moderationCase || !delivery || delivery.resolutionState === "closed")
+            return { outcome: "completed" };
+        if (!isActiveDelivery(delivery))
+            return { outcome: "requires_review", safeCode: "thread_redacted" };
+        if (deliveryComplete(delivery))
+            return delivery.evidenceState === "failed"
+                ? {
+                    outcome: "requires_review",
+                    safeCode: "thread_evidence_unavailable",
+                }
+                : { outcome: "completed" };
+        if (delivery.attemptCount >= 6)
+            return {
+                outcome: "requires_review",
+                safeCode: "thread_delivery_exhausted",
+            };
+        if (!moderationCase.subjectUserId)
+            return { outcome: "requires_review", safeCode: "case_disassociated" };
+        try {
+            const completed = await continueDelivery(repository, delivery, await settings(services, input.guildId), {
+                subjectUserId: moderationCase.subjectUserId,
+                caseNumber: moderationCase.caseNumber,
+                evidence: undefined,
+                services,
+            });
+            return completed.evidenceState === "failed"
+                ? {
+                    outcome: "requires_review",
+                    safeCode: "thread_evidence_unavailable",
+                }
+                : { outcome: "completed" };
+        }
+        catch (error) {
+            if (threadFailureCode(error) === "thread_delivery_fence_changed")
+                return {
+                    outcome: "retry",
+                    delayMs: 2_000,
+                    safeCode: "thread_delivery_fence_changed",
+                };
+            const failed = await markRetry(repository, services, input.guildId, input.caseId, moderationCase.subjectUserId, error);
+            return failed && failed.attemptCount < 6
+                ? {
+                    outcome: "retry",
+                    delayMs: 5_000,
+                    safeCode: "thread_delivery_failed",
+                }
+                : { outcome: "requires_review", safeCode: "thread_delivery_exhausted" };
+        }
+    }
+    async reconcileAccess(services, guildId) {
+        const configuration = await settings(services, guildId);
+        if (!configuration.violationThreadChannelId ||
+            !configuration.violationAccessRoleId)
+            return { outcome: "completed" };
+        const inspection = await threads(services).inspectConfiguration({
+            guildId,
+            parentChannelId: configuration.violationThreadChannelId,
+            accessRoleId: configuration.violationAccessRoleId,
+            moderatorRoleIds: configuration.violationModeratorRoleIds,
+            moderatorUserIds: configuration.violationModeratorUserIds,
+        });
+        if (inspection.outcome !== "allowed")
+            return {
+                outcome: "requires_review",
+                safeCode: `thread_${inspection.outcome}`,
+            };
+        const result = await grants(services).reconcile({
+            maximum: 100,
+            now: new Date(),
+        });
+        if (result.reviewRequired)
+            return { outcome: "requires_review", safeCode: "role_grant_review" };
+        if (result.retryPending)
+            return { outcome: "retry", delayMs: 5_000, safeCode: "role_grant_retry" };
+        return { outcome: "completed" };
+    }
+}
+async function continueDelivery(repository, current, configuration, input) {
+    if (!isActiveDelivery(current))
+        throw new Error("thread_delivery_redacted");
+    let delivery = await update(repository, current, {
+        attemptCount: current.attemptCount + 1,
+        safeCode: null,
+        retryAt: null,
+        updatedAt: new Date(),
+    });
+    if (!delivery.threadId) {
+        const inspected = await threads(input.services).inspectConfiguration({
+            guildId: delivery.guildId,
+            parentChannelId: delivery.parentChannelId,
+            accessRoleId: delivery.accessRoleId,
+            moderatorRoleIds: configuration.violationModeratorRoleIds,
+            moderatorUserIds: configuration.violationModeratorUserIds,
+        });
+        if (inspected.outcome !== "allowed" ||
+            inspected.missingPermissions.length > 0 ||
+            inspected.requiredChanges.length > 0)
+            throw new Error("thread_configuration_invalid");
+        const claimed = await grants(input.services).claim({
+            guildId: delivery.guildId,
+            memberUserId: input.subjectUserId,
+            roleId: delivery.accessRoleId,
+            sourceModuleId: MODERATION_MODULE_ID,
+            sourceId: delivery.caseId,
+            sourceScopeId: delivery.caseId,
+            operationKey: `${delivery.operationKey}:access-claim`,
+            occurredAt: delivery.createdAt,
+            reason: `Violation thread access for case ${input.caseNumber}`,
+        });
+        if (claimed.outcome === "rejected" || claimed.deliveryState !== "delivered")
+            throw new Error("thread_access_failed");
+        const created = await threads(input.services).create({
+            guildId: delivery.guildId,
+            parentChannelId: delivery.parentChannelId,
+            name: moderationThreadName(configuration, input.caseNumber),
+            operationKey: `${delivery.operationKey}:create-thread`,
+            revalidate: () => configurationStillMatches(input.services, delivery, configuration),
+        });
+        if (created.outcome !== "created" && created.outcome !== "already_exists")
+            throw new Error("thread_create_failed");
+        delivery = await update(repository, delivery, {
+            threadId: created.threadId,
+            updatedAt: new Date(),
+        });
+    }
+    const threadId = delivery.threadId;
+    if (!threadId)
+        throw new Error("thread_missing");
+    if (delivery.memberState !== "succeeded") {
+        const member = await threads(input.services).addMember({
+            guildId: delivery.guildId,
+            threadId,
+            memberUserId: input.subjectUserId,
+            operationKey: `${delivery.operationKey}:add-member`,
+        });
+        if (member.outcome !== "created" && member.outcome !== "already_exists")
+            throw new Error("thread_member_failed");
+        delivery = await update(repository, delivery, {
+            memberState: "succeeded",
+            updatedAt: new Date(),
+        });
+    }
+    if (!delivery.controlMessageId) {
+        // Each staff user is invited independently; retries converge through the
+        // adapter's membership check without granting any moderation authority.
+        for (const staffUserId of configuration.violationModeratorUserIds) {
+            if (staffUserId === input.subjectUserId)
+                continue;
+            if (!(await configurationStillMatches(input.services, delivery, configuration)))
+                throw new Error("thread_configuration_changed");
+            const staff = await threads(input.services).addMember({
+                guildId: delivery.guildId,
+                threadId,
+                memberUserId: staffUserId,
+                operationKey: `${delivery.operationKey}:staff:${staffUserId}`,
+            });
+            if (staff.outcome !== "created" && staff.outcome !== "already_exists")
+                throw new Error("thread_staff_notification_access_failed");
+        }
+        const member = await input.services
+            .get(HELYX_SERVICE_NAMES.memberEnforcement)
+            .inspectMember({
+            guildId: delivery.guildId,
+            memberUserId: input.subjectUserId,
+        });
+        if (!(await configurationStillMatches(input.services, delivery, configuration)))
+            throw new Error("thread_configuration_changed");
+        const opening = await threads(input.services).send({
+            guildId: delivery.guildId,
+            threadId,
+            presentation: {
+                layout: configuration.violationMessageLayout,
+                caseNumber: input.caseNumber,
+            },
+            response: violationOpeningMessage(configuration.violationModeratorRoleIds, input.subjectUserId, configuration.violationOpeningMessageTemplate, initialThreadControls(delivery.controlToken, member.outcome === "present" && Boolean(member.timeoutEndsAt)), configuration.violationModeratorUserIds.filter((id) => id !== input.subjectUserId)),
+            operationKey: `${delivery.operationKey}:opening-controls`,
+        });
+        if (opening.outcome !== "sent" && opening.outcome !== "already_sent")
+            throw new Error("thread_opening_failed");
+        delivery = await update(repository, delivery, {
+            controlMessageId: opening.messageId,
+            notificationState: "succeeded",
+            openingState: "succeeded",
+            updatedAt: new Date(),
+        });
+    }
+    if (delivery.evidenceState === "pending") {
+        const result = input.evidence
+            ? await input.evidence
+                .deliver({
+                guildId: delivery.guildId,
+                caseId: delivery.caseId,
+                threadId,
+                ...(delivery.controlMessageId
+                    ? { openingMessageId: delivery.controlMessageId }
+                    : {}),
+                operationKey: `${delivery.operationKey}:evidence`,
+            })
+                .catch(() => {
+                throw new Error("thread_evidence_failed");
+            })
+            : { outcome: "evidence_unavailable" };
+        delivery = await update(repository, delivery, {
+            evidenceState: result.outcome === "sent" || result.outcome === "already_sent"
+                ? "succeeded"
+                : "failed",
+            safeCode: result.outcome === "sent" || result.outcome === "already_sent"
+                ? null
+                : "thread_evidence_unavailable",
+            updatedAt: new Date(),
+        });
+    }
+    return delivery;
+}
+async function update(repository, current, values) {
+    if (!(await repository.updateThreadDelivery({
+        deliveryId: current.deliveryId,
+        expectedFenceToken: current.fenceToken,
+        values,
+    })))
+        throw new Error("thread_delivery_fence_changed");
+    return { ...current, ...values, fenceToken: current.fenceToken + 1 };
+}
+async function markRetry(repository, services, guildId, caseId, subjectUserId, error) {
+    const delivery = await repository.findThreadDelivery(guildId, caseId);
+    if (!delivery)
+        return null;
+    const exhausted = delivery.attemptCount >= 6;
+    const safeCode = threadFailureCode(error);
+    const state = exhausted ? "review_required" : "retry_pending";
+    const values = {
+        safeCode,
+        retryAt: exhausted ? null : new Date(Date.now() + 5_000),
+        updatedAt: new Date(),
+        ...(safeCode === "thread_member_failed" ? { memberState: state } : {}),
+        ...(safeCode === "thread_opening_failed" ? { openingState: state } : {}),
+        ...(safeCode === "thread_evidence_failed"
+            ? { evidenceState: "failed" }
+            : {}),
+        ...(safeCode === "thread_notification_failed"
+            ? { notificationState: state }
+            : {}),
+    };
+    const updated = await repository
+        .updateThreadDelivery({
+        deliveryId: delivery.deliveryId,
+        expectedFenceToken: delivery.fenceToken,
+        values,
+    })
+        .catch(() => false);
+    if (exhausted && delivery.accessRoleId)
+        await grants(services)
+            .release({
+            guildId: delivery.guildId,
+            memberUserId: subjectUserId,
+            roleId: delivery.accessRoleId,
+            sourceModuleId: MODERATION_MODULE_ID,
+            sourceId: delivery.caseId,
+            sourceScopeId: delivery.caseId,
+            operationKey: `${delivery.operationKey}:terminal-access-release`,
+            occurredAt: delivery.createdAt,
+            reason: "Release violation access after exhausted thread delivery",
+        })
+            .catch(() => undefined);
+    if (exhausted && delivery.threadId)
+        await threads(services)
+            .close({
+            guildId: delivery.guildId,
+            threadId: delivery.threadId,
+            operationKey: `${delivery.operationKey}:terminal-thread-close`,
+            revalidate: () => Promise.resolve(true),
+        })
+            .catch(() => undefined);
+    return updated
+        ? { ...delivery, ...values, fenceToken: delivery.fenceToken + 1 }
+        : null;
+}
+function threadFailureCode(error) {
+    const code = error instanceof Error ? error.message : "";
+    return THREAD_FAILURE_CODES.has(code) ? code : "thread_delivery_failed";
+}
+const THREAD_FAILURE_CODES = new Set("thread_configuration_invalid thread_access_failed thread_create_failed thread_missing thread_member_failed thread_opening_failed thread_evidence_failed thread_notification_failed thread_controls_failed thread_delivery_fence_changed".split(" "));
+function controlToken(services) {
+    return (services
+        .get(HELYX_SERVICE_NAMES.secureRandom)
+        .opaqueToken?.({ bytes: 24, purpose: "moderation.thread-control" }) ??
+        null);
+}
+async function settings(services, guildId) {
+    if (!services.has(HELYX_SERVICE_NAMES.configuration))
+        return DEFAULT_MODERATION_CONFIGURATION;
+    const stored = await services
+        .get(HELYX_SERVICE_NAMES.configuration)
+        .get(guildId, MODERATION_MODULE_ID);
+    return stored
+        ? parseModerationConfiguration(stored.value)
+        : DEFAULT_MODERATION_CONFIGURATION;
+}
+async function configurationStillMatches(services, delivery, expected) {
+    const current = await settings(services, delivery.guildId);
+    return (current.violationThreadChannelId === delivery.parentChannelId &&
+        current.violationAccessRoleId === delivery.accessRoleId &&
+        current.violationModeratorRoleIds.join(",") ===
+            expected.violationModeratorRoleIds.join(",") &&
+        current.violationModeratorUserIds.join(",") ===
+            expected.violationModeratorUserIds.join(","));
+}
+function threads(services) {
+    return services.get(HELYX_SERVICE_NAMES.violationThreads);
+}
+function grants(services) {
+    return services.get(HELYX_SERVICE_NAMES.memberRoleGrants);
+}
+function isActiveDelivery(delivery) {
+    return Boolean(delivery.parentChannelId && delivery.accessRoleId && delivery.controlToken);
+}
+function deliveryComplete(delivery) {
+    return Boolean(delivery.threadId &&
+        delivery.controlMessageId &&
+        delivery.memberState === "succeeded" &&
+        delivery.openingState === "succeeded" &&
+        delivery.notificationState === "succeeded" &&
+        delivery.evidenceState !== "pending");
+}
+//# sourceMappingURL=thread-delivery.js.map

package/dist/thread-reconciliation.d.ts

@@ -0,0 +1,24 @@
+import { type ScheduledTaskExecutionResult, type ServiceAccess } from "@helyx/sdk";
+import { ModerationRepository, type StoredModerationThreadDelivery } from "./repository.js";
+export type RecoverableThreadAction = "kick" | "ban" | "unmute" | "close" | "close_delete" | "resolve";
+export type ThreadControlEffectInspection = "applied" | "not_applied" | "unknown";
+export interface ThreadControlRecoveryMarker {
+    action: RecoverableThreadAction;
+    attemptId: string;
+}
+export declare function markAmbiguousThreadControl(repository: ModerationRepository, delivery: StoredModerationThreadDelivery, action: RecoverableThreadAction, attemptId: string): Promise<void>;
+export declare function recoveryMarker(delivery: StoredModerationThreadDelivery | null): ThreadControlRecoveryMarker | null;
+export declare function inspectThreadControlEffect(services: ServiceAccess, input: {
+    guildId: string;
+    caseId: string;
+    subjectUserId: string;
+    action: RecoverableThreadAction;
+}): Promise<ThreadControlEffectInspection>;
+export declare function finalizeThreadControlRecovery(services: ServiceAccess, input: {
+    guildId: string;
+    caseId: string;
+    caseRevision: number;
+    subjectUserId: string;
+    action: RecoverableThreadAction;
+}): Promise<ScheduledTaskExecutionResult>;
+//# sourceMappingURL=thread-reconciliation.d.ts.map

package/dist/thread-reconciliation.js

@@ -0,0 +1,181 @@
+import { HELYX_SERVICE_NAMES, } from "@helyx/sdk";
+import { MODERATION_MODULE_ID } from "./constants.js";
+import { closeThreadControl } from "./components.js";
+import { ModerationRepository, } from "./repository.js";
+export async function markAmbiguousThreadControl(repository, delivery, action, attemptId) {
+    let current = delivery;
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+        const updated = await repository.updateThreadDelivery({
+            deliveryId: current.deliveryId,
+            expectedFenceToken: current.fenceToken,
+            values: {
+                safeCode: recoveryCode(action, attemptId),
+                retryAt: new Date(),
+                updatedAt: new Date(),
+            },
+        });
+        if (updated)
+            return;
+        const refreshed = await repository.findThreadDelivery(current.guildId, current.caseId);
+        if (!refreshed)
+            throw new Error("thread_delivery_missing");
+        if (refreshed.safeCode === recoveryCode(action, attemptId))
+            return;
+        current = refreshed;
+    }
+    throw new Error("thread_delivery_fence_changed");
+}
+export function recoveryMarker(delivery) {
+    const match = /^thread_control_ambiguous_(kick|ban|unmute|close|close_delete|resolve)_([0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12})$/iu.exec(delivery?.safeCode ?? "");
+    if (!match?.[1] || !match[2])
+        return null;
+    return {
+        action: match[1],
+        attemptId: match[2].toLowerCase(),
+    };
+}
+export async function inspectThreadControlEffect(services, input) {
+    if (input.action === "resolve")
+        return "unknown";
+    if (input.action === "close" || input.action === "close_delete") {
+        const delivery = await new ModerationRepository(services).findThreadDelivery(input.guildId, input.caseId);
+        if (!delivery?.parentChannelId || !delivery.threadId)
+            return "unknown";
+        const thread = await services
+            .get(HELYX_SERVICE_NAMES.violationThreads)
+            .reconcile({
+            guildId: input.guildId,
+            parentChannelId: delivery.parentChannelId,
+            threadId: delivery.threadId,
+            ...(input.action === "close_delete" ? { requireBotOwner: true } : {}),
+            operationKey: `reconcile:${input.caseId}:thread-close`,
+        });
+        if (input.action === "close_delete")
+            return thread.outcome === "absent" ? "applied" : "unknown";
+        if (thread.outcome !== "exists")
+            return "unknown";
+        return thread.archived && thread.locked ? "applied" : "not_applied";
+    }
+    const enforcement = services.get(HELYX_SERVICE_NAMES.memberEnforcement);
+    if (input.action === "ban") {
+        const ban = await enforcement.inspectBan({
+            guildId: input.guildId,
+            userId: input.subjectUserId,
+        });
+        return ban.outcome === "banned"
+            ? "applied"
+            : ban.outcome === "not_banned"
+                ? "not_applied"
+                : "unknown";
+    }
+    const member = await enforcement.inspectMember({
+        guildId: input.guildId,
+        memberUserId: input.subjectUserId,
+    });
+    if (member.outcome === "failed")
+        return "unknown";
+    if (input.action === "kick")
+        return member.outcome === "member_missing" ? "applied" : "not_applied";
+    return member.outcome === "present" && !member.timeoutEndsAt
+        ? "applied"
+        : "not_applied";
+}
+export async function finalizeThreadControlRecovery(services, input) {
+    const repository = new ModerationRepository(services);
+    const delivery = await repository.findThreadDelivery(input.guildId, input.caseId);
+    if (!delivery)
+        return { outcome: "completed" };
+    const closing = input.action === "close" || input.action === "close_delete";
+    const desiredResolution = closing ? "closed" : "resolved";
+    if (delivery.caseRevision === input.caseRevision &&
+        delivery.resolutionState === desiredResolution &&
+        !recoveryMarker(delivery))
+        return { outcome: "completed" };
+    if ((input.action === "kick" || input.action === "ban" || closing) &&
+        !(await releaseAccess(services, delivery, input.subjectUserId, input.action)))
+        return {
+            outcome: "retry",
+            delayMs: 5_000,
+            safeCode: "thread_access_release_pending",
+        };
+    const updated = await repository.updateThreadDelivery({
+        deliveryId: delivery.deliveryId,
+        expectedFenceToken: delivery.fenceToken,
+        values: {
+            caseRevision: input.caseRevision,
+            resolutionState: desiredResolution,
+            ...(closing ? { closeState: "succeeded" } : {}),
+            ...(closing ? { safeCode: null, retryAt: null } : {}),
+            updatedAt: new Date(),
+        },
+    });
+    if (!updated)
+        return {
+            outcome: "retry",
+            delayMs: 2_000,
+            safeCode: "thread_delivery_revision_changed",
+        };
+    if (closing)
+        return { outcome: "completed" };
+    const threads = services.get(HELYX_SERVICE_NAMES.violationThreads);
+    if (threads.editControls &&
+        delivery.threadId &&
+        delivery.controlMessageId &&
+        delivery.controlToken) {
+        const edited = await threads.editControls({
+            guildId: input.guildId,
+            threadId: delivery.threadId,
+            messageId: delivery.controlMessageId,
+            buttons: closeThreadControl(delivery.controlToken).buttons,
+            operationKey: `recover:${input.caseId}:${input.caseRevision}:controls`,
+            revalidate: async () => {
+                const current = await repository.findCase(input.guildId, input.caseId);
+                return (current?.state === "applied" &&
+                    current.revision === input.caseRevision &&
+                    Boolean(current.subjectUserId) &&
+                    !current.disassociatedAt);
+            },
+        });
+        if (edited.outcome !== "updated")
+            return {
+                outcome: "retry",
+                delayMs: 5_000,
+                safeCode: "thread_controls_refresh_pending",
+            };
+    }
+    const current = await repository.findThreadDelivery(input.guildId, input.caseId);
+    if (!current ||
+        !(await repository.updateThreadDelivery({
+            deliveryId: current.deliveryId,
+            expectedFenceToken: current.fenceToken,
+            values: { safeCode: null, retryAt: null, updatedAt: new Date() },
+        })))
+        return {
+            outcome: "retry",
+            delayMs: 2_000,
+            safeCode: "thread_delivery_revision_changed",
+        };
+    return { outcome: "completed" };
+}
+async function releaseAccess(services, delivery, subjectUserId, action) {
+    if (!delivery.accessRoleId || !delivery.controlToken)
+        return false;
+    const result = await services
+        .get(HELYX_SERVICE_NAMES.memberRoleGrants)
+        .release({
+        guildId: delivery.guildId,
+        memberUserId: subjectUserId,
+        roleId: delivery.accessRoleId,
+        sourceModuleId: MODERATION_MODULE_ID,
+        sourceId: delivery.caseId,
+        sourceScopeId: delivery.caseId,
+        operationKey: `thread:${delivery.controlToken}:release:${action}`,
+        occurredAt: delivery.createdAt,
+        reason: `Violation thread access release after ${action}`,
+    });
+    return result.outcome === "committed" && result.deliveryState === "delivered";
+}
+function recoveryCode(action, attemptId) {
+    return `thread_control_ambiguous_${action}_${attemptId}`;
+}
+//# sourceMappingURL=thread-reconciliation.js.map

package/dist/thread-repository.d.ts

@@ -0,0 +1,16 @@
+import type { ModuleRecordService } from "@helyx/sdk";
+import { type StoredModerationThreadDelivery } from "./repository-model.js";
+export declare class ModerationThreadRepository {
+    private readonly records;
+    constructor(records: ModuleRecordService);
+    findThreadDelivery(guildId: string, caseId: string): Promise<StoredModerationThreadDelivery | null>;
+    findThreadDeliveryByControlToken(controlToken: string): Promise<StoredModerationThreadDelivery | null>;
+    upsertThreadDelivery(input: StoredModerationThreadDelivery): Promise<void>;
+    createThreadDelivery(input: StoredModerationThreadDelivery): Promise<StoredModerationThreadDelivery>;
+    updateThreadDelivery(input: {
+        deliveryId: string;
+        expectedFenceToken: number;
+        values: Partial<Omit<StoredModerationThreadDelivery, "deliveryId" | "guildId" | "caseId" | "createdAt">>;
+    }): Promise<boolean>;
+}
+//# sourceMappingURL=thread-repository.d.ts.map