@helyx/bot 1.0.1 → 1.2.0

package/dist/embedded-auto-moderation-worker.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=embedded-auto-moderation-worker.d.ts.map

package/dist/embedded-auto-moderation-worker.js

@@ -0,0 +1,13 @@
+import { parentPort } from "node:worker_threads";
+import { EmbeddedWorkerRuntime, } from "./embedded-auto-moderation-worker-runtime.js";
+const workerPort = parentPort;
+if (!workerPort)
+    throw new Error("Embedded Auto Moderation worker requires a parent port");
+const runtime = new EmbeddedWorkerRuntime();
+workerPort.on("message", (request) => {
+    const response = runtime.handle(request);
+    if (response)
+        workerPort.postMessage(response);
+});
+workerPort.postMessage({ type: "ready" });
+//# sourceMappingURL=embedded-auto-moderation-worker.js.map

package/dist/events.d.ts

@@ -1,8 +1,12 @@
 import type { DiscordChannelAudienceInspection, DiscordChannelInspection, DiscordEmojiInspection, DiscordMessageInspection, DiscordGuildCapabilityInspection, DiscordGuildChannelAudienceInspection, DiscordResourceInspectionService, DiscordRoleInspection, DiscordMessageService, InstallationService, MemberEnforcementService, MemberRoleService, ModuleDefinition, ServiceAccess, VerificationMemberService } from "@helyx/sdk";
 import { type Client, type MessageReaction, type PartialMessageReaction } from "discord.js";
 import { type InteractionLogger } from "./interactions.js";
+import type { TransientViolationEvidenceStore } from "./transient-violation-evidence.js";
 export declare function availabilityAwareInstallations(services: ServiceAccess, modulesById?: ReadonlyMap<string, ModuleDefinition>): Pick<InstallationService, "isModuleEnabled">;
-export declare function installModuleEvents(client: Client, modules: readonly ModuleDefinition[], logger: InteractionLogger, services: ServiceAccess): ModuleEventHandle;
+export declare function installModuleEvents(client: Client, modules: readonly ModuleDefinition[], logger: InteractionLogger, services: ServiceAccess, options?: {
+    runtimeProfile?: "hosted" | "self-hosted";
+    evidenceStore?: TransientViolationEvidenceStore;
+}): ModuleEventHandle;
 export interface ModuleEventHandle {
     stop(): Promise<void>;
     queueDepth(): number;

package/dist/events.js

@@ -5,6 +5,8 @@ import { toReplyOptions } from "./interactions.js";
 import { createHash } from "node:crypto";
 import { classifyGuildMessage, unavailableGuildMessageClassification, } from "./message-classification.js";
 import { canAccessModule } from "./premium-access.js";
+import { fromDiscordAction, toRuleSnapshot, } from "./discord-auto-moderation-service.js";
+import { PrivilegedMessageMetadataCache } from "./privileged-message-metadata-cache.js";
 export function availabilityAwareInstallations(services, modulesById) {
     const installations = services.get(HELYX_SERVICE_NAMES.installations);
     const candidate = typeof services.has === "function" &&
@@ -21,12 +23,65 @@ export function availabilityAwareInstallations(services, modulesById) {
         },
     };
 }
-export function installModuleEvents(client, modules, logger, services) {
+async function featureContributionAvailable(services, guildId, moduleId, featureId) {
+    if (!featureId)
+        return true;
+    if (!services.has(HELYX_SERVICE_NAMES.featureAccess))
+        return false;
+    try {
+        const result = await services
+            .get(HELYX_SERVICE_NAMES.featureAccess)
+            .check({ guildId, moduleId, featureId });
+        return result.decision === "granted";
+    }
+    catch {
+        return false;
+    }
+}
+function privilegedSource(message) {
+    const author = message.author;
+    if (!author?.id)
+        return { resolved: false };
+    const channel = "channel" in message ? message.channel : undefined;
+    const channelIsThread = Boolean(channel && typeof channel.isThread === "function" && channel.isThread());
+    return {
+        resolved: true,
+        userId: author.id,
+        userIsBot: author.bot,
+        userIsSystem: Boolean(author.system || message.system),
+        webhookId: message.webhookId,
+        member: message.member
+            ? {
+                present: true,
+                roleIds: [...message.member.roles.cache.keys()].sort(),
+            }
+            : { present: false },
+        channelId: message.channelId,
+        parentChannelId: channelIsThread && channel && "parentId" in channel
+            ? channel.parentId
+            : null,
+        channelIsThread,
+    };
+}
+export function installModuleEvents(client, modules, logger, services, options) {
+    const runtimeProfile = options?.runtimeProfile ?? "hosted";
     const modulesById = new Map(modules.map((module) => [module.manifest.id, module]));
-    const privilegedMessageContributions = modules.flatMap((module) => (module.events?.privilegedMessageCreate ?? []).map((contribution) => ({
+    const privilegedMessageContributions = modules.flatMap((module) => (module.events?.privilegedMessageCreate ?? [])
+        .filter((contribution) => !contribution.featureId || runtimeProfile === "self-hosted")
+        .map((contribution) => ({
         moduleId: module.manifest.id,
         contribution,
     })));
+    const privilegedMessageUpdateContributions = modules.flatMap((module) => (module.events?.privilegedMessageUpdate ?? [])
+        .filter((contribution) => !contribution.featureId || runtimeProfile === "self-hosted")
+        .map((contribution) => ({
+        moduleId: module.manifest.id,
+        contribution,
+    })));
+    const autoModerationRuleCreateContributions = modules.flatMap((module) => (module.events?.discordAutoModerationRuleCreate ?? []).map((contribution) => ({ moduleId: module.manifest.id, contribution })));
+    const autoModerationRuleUpdateContributions = modules.flatMap((module) => (module.events?.discordAutoModerationRuleUpdate ?? []).map((contribution) => ({ moduleId: module.manifest.id, contribution })));
+    const autoModerationRuleDeleteContributions = modules.flatMap((module) => (module.events?.discordAutoModerationRuleDelete ?? []).map((contribution) => ({ moduleId: module.manifest.id, contribution })));
+    const autoModerationActionContributions = modules.flatMap((module) => (module.events?.discordAutoModerationActionExecution ?? []).map((contribution) => ({ moduleId: module.manifest.id, contribution })));
     const guildMessageContributions = modules.flatMap((module) => (module.events?.guildMessageCreate ?? []).map((contribution) => ({
         moduleId: module.manifest.id,
         classificationRequested: module.requiredDiscordCapabilities?.includes("message-content") ??
@@ -101,6 +156,11 @@ export function installModuleEvents(client, modules, logger, services) {
         contribution,
     })));
     if (privilegedMessageContributions.length === 0 &&
+        privilegedMessageUpdateContributions.length === 0 &&
+        autoModerationRuleCreateContributions.length === 0 &&
+        autoModerationRuleUpdateContributions.length === 0 &&
+        autoModerationRuleDeleteContributions.length === 0 &&
+        autoModerationActionContributions.length === 0 &&
         guildMessageContributions.length === 0 &&
         guildVoiceSessionContributions.length === 0 &&
         reactionContributions.length === 0 &&
@@ -120,6 +180,7 @@ export function installModuleEvents(client, modules, logger, services) {
         guildEmojiUpdateContributions.length === 0)
         return { stop: () => Promise.resolve(), queueDepth: () => 0 };
     const queue = new BoundedGuildEventQueue(logger);
+    const privilegedMetadata = new PrivilegedMessageMetadataCache();
     const voiceSessions = new Map();
     const privilegedEligibilityQueue = privilegedMessageContributions.length > 0
         ? new BoundedGuildEventQueue(logger)
@@ -149,6 +210,21 @@ export function installModuleEvents(client, modules, logger, services) {
                 });
         });
     }
+    if (privilegedMessageUpdateContributions.length > 0) {
+        client.on(Events.MessageCreate, (message) => {
+            if (!message.guildId)
+                return;
+            const source = privilegedSource(message);
+            if (!source.resolved)
+                return;
+            privilegedMetadata.remember({
+                guildId: message.guildId,
+                channelId: message.channelId,
+                messageId: message.id,
+                source,
+            });
+        });
+    }
     if (privilegedMessageContributions.length > 0) {
         client.on(Events.MessageCreate, (message) => {
             if (!message.guildId || !privilegedEligibilityQueue)
@@ -159,6 +235,7 @@ export function installModuleEvents(client, modules, logger, services) {
                 for (const item of privilegedMessageContributions) {
                     try {
                         if ((await installations.isModuleEnabled(message.guildId, item.moduleId)) &&
+                            (await featureContributionAvailable(services, message.guildId, item.moduleId, item.contribution.featureId)) &&
                             (await item.contribution.isEligible({
                                 serverId: message.guildId,
                                 channelId: message.channelId,
@@ -167,6 +244,7 @@ export function installModuleEvents(client, modules, logger, services) {
                                 userIsSystem: message.author.system || message.system,
                                 webhookId: message.webhookId,
                                 content: message.content,
+                                source: privilegedSource(message),
                                 services,
                             }))) {
                             eligible.push(item);
@@ -241,6 +319,32 @@ export function installModuleEvents(client, modules, logger, services) {
                 queue.enqueue(message.guildId, () => handleMessageUpdate(message));
         });
     }
+    if (privilegedMessageUpdateContributions.length > 0) {
+        client.on(Events.MessageUpdate, (_before, message) => {
+            if (message.guildId)
+                queue.enqueue(message.guildId, () => handlePrivilegedMessageUpdate(message));
+        });
+    }
+    if (autoModerationRuleCreateContributions.length > 0) {
+        client.on(Events.AutoModerationRuleCreate, (rule) => {
+            queue.enqueue(rule.guild.id, () => handleAutoModerationRule(autoModerationRuleCreateContributions, rule, "create"));
+        });
+    }
+    if (autoModerationRuleUpdateContributions.length > 0) {
+        client.on(Events.AutoModerationRuleUpdate, (_before, rule) => {
+            queue.enqueue(rule.guild.id, () => handleAutoModerationRule(autoModerationRuleUpdateContributions, rule, "update"));
+        });
+    }
+    if (autoModerationRuleDeleteContributions.length > 0) {
+        client.on(Events.AutoModerationRuleDelete, (rule) => {
+            queue.enqueue(rule.guild.id, () => handleAutoModerationRule(autoModerationRuleDeleteContributions, rule, "delete"));
+        });
+    }
+    if (autoModerationActionContributions.length > 0) {
+        client.on(Events.AutoModerationActionExecution, (execution) => {
+            queue.enqueue(execution.guild.id, () => handleAutoModerationAction(execution));
+        });
+    }
     if (messageDeleteContributions.length > 0) {
         client.on(Events.MessageDelete, (message) => {
             if (message.guildId)
@@ -335,7 +439,8 @@ export function installModuleEvents(client, modules, logger, services) {
         const installations = availabilityAwareInstallations(services, modulesById);
         for (const { moduleId, contribution } of contributions) {
             try {
-                if (!(await installations.isModuleEnabled(message.guildId, moduleId)))
+                if (!(await installations.isModuleEnabled(message.guildId, moduleId)) ||
+                    !(await featureContributionAvailable(services, message.guildId, moduleId, contribution.featureId)))
                     continue;
                 await contribution.execute({
                     serverId: message.guildId,
@@ -345,6 +450,7 @@ export function installModuleEvents(client, modules, logger, services) {
                     userIsBot: message.author.bot,
                     webhookId: message.webhookId,
                     content: message.content,
+                    source: privilegedSource(message),
                     services,
                     deleteSource: async () => {
                         await message.delete();
@@ -362,6 +468,138 @@ export function installModuleEvents(client, modules, logger, services) {
             }
         }
     }
+    async function handlePrivilegedMessageUpdate(message) {
+        if (!message.guildId)
+            return;
+        const payloadSource = privilegedSource(message);
+        const cachedSource = privilegedMetadata.resolve({
+            guildId: message.guildId,
+            channelId: message.channelId,
+            messageId: message.id,
+        });
+        const source = payloadSource.resolved
+            ? payloadSource
+            : (cachedSource ?? { resolved: false });
+        if (source.resolved)
+            privilegedMetadata.remember({
+                guildId: message.guildId,
+                channelId: message.channelId,
+                messageId: message.id,
+                source,
+            });
+        const observedAt = new Date();
+        const content = typeof message.content === "string"
+            ? { present: true, value: message.content }
+            : { present: false };
+        const installations = availabilityAwareInstallations(services, modulesById);
+        for (const { moduleId, contribution, } of privilegedMessageUpdateContributions) {
+            try {
+                if (!(await installations.isModuleEnabled(message.guildId, moduleId)) ||
+                    !(await featureContributionAvailable(services, message.guildId, moduleId, contribution.featureId)))
+                    continue;
+                await contribution.execute({
+                    serverId: message.guildId,
+                    channelId: message.channelId,
+                    messageId: message.id,
+                    observationVersion: message.editedTimestamp?.toString() ?? observedAt.toISOString(),
+                    observedAt,
+                    content,
+                    source,
+                    services,
+                });
+            }
+            catch (error) {
+                logger.warn({
+                    event: "module.privileged_message_update_failed",
+                    moduleId,
+                    error: safeError(error),
+                    messageId: message.id,
+                    guildId: message.guildId,
+                }, "Module privileged message-update event failed");
+            }
+        }
+    }
+    async function handleAutoModerationRule(contributions, rule, eventName) {
+        const installations = availabilityAwareInstallations(services, modulesById);
+        for (const { moduleId, contribution } of contributions) {
+            try {
+                if (!(await installations.isModuleEnabled(rule.guild.id, moduleId)))
+                    continue;
+                await contribution.execute({
+                    serverId: rule.guild.id,
+                    rule: toRuleSnapshot(rule),
+                    services,
+                });
+            }
+            catch (error) {
+                logger.warn({
+                    event: `module.auto_moderation_rule_${eventName}_failed`,
+                    moduleId,
+                    guildId: rule.guild.id,
+                    ruleId: rule.id,
+                    error: safeError(error),
+                }, "Module Auto Moderation rule event failed");
+            }
+        }
+    }
+    async function handleAutoModerationAction(execution) {
+        const installations = availabilityAwareInstallations(services, modulesById);
+        const action = fromDiscordAction(execution.action);
+        const executionId = createHash("sha256")
+            .update(JSON.stringify([
+            execution.guild.id,
+            execution.ruleId,
+            execution.userId,
+            execution.channelId,
+            execution.messageId,
+        ]))
+            .digest("hex");
+        const evidenceReference = options?.evidenceStore && execution.channelId && execution.content
+            ? options.evidenceStore.capture({
+                source: "discord_auto_moderation",
+                sourceEventId: executionId,
+                guildId: execution.guild.id,
+                channelId: execution.channelId,
+                messageId: execution.messageId,
+                authorUserId: execution.userId,
+                content: execution.content,
+            })
+            : null;
+        try {
+            for (const { moduleId, contribution, } of autoModerationActionContributions) {
+                try {
+                    if (!(await installations.isModuleEnabled(execution.guild.id, moduleId)))
+                        continue;
+                    await contribution.execute({
+                        serverId: execution.guild.id,
+                        ruleId: execution.ruleId,
+                        userId: execution.userId,
+                        channelId: execution.channelId,
+                        messageId: execution.messageId,
+                        alertSystemMessageId: execution.alertSystemMessageId,
+                        action,
+                        executionId,
+                        evidenceReference,
+                        occurredAt: new Date(),
+                        services,
+                    });
+                }
+                catch (error) {
+                    logger.warn({
+                        event: "module.auto_moderation_action_execution_failed",
+                        moduleId,
+                        guildId: execution.guild.id,
+                        ruleId: execution.ruleId,
+                        error: safeError(error),
+                    }, "Module Auto Moderation action event failed");
+                }
+            }
+        }
+        finally {
+            if (evidenceReference)
+                options?.evidenceStore?.discard(evidenceReference);
+        }
+    }
     async function handleGuildMessageCreate(message) {
         if (!message.guildId || !message.channelId)
             return;
@@ -862,6 +1100,7 @@ export function installModuleEvents(client, modules, logger, services) {
             await guildMessageQueue?.stop();
             await queue.stop();
             voiceSessions.clear();
+            privilegedMetadata.clear();
         },
         queueDepth: () => queue.queueDepth() +
             (privilegedEligibilityQueue?.queueDepth() ?? 0) +
@@ -1504,19 +1743,46 @@ export class DiscordResourceInspection {
     }
     async resolveMembers(input) {
         const guild = await this.#resolveMemberGuild(input);
-        return Promise.all(input.userIds.map(async (userId) => {
-            const member = await fetchExactMember(guild, userId, "member").catch((error) => {
+        const members = new Map();
+        for (const userId of input.userIds) {
+            const cached = guild.members.cache?.get(userId);
+            if (cached)
+                members.set(userId, cached);
+        }
+        const missing = input.userIds.filter((userId) => !members.has(userId));
+        const canBulkResolve = this.client.options?.intents?.has(GatewayIntentBits.GuildMembers);
+        if (missing.length > 0 && canBulkResolve) {
+            const fetched = await guild.members
+                .fetch({ user: missing, time: 5_000 })
+                .catch(() => null);
+            if (fetched)
+                for (const member of fetched.values())
+                    if (missing.includes(member.id))
+                        members.set(member.id, member);
+        }
+        else if (missing.length > 0) {
+            const fetched = await Promise.all(missing.map((userId) => fetchExactMember(guild, userId, "member").catch((error) => {
                 if (isUnknownMember(error))
                     return null;
                 throw error;
-            });
+            })));
+            for (const member of fetched)
+                if (member)
+                    members.set(member.id, member);
+        }
+        return input.userIds.map((userId) => {
+            const member = members.get(userId) ?? null;
+            const cachedUser = this.client.users?.cache?.get(userId);
             const avatarUrl = memberAvatarUrl(member);
             return {
                 userId,
-                displayName: member?.displayName ?? null,
+                displayName: member?.displayName ??
+                    cachedUser?.globalName ??
+                    cachedUser?.username ??
+                    null,
                 ...(avatarUrl ? { avatarUrl } : {}),
             };
-        }));
+        });
     }
     async searchMembers(input) {
         validateSnowflake(input.guildId, "guild");
@@ -2061,7 +2327,7 @@ function validateSnowflake(value, label) {
         throw new Error(`Invalid Discord ${label} ID`);
 }
 function discordAuditReason(input) {
-    return `Helyx ${input.moduleId}: ${input.reason.trim()}`;
+    return `Helyx ${input.moduleId}${input.operationKey ? ` ${input.operationKey}` : ""}: ${input.reason.trim()}`.slice(0, 512);
 }
 function normalizePermissionName(permission) {
     return permission.replaceAll(/([a-z0-9])([A-Z])/g, "$1_$2").toUpperCase();

package/dist/guilds.d.ts

@@ -2,6 +2,7 @@ import { type DatabasePool, type GuildShardOwnership } from "@helyx/database";
 import type { ModuleDefinition } from "@helyx/sdk";
 import { type Client } from "discord.js";
 import type { InteractionLogger } from "./interactions.js";
+import type { HostedBotInviteGate, HostedGuildOwnerObserver, HostedGuildSafety } from "./hosted-server-moderation.js";
 export interface GuildReconciliationHealth {
     status: "pending" | "running" | "healthy" | "failed" | "stopped";
     lastStartedAt?: string;
@@ -21,5 +22,5 @@ export interface GuildTrackingPreparation {
     health(): GuildReconciliationHealth;
     stop(): void;
 }
-export declare function installGuildTracking(client: Client, database: DatabasePool, modules: readonly ModuleDefinition[], logger: InteractionLogger, enabledByDefaultModuleIds?: ReadonlySet<string>, ownership?: GuildShardOwnership, reconciliationIntervalMs?: number, shardCount?: number, applicationId?: string): GuildTrackingPreparation;
+export declare function installGuildTracking(client: Client, database: DatabasePool, modules: readonly ModuleDefinition[], logger: InteractionLogger, enabledByDefaultModuleIds?: ReadonlySet<string>, ownership?: GuildShardOwnership, reconciliationIntervalMs?: number, shardCount?: number, applicationId?: string, hostedSafety?: HostedGuildSafety, hostedInviteGate?: HostedBotInviteGate, hostedOwnerObserver?: HostedGuildOwnerObserver | undefined): GuildTrackingPreparation;
 //# sourceMappingURL=guilds.d.ts.map

package/dist/guilds.js

@@ -3,7 +3,7 @@ import { safeError } from "@helyx/core";
 import { Events } from "discord.js";
 const RECONCILIATION_PAGE_SIZE = 250;
 const DEFAULT_RECONCILIATION_INTERVAL_MS = 15 * 60 * 1_000;
-export function installGuildTracking(client, database, modules, logger, enabledByDefaultModuleIds = new Set(), ownership, reconciliationIntervalMs = DEFAULT_RECONCILIATION_INTERVAL_MS, shardCount, applicationId) {
+export function installGuildTracking(client, database, modules, logger, enabledByDefaultModuleIds = new Set(), ownership, reconciliationIntervalMs = DEFAULT_RECONCILIATION_INTERVAL_MS, shardCount, applicationId, hostedSafety, hostedInviteGate, hostedOwnerObserver = hostedSafety) {
     if (!Number.isSafeInteger(reconciliationIntervalMs) ||
         reconciliationIntervalMs < 60_000)
         throw new Error("Guild reconciliation interval must be at least one minute");
@@ -12,6 +12,11 @@ export function installGuildTracking(client, database, modules, logger, enabledB
     let stopped = false;
     let reconciliation;
     let timer;
+    const admissionRetries = new Map();
+    const inviteGateRejections = new Map();
+    const ownerObservations = hostedOwnerObserver
+        ? new OwnerObservationQueue(hostedOwnerObserver, logger)
+        : undefined;
     let health = {
         status: "pending",
         examinedRows: 0,
@@ -21,11 +26,14 @@ export function installGuildTracking(client, database, modules, logger, enabledB
         unavailableGuilds: 0,
     };
     async function syncGuild(guild, firstObservation = false) {
+        const cachedOwner = guild.members?.cache.get(guild.ownerId)?.user ??
+            guild.client?.users.cache.get(guild.ownerId);
         const persist = async (connection) => {
             const installations = new InstallationRepository(connection);
             const record = await installations.syncGuild({
                 guildId: guild.id,
                 ownerUserId: guild.ownerId,
+                ...(cachedOwner ? { ownerUsername: cachedOwner.username } : {}),
                 name: guild.name,
                 ...(ownership ? { ownership } : {}),
             });
@@ -57,17 +65,105 @@ export function installGuildTracking(client, database, modules, logger, enabledB
             await withTransaction(database, persist);
         else
             await persist(database);
+        if (cachedOwner && hostedOwnerObserver)
+            await hostedOwnerObserver.observeOwner(guild);
+        else
+            ownerObservations?.enqueue(guild);
+    }
+    async function leaveInviteRejectedGuild(guild) {
+        const reasonCode = inviteGateRejections.get(guild.id);
+        if (!reasonCode)
+            return;
+        await guild.leave();
+        logger.info({
+            event: "guild.invite_gate_enforced",
+            guildId: guild.id,
+            reasonCode,
+        }, "New guild was rejected by the Bot Invite gate");
+    }
+    async function admitAndSync(guild, firstObservation) {
+        if (inviteGateRejections.has(guild.id)) {
+            await leaveInviteRejectedGuild(guild);
+            return;
+        }
+        const [blacklist, inviteGate] = await Promise.allSettled([
+            hostedSafety
+                ? hostedSafety.isBlacklisted(guild.id)
+                : Promise.resolve(false),
+            hostedInviteGate ? hostedInviteGate.isEnabled() : Promise.resolve(true),
+        ]);
+        if (hostedSafety && blacklist.status === "fulfilled" && blacklist.value) {
+            const enforcement = await Promise.allSettled([
+                hostedSafety.recordAutomaticLeave(guild.id),
+                guild.leave(),
+            ]);
+            if (enforcement.some((result) => result.status === "rejected"))
+                throw new Error("Blacklisted guild enforcement was unavailable");
+            logger.info({ event: "guild.blacklist_enforced", guildId: guild.id }, "Blacklisted guild was rejected before initialization");
+            return;
+        }
+        if (inviteGate.status === "rejected") {
+            inviteGateRejections.set(guild.id, "gate_unavailable");
+            logger.warn({
+                event: "guild.invite_gate_check_failed",
+                guildId: guild.id,
+                reasonCode: "gate_unavailable",
+            }, "Bot Invite gate was unavailable; the new guild will be rejected");
+            await leaveInviteRejectedGuild(guild);
+            return;
+        }
+        if (!inviteGate.value) {
+            inviteGateRejections.set(guild.id, "gate_paused");
+            await leaveInviteRejectedGuild(guild);
+            return;
+        }
+        if (blacklist.status === "rejected")
+            throw new Error("Hosted guild safety lookup was unavailable");
+        await syncGuild(guild, firstObservation);
+        const retry = admissionRetries.get(guild.id);
+        if (retry)
+            clearTimeout(retry);
+        admissionRetries.delete(guild.id);
+    }
+    function scheduleAdmissionRetry(guild) {
+        if (stopped || admissionRetries.has(guild.id))
+            return;
+        const retry = setTimeout(() => {
+            admissionRetries.delete(guild.id);
+            if (stopped || !guild.available)
+                return;
+            void admitAndSync(guild, true).catch(() => {
+                logger.error({
+                    event: "guild.admission_retry_failed",
+                    guildId: guild.id,
+                    reasonCode: "admission_unavailable",
+                }, "Guild admission retry failed");
+                scheduleAdmissionRetry(guild);
+            });
+        }, 30_000);
+        retry.unref();
+        admissionRetries.set(guild.id, retry);
     }
     client.on(Events.GuildCreate, (guild) => {
-        void syncGuild(guild, true).catch((error) => {
+        void admitAndSync(guild, true).catch(() => {
             logger.error({
-                event: "guild.sync_failed",
+                event: "guild.admission_failed",
                 guildId: guild.id,
-                error: safeError(error),
-            }, "Guild installation sync failed");
+                reasonCode: "admission_unavailable",
+            }, "Guild admission failed closed");
+            scheduleAdmissionRetry(guild);
         });
     });
+    client.on(Events.GuildUpdate, (_previous, guild) => {
+        if (!inviteGateRejections.has(guild.id))
+            ownerObservations?.enqueue(guild);
+    });
     client.on(Events.GuildDelete, (guild) => {
+        const retry = admissionRetries.get(guild.id);
+        if (retry)
+            clearTimeout(retry);
+        admissionRetries.delete(guild.id);
+        inviteGateRejections.delete(guild.id);
         void repository
             .markGuildRemoved(guild.id, ownership)
             .then(async (changed) => {
@@ -110,9 +206,23 @@ export function installGuildTracking(client, database, modules, logger, enabledB
             const observedGuildIds = new Set(client.guilds.cache.keys());
             const unavailableGuilds = [...client.guilds.cache.values()].filter((guild) => !guild.available).length;
             try {
+                const blacklistedGuildIds = new Set();
+                if (hostedSafety) {
+                    const observed = [...observedGuildIds];
+                    for (let offset = 0; offset < observed.length; offset += RECONCILIATION_PAGE_SIZE) {
+                        const page = await hostedSafety.blacklistedGuildIds(observed.slice(offset, offset + RECONCILIATION_PAGE_SIZE));
+                        for (const guildId of page)
+                            blacklistedGuildIds.add(guildId);
+                    }
+                }
                 for (const guild of client.guilds.cache.values()) {
                     if (stopped)
                         return;
+                    if (blacklistedGuildIds.has(guild.id)) {
+                        await hostedSafety.recordAutomaticLeave(guild.id);
+                        await guild.leave();
+                        continue;
+                    }
                     await syncGuild(guild);
                     refreshedGuilds += 1;
                 }
@@ -211,8 +321,57 @@ export function installGuildTracking(client, database, modules, logger, enabledB
         if (timer)
             clearInterval(timer);
         timer = undefined;
+        for (const retry of admissionRetries.values())
+            clearTimeout(retry);
+        admissionRetries.clear();
+        inviteGateRejections.clear();
+        ownerObservations?.stop();
         health = { ...health, status: "stopped", nextScheduledAt: undefined };
     };
     return prepare;
 }
+class OwnerObservationQueue {
+    observer;
+    logger;
+    #pending = new Map();
+    #active = 0;
+    #stopped = false;
+    constructor(observer, logger) {
+        this.observer = observer;
+        this.logger = logger;
+    }
+    enqueue(guild) {
+        if (this.#stopped)
+            return;
+        this.#pending.set(guild.id, guild);
+        this.#drain();
+    }
+    stop() {
+        this.#stopped = true;
+        this.#pending.clear();
+    }
+    #drain() {
+        while (!this.#stopped && this.#active < 2 && this.#pending.size > 0) {
+            const next = this.#pending.entries().next().value;
+            if (!next)
+                return;
+            const [guildId, guild] = next;
+            this.#pending.delete(guildId);
+            this.#active += 1;
+            void this.observer
+                .observeOwner(guild)
+                .catch(() => {
+                this.logger.warn({
+                    event: "guild.owner_observation_failed",
+                    guildId,
+                    reasonCode: "owner_identity_unavailable",
+                }, "Guild owner identity observation was deferred");
+            })
+                .finally(() => {
+                this.#active -= 1;
+                this.#drain();
+            });
+        }
+    }
+}
 //# sourceMappingURL=guilds.js.map