@helyx/bot 1.3.0 → 1.4.0

package/dist/guild-command-worker.d.ts

@@ -1,4 +1,5 @@
-import { GuildCommandRepository, type GuildCommandHealth, type GuildCommandRequestRecord } from "@helyx/database";
+import { GuildCommandRepository, InstallationRepository, ModuleAvailabilityRepository, type GuildCommandHealth, type GuildCommandRequestRecord } from "@helyx/database";
+import { type GuildCommandRepository as MysqlGuildCommandRepository, type InstallationRepository as MysqlInstallationRepository, type ModuleAvailabilityRepository as MysqlModuleAvailabilityRepository } from "@helyx/database-mysql";
 import type { Logger, ModuleDefinition } from "@helyx/sdk";
 import type { Pool } from "pg";
 import { type GuildCommandDiff, type GuildCommandProjection } from "./guild-command-projection.js";
@@ -9,10 +10,22 @@ export interface GuildCommandWorkerHealth extends GuildCommandHealth {
     workerRunning: boolean;
     activeCount: number;
 }
+type WorkerCommandRepository = Pick<GuildCommandRepository, "claimDue" | "getHealth" | "heartbeat" | "getState" | "completeDryRun" | "defer" | "markBlocked" | "markFailed" | "completeLive" | "isLeaseCurrent" | "reserveCreations" | "settleCreation"> & Pick<MysqlGuildCommandRepository, "claimDue" | "getHealth" | "heartbeat" | "getState" | "completeDryRun" | "defer" | "markBlocked" | "markFailed" | "completeLive" | "isLeaseCurrent" | "reserveCreations" | "settleCreation">;
+export interface GuildCommandWorkerRepositories {
+    commands: WorkerCommandRepository;
+    installations: Pick<InstallationRepository, "listEnabledModules"> & Pick<MysqlInstallationRepository, "listEnabledModules">;
+    availability: Pick<ModuleAvailabilityRepository, "list"> & Pick<MysqlModuleAvailabilityRepository, "list">;
+}
+type WorkerPersistence = {
+    database: Pool;
+    repositories?: never;
+} | {
+    database?: never;
+    repositories: GuildCommandWorkerRepositories;
+};
 export declare class GuildCommandWorker {
     #private;
     constructor(input: {
-        database: Pool;
         modules: readonly ModuleDefinition[];
         logger: Logger;
         workerId?: string;
@@ -24,13 +37,13 @@ export declare class GuildCommandWorker {
         claimLimit?: number;
         concurrency?: number;
         stopTimeoutMs?: number;
-    });
+    } & WorkerPersistence);
     start(): void;
     runOnce(): Promise<void>;
     stop(): Promise<void>;
     getHealth(): Promise<GuildCommandWorkerHealth>;
 }
-type LiveRepository = Pick<GuildCommandRepository, "completeLive" | "isLeaseCurrent" | "reserveCreations" | "settleCreation">;
+type LiveRepository = Pick<GuildCommandRepository, "completeLive" | "isLeaseCurrent" | "reserveCreations" | "settleCreation"> & Pick<MysqlGuildCommandRepository, "completeLive" | "isLeaseCurrent" | "reserveCreations" | "settleCreation">;
 export declare function reconcileLiveGuildCommands(input: {
     repository: LiveRepository;
     discord: Pick<GuildCommandDiscordClient, "observe" | "replace">;

package/dist/guild-command-worker.js

@@ -1,4 +1,5 @@
 import { GuildCommandBudgetExceededError, GuildCommandRepository, InstallationRepository, ModuleAvailabilityRepository, } from "@helyx/database";
+import { GuildCommandBudgetExceededError as MysqlGuildCommandBudgetExceededError, } from "@helyx/database-mysql";
 import { randomUUID } from "node:crypto";
 import { diffDryRunGuildCommands, diffGuildCommands, projectGuildCommands, } from "./guild-command-projection.js";
 const DEFAULT_POLL_INTERVAL_MS = 1_000;
@@ -8,7 +9,8 @@ const DEFAULT_CONCURRENCY = 2;
 const DEFAULT_STOP_TIMEOUT_MS = 5_000;
 export class GuildCommandWorker {
     #repository;
-    #database;
+    #installations;
+    #availability;
     #modules;
     #logger;
     #workerId;
@@ -28,8 +30,16 @@ export class GuildCommandWorker {
     constructor(input) {
         if (input.fencingToken < 1n)
             throw new Error("Guild command worker fencing token must be positive");
-        this.#database = input.database;
-        this.#repository = new GuildCommandRepository(input.database);
+        const repositories = input.database
+            ? {
+                commands: new GuildCommandRepository(input.database),
+                installations: new InstallationRepository(input.database),
+                availability: new ModuleAvailabilityRepository(input.database),
+            }
+            : input.repositories;
+        this.#repository = repositories.commands;
+        this.#installations = repositories.installations;
+        this.#availability = repositories.availability;
         this.#modules = input.modules;
         this.#logger = input.logger;
         this.#workerId = input.workerId ?? `guild-command:${randomUUID()}`;
@@ -145,8 +155,8 @@ export class GuildCommandWorker {
         heartbeat.unref();
         try {
             const [enabled, availability, state] = await Promise.all([
-                new InstallationRepository(this.#database).listEnabledModules(request.guildId),
-                new ModuleAvailabilityRepository(this.#database).list(),
+                this.#installations.listEnabledModules(request.guildId),
+                this.#availability.list(),
                 this.#repository.getState(request.applicationId, request.guildId),
             ]);
             if (!state || state.desiredRevision !== request.requestedRevision) {
@@ -310,7 +320,8 @@ export async function reconcileLiveGuildCommands(input) {
             })).ledgerId;
         }
         catch (error) {
-            if (error instanceof GuildCommandBudgetExceededError)
+            if (error instanceof GuildCommandBudgetExceededError ||
+                error instanceof MysqlGuildCommandBudgetExceededError)
                 throw new GuildCommandLiveError("creation_budget_exhausted");
             throw error;
         }

package/dist/guilds.d.ts

@@ -1,4 +1,5 @@
-import { type DatabasePool, type GuildShardOwnership } from "@helyx/database";
+import { InstallationRepository, type DatabasePool, type GuildShardOwnership } from "@helyx/database";
+import type { MysqlPool } from "@helyx/database-mysql";
 import type { ModuleDefinition } from "@helyx/sdk";
 import { type Client } from "discord.js";
 import type { InteractionLogger } from "./interactions.js";
@@ -20,7 +21,27 @@ export interface GuildTrackingPreparation {
     (readyClient: Client<true>): Promise<void>;
     reconcile(reason: "ready" | "resume" | "periodic"): Promise<void>;
     health(): GuildReconciliationHealth;
-    stop(): void;
+    stop(): Promise<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, hostedSafety?: HostedGuildSafety, hostedInviteGate?: HostedBotInviteGate, hostedOwnerObserver?: HostedGuildOwnerObserver | undefined): GuildTrackingPreparation;
+interface GuildObservation {
+    guildId: string;
+    ownerUserId: string;
+    ownerUsername?: string;
+    name: string;
+    modules: readonly ModuleDefinition[];
+    enabledByDefaultModuleIds: ReadonlySet<string>;
+    firstObservation: boolean;
+    applicationId?: string;
+    ownership?: GuildShardOwnership;
+    continueObservation?: () => boolean;
+}
+type ReconciliationRepository = Pick<InstallationRepository, "listActiveGuildIdsForOwnership" | "adoptGuildsForReconciliation" | "markGuildsRemovedForReconciliation">;
+export interface GuildTrackingPersistence extends ReconciliationRepository {
+    readonly engine: "postgresql" | "mysql";
+    syncGuild(input: GuildObservation): Promise<void>;
+    markGuildRemoved(guildId: string, ownership: GuildShardOwnership | undefined, applicationId: string | undefined): Promise<boolean>;
+}
+export declare function createMysqlGuildTrackingPersistence(database: MysqlPool): Promise<GuildTrackingPersistence>;
+export declare function installGuildTracking(client: Client, database: DatabasePool | GuildTrackingPersistence, modules: readonly ModuleDefinition[], logger: InteractionLogger, enabledByDefaultModuleIds?: ReadonlySet<string>, ownership?: GuildShardOwnership, reconciliationIntervalMs?: number, shardCount?: number, applicationId?: string, hostedSafety?: HostedGuildSafety, hostedInviteGate?: HostedBotInviteGate, hostedOwnerObserver?: HostedGuildOwnerObserver | undefined): GuildTrackingPreparation;
+export {};
 //# sourceMappingURL=guilds.d.ts.map

package/dist/guilds.js

@@ -3,14 +3,122 @@ import { safeError } from "@helyx/core";
 import { Events } from "discord.js";
 const RECONCILIATION_PAGE_SIZE = 250;
 const DEFAULT_RECONCILIATION_INTERVAL_MS = 15 * 60 * 1_000;
+async function writeGuildObservation(installations, commands, input) {
+    const record = await installations.syncGuild({
+        guildId: input.guildId,
+        ownerUserId: input.ownerUserId,
+        ...(input.ownerUsername ? { ownerUsername: input.ownerUsername } : {}),
+        name: input.name,
+        ...(input.ownership ? { ownership: input.ownership } : {}),
+    });
+    const ownership = input.ownership;
+    if (ownership &&
+        (record.shardGeneration !== ownership.generation ||
+            record.shardDeploymentOrder !== (ownership.deploymentOrder ?? 1n) ||
+            record.shardSupervisorId !== ownership.supervisorId ||
+            record.shardId !== ownership.shardId ||
+            record.shardFencingToken !== ownership.fencingToken))
+        throw new Error("Guild observation was rejected by a newer shard owner");
+    if (input.firstObservation && input.applicationId)
+        await commands.ensureState({
+            applicationId: input.applicationId,
+            guildId: input.guildId,
+            setupState: "incomplete",
+        });
+    for (const module of input.modules) {
+        // First observations remain atomic; refreshes can stop between writes.
+        if (!input.firstObservation && input.continueObservation?.() === false)
+            return;
+        await installations.ensureModule({
+            guildId: input.guildId,
+            moduleId: module.manifest.id,
+            moduleVersion: module.manifest.version,
+            configurationSchemaVersion: module.configuration?.schemaVersion ?? 1,
+            enabledBy: input.ownerUserId,
+            enabledByDefault: input.enabledByDefaultModuleIds.has(module.manifest.id),
+        });
+    }
+}
+function createPostgresqlGuildTrackingPersistence(database) {
+    const repository = new InstallationRepository(database);
+    return {
+        engine: "postgresql",
+        async syncGuild(input) {
+            const persist = (connection) => writeGuildObservation(new InstallationRepository(connection), new GuildCommandRepository(connection), input);
+            if (input.firstObservation)
+                await withTransaction(database, persist);
+            else
+                await persist(database);
+        },
+        async markGuildRemoved(guildId, ownership, applicationId) {
+            const changed = await repository.markGuildRemoved(guildId, ownership);
+            if (changed && applicationId)
+                await new GuildCommandRepository(database).cancelGuildWork(applicationId, guildId);
+            return changed;
+        },
+        listActiveGuildIdsForOwnership: (input) => repository.listActiveGuildIdsForOwnership(input),
+        adoptGuildsForReconciliation: (input) => repository.adoptGuildsForReconciliation(input),
+        markGuildsRemovedForReconciliation: (input) => repository.markGuildsRemovedForReconciliation(input),
+    };
+}
+export async function createMysqlGuildTrackingPersistence(database) {
+    const { InstallationRepository: MysqlInstallationRepository, GuildCommandRepository: MysqlGuildCommandRepository, createMysqlQueryExecutor, withMysqlTransaction, } = await import("@helyx/database-mysql");
+    const repository = new MysqlInstallationRepository(database);
+    return {
+        engine: "mysql",
+        async syncGuild(input) {
+            if (input.ownership)
+                throw new Error("MySQL guild tracking does not support shard ownership");
+            if (input.firstObservation) {
+                await withMysqlTransaction(database, (connection) => {
+                    const executor = createMysqlQueryExecutor(connection);
+                    return writeGuildObservation(new MysqlInstallationRepository(executor), new MysqlGuildCommandRepository(executor), input);
+                });
+            }
+            else {
+                await writeGuildObservation(new MysqlInstallationRepository(database), new MysqlGuildCommandRepository(database), input);
+            }
+        },
+        async markGuildRemoved(guildId, ownership, applicationId) {
+            if (ownership)
+                throw new Error("MySQL guild tracking does not support shard ownership");
+            return withMysqlTransaction(database, async (connection) => {
+                const executor = createMysqlQueryExecutor(connection);
+                const changed = await new MysqlInstallationRepository(executor).markGuildRemoved(guildId);
+                if (changed && applicationId)
+                    await new MysqlGuildCommandRepository(executor).cancelGuildWork(applicationId, guildId);
+                return changed;
+            });
+        },
+        listActiveGuildIdsForOwnership: (input) => {
+            if (input.ownership)
+                throw new Error("MySQL guild tracking does not support shard ownership");
+            return repository.listActiveGuildIdsForOwnership(input);
+        },
+        adoptGuildsForReconciliation: () => {
+            throw new Error("MySQL guild tracking does not support shard ownership");
+        },
+        markGuildsRemovedForReconciliation: (input) => {
+            if (input.ownership)
+                throw new Error("MySQL guild tracking does not support shard ownership");
+            return repository.markGuildsRemovedForReconciliation(input);
+        },
+    };
+}
 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");
-    const repository = new InstallationRepository(database);
+    const persistence = "engine" in database
+        ? database
+        : createPostgresqlGuildTrackingPersistence(database);
+    if (persistence.engine === "mysql" && ownership)
+        throw new Error("MySQL guild tracking does not support shard ownership");
     let prepared = false;
     let stopped = false;
     let reconciliation;
+    let stopPromise;
+    const inFlightOperations = new Set();
     let timer;
     const admissionRetries = new Map();
     const inviteGateRejections = new Map();
@@ -25,46 +133,29 @@ export function installGuildTracking(client, database, modules, logger, enabledB
         rejectedFences: 0,
         unavailableGuilds: 0,
     };
+    function trackOperation(operation) {
+        const settled = operation.then(() => undefined, () => undefined);
+        inFlightOperations.add(settled);
+        void settled.then(() => inFlightOperations.delete(settled));
+        return operation;
+    }
     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 } : {}),
-            });
-            if (ownership &&
-                (record.shardGeneration !== ownership.generation ||
-                    record.shardDeploymentOrder !== (ownership.deploymentOrder ?? 1n) ||
-                    record.shardSupervisorId !== ownership.supervisorId ||
-                    record.shardId !== ownership.shardId ||
-                    record.shardFencingToken !== ownership.fencingToken))
-                throw new Error("Guild observation was rejected by a newer shard owner");
-            if (firstObservation && applicationId)
-                await new GuildCommandRepository(connection).ensureState({
-                    applicationId,
-                    guildId: guild.id,
-                    setupState: "incomplete",
-                });
-            for (const module of modules) {
-                await installations.ensureModule({
-                    guildId: guild.id,
-                    moduleId: module.manifest.id,
-                    moduleVersion: module.manifest.version,
-                    configurationSchemaVersion: module.configuration?.schemaVersion ?? 1,
-                    enabledBy: guild.ownerId,
-                    enabledByDefault: enabledByDefaultModuleIds.has(module.manifest.id),
-                });
-            }
-        };
-        if (firstObservation)
-            await withTransaction(database, persist);
-        else
-            await persist(database);
+        await persistence.syncGuild({
+            guildId: guild.id,
+            ownerUserId: guild.ownerId,
+            ...(cachedOwner ? { ownerUsername: cachedOwner.username } : {}),
+            name: guild.name,
+            modules,
+            enabledByDefaultModuleIds,
+            firstObservation,
+            continueObservation: () => !stopped,
+            ...(applicationId ? { applicationId } : {}),
+            ...(ownership ? { ownership } : {}),
+        });
+        if (stopped)
+            return;
         if (cachedOwner && hostedOwnerObserver)
             await hostedOwnerObserver.observeOwner(guild);
         else
@@ -82,6 +173,8 @@ export function installGuildTracking(client, database, modules, logger, enabledB
         }, "New guild was rejected by the Bot Invite gate");
     }
     async function admitAndSync(guild, firstObservation) {
+        if (stopped)
+            return;
         if (inviteGateRejections.has(guild.id)) {
             await leaveInviteRejectedGuild(guild);
             return;
@@ -92,6 +185,8 @@ export function installGuildTracking(client, database, modules, logger, enabledB
                 : Promise.resolve(false),
             hostedInviteGate ? hostedInviteGate.isEnabled() : Promise.resolve(true),
         ]);
+        if (stopped)
+            return;
         if (hostedSafety && blacklist.status === "fulfilled" && blacklist.value) {
             const enforcement = await Promise.allSettled([
                 hostedSafety.recordAutomaticLeave(guild.id),
@@ -132,7 +227,7 @@ export function installGuildTracking(client, database, modules, logger, enabledB
             admissionRetries.delete(guild.id);
             if (stopped || !guild.available)
                 return;
-            void admitAndSync(guild, true).catch(() => {
+            void trackOperation(admitAndSync(guild, true)).catch(() => {
                 logger.error({
                     event: "guild.admission_retry_failed",
                     guildId: guild.id,
@@ -145,7 +240,9 @@ export function installGuildTracking(client, database, modules, logger, enabledB
         admissionRetries.set(guild.id, retry);
     }
     client.on(Events.GuildCreate, (guild) => {
-        void admitAndSync(guild, true).catch(() => {
+        if (stopped)
+            return;
+        void trackOperation(admitAndSync(guild, true)).catch(() => {
             logger.error({
                 event: "guild.admission_failed",
                 guildId: guild.id,
@@ -155,20 +252,21 @@ export function installGuildTracking(client, database, modules, logger, enabledB
         });
     });
     client.on(Events.GuildUpdate, (_previous, guild) => {
+        if (stopped)
+            return;
         if (!inviteGateRejections.has(guild.id))
             ownerObservations?.enqueue(guild);
     });
     client.on(Events.GuildDelete, (guild) => {
+        if (stopped)
+            return;
         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) => {
-            if (changed && applicationId)
-                await new GuildCommandRepository(database).cancelGuildWork(applicationId, guild.id);
+        void trackOperation(persistence.markGuildRemoved(guild.id, ownership, applicationId))
+            .then((changed) => {
             logger.info({
                 event: "guild.removed",
                 outcome: changed ? "changed" : "rejected_or_duplicate",
@@ -210,6 +308,8 @@ export function installGuildTracking(client, database, modules, logger, enabledB
                 if (hostedSafety) {
                     const observed = [...observedGuildIds];
                     for (let offset = 0; offset < observed.length; offset += RECONCILIATION_PAGE_SIZE) {
+                        if (stopped)
+                            return;
                         const page = await hostedSafety.blacklistedGuildIds(observed.slice(offset, offset + RECONCILIATION_PAGE_SIZE));
                         for (const guildId of page)
                             blacklistedGuildIds.add(guildId);
@@ -224,30 +324,38 @@ export function installGuildTracking(client, database, modules, logger, enabledB
                         continue;
                     }
                     await syncGuild(guild);
+                    if (stopped)
+                        return;
                     refreshedGuilds += 1;
                 }
                 let cursor;
                 do {
                     if (stopped || !client.isReady())
                         return;
-                    const page = await repository.listActiveGuildIdsForOwnership({
+                    const page = await persistence.listActiveGuildIdsForOwnership({
                         ...(ownership ? { ownership } : {}),
                         ...(ownership && shardCount !== undefined ? { shardCount } : {}),
                         ...(cursor ? { cursor } : {}),
                         limit: RECONCILIATION_PAGE_SIZE,
                     });
+                    if (stopped)
+                        return;
                     examinedRows += page.guildIds.length;
                     if (ownership)
-                        await repository.adoptGuildsForReconciliation({
+                        await persistence.adoptGuildsForReconciliation({
                             guildIds: page.guildIds,
                             ownership,
                             shardCount: shardCount,
                         });
+                    if (stopped)
+                        return;
                     const absent = page.guildIds.filter((guildId) => !observedGuildIds.has(guildId));
-                    const result = await repository.markGuildsRemovedForReconciliation({
+                    const result = await persistence.markGuildsRemovedForReconciliation({
                         guildIds: absent,
                         ...(ownership ? { ownership } : {}),
                     });
+                    if (stopped)
+                        return;
                     removedGuilds += result.changed;
                     rejectedFences += result.rejectedFence;
                     cursor = page.nextCursor;
@@ -277,22 +385,23 @@ export function installGuildTracking(client, database, modules, logger, enabledB
                 }, "Discord guild presence reconciliation completed");
             }
             catch (error) {
-                health = {
-                    status: "failed",
-                    lastStartedAt: new Date(startedAt).toISOString(),
-                    durationMs: Date.now() - startedAt,
-                    examinedRows,
-                    refreshedGuilds,
-                    removedGuilds,
-                    rejectedFences,
-                    unavailableGuilds,
-                    failureReasonCode: "reconciliation_failed",
-                    nextScheduledAt: new Date(Date.now() + reconciliationIntervalMs).toISOString(),
-                };
+                if (!stopped)
+                    health = {
+                        status: "failed",
+                        lastStartedAt: new Date(startedAt).toISOString(),
+                        durationMs: Date.now() - startedAt,
+                        examinedRows,
+                        refreshedGuilds,
+                        removedGuilds,
+                        rejectedFences,
+                        unavailableGuilds,
+                        failureReasonCode: "reconciliation_failed",
+                        nextScheduledAt: new Date(Date.now() + reconciliationIntervalMs).toISOString(),
+                    };
                 logger.error({
                     event: "guild.reconciliation_failed",
                     reason,
-                    reasonCode: health.failureReasonCode,
+                    reasonCode: "reconciliation_failed",
                     error: safeError(error),
                 }, "Discord guild presence reconciliation failed");
             }
@@ -306,7 +415,7 @@ export function installGuildTracking(client, database, modules, logger, enabledB
             return;
         prepared = true;
         await runReconciliation("ready");
-        if (!timer) {
+        if (!stopped && !timer) {
             timer = setInterval(() => void runReconciliation("periodic"), reconciliationIntervalMs);
             timer.unref();
         }
@@ -317,6 +426,8 @@ export function installGuildTracking(client, database, modules, logger, enabledB
     prepare.reconcile = runReconciliation;
     prepare.health = () => ({ ...health });
     prepare.stop = () => {
+        if (stopPromise)
+            return stopPromise;
         stopped = true;
         if (timer)
             clearInterval(timer);
@@ -325,8 +436,14 @@ export function installGuildTracking(client, database, modules, logger, enabledB
             clearTimeout(retry);
         admissionRetries.clear();
         inviteGateRejections.clear();
-        ownerObservations?.stop();
+        const ownerDrain = ownerObservations?.stop();
         health = { ...health, status: "stopped", nextScheduledAt: undefined };
+        stopPromise = Promise.allSettled([
+            ...inFlightOperations,
+            ...(reconciliation ? [reconciliation] : []),
+            ...(ownerDrain ? [ownerDrain] : []),
+        ]).then(() => undefined);
+        return stopPromise;
     };
     return prepare;
 }
@@ -336,6 +453,7 @@ class OwnerObservationQueue {
     #pending = new Map();
     #active = 0;
     #stopped = false;
+    #inFlight = new Set();
     constructor(observer, logger) {
         this.observer = observer;
         this.logger = logger;
@@ -349,6 +467,7 @@ class OwnerObservationQueue {
     stop() {
         this.#stopped = true;
         this.#pending.clear();
+        return Promise.allSettled([...this.#inFlight]).then(() => undefined);
     }
     #drain() {
         while (!this.#stopped && this.#active < 2 && this.#pending.size > 0) {
@@ -358,7 +477,7 @@ class OwnerObservationQueue {
             const [guildId, guild] = next;
             this.#pending.delete(guildId);
             this.#active += 1;
-            void this.observer
+            const observation = this.observer
                 .observeOwner(guild)
                 .catch(() => {
                 this.logger.warn({
@@ -368,9 +487,11 @@ class OwnerObservationQueue {
                 }, "Guild owner identity observation was deferred");
             })
                 .finally(() => {
+                this.#inFlight.delete(observation);
                 this.#active -= 1;
                 this.#drain();
             });
+            this.#inFlight.add(observation);
         }
     }
 }

package/dist/hosted-server-moderation.d.ts

@@ -11,8 +11,8 @@ declare const resultSchema: z.ZodObject<{
     }>;
     outcome: z.ZodEnum<{
         completed: "completed";
-        requires_review: "requires_review";
         failed: "failed";
+        requires_review: "requires_review";
         queued: "queued";
         not_currently_installed: "not_currently_installed";
         accepted_for_retry: "accepted_for_retry";
@@ -45,7 +45,7 @@ export declare class HostedServerModerationClient implements DeveloperServerMode
         idempotencyKey: string;
     }): Promise<{
         operationId: string;
-        outcome: "completed" | "requires_review" | "failed" | "queued" | "not_currently_installed" | "accepted_for_retry" | "already_blacklisted";
+        outcome: "completed" | "failed" | "requires_review" | "queued" | "not_currently_installed" | "accepted_for_retry" | "already_blacklisted";
         paidSlotsReleased: number;
     }>;
 }

package/dist/hosted-server-moderation.js

@@ -168,14 +168,20 @@ export class HostedServerLeaveWorker {
         });
     }
     async #deliver(claim) {
+        const outcome = await this.#repository.withLeaveDeliveryGuard(claim, (connection) => this.#deliverGuarded(claim, connection));
+        return (outcome ??
+            (await this.#repository.getLeaveDeliveryOutcome(claim.operationId, claim.guildId)) ??
+            "queued");
+    }
+    async #deliverGuarded(claim, connection) {
         const guild = this.client.guilds.cache.get(claim.guildId);
         if (!guild) {
-            await this.#repository.completeLeaveDelivery(claim, "not_currently_installed");
+            await this.#repository.completeLeaveDelivery(claim, "not_currently_installed", connection);
             return "not_currently_installed";
         }
         try {
             await guild.leave();
-            await this.#repository.completeLeaveDelivery(claim, "completed");
+            await this.#repository.completeLeaveDelivery(claim, "completed", connection);
             this.logger.info({
                 event: "hosted_moderation.leave_completed",
                 guildId: claim.guildId,
@@ -186,14 +192,14 @@ export class HostedServerLeaveWorker {
         catch (error) {
             const failureCode = classifyLeaveFailure(error);
             if (failureCode === "discord_not_installed") {
-                await this.#repository.completeLeaveDelivery(claim, "not_currently_installed");
+                await this.#repository.completeLeaveDelivery(claim, "not_currently_installed", connection);
                 return "not_currently_installed";
             }
             const outcome = await this.#repository.failLeaveDelivery({
                 claim,
                 failureCode,
                 retryAfterSeconds: Math.min(3_600, 15 * 2 ** claim.attemptCount),
-            });
+            }, connection);
             this.logger.warn({
                 event: "hosted_moderation.leave_deferred",
                 guildId: claim.guildId,

package/dist/index.d.ts

@@ -2,6 +2,7 @@ import { type ModuleDefinition } from "@helyx/sdk";
 import { GatewayIntentBits } from "discord.js";
 import { type ShardHealthSnapshot } from "./shard-contracts.js";
 export { loadConfiguredModulePackages } from "./modules.js";
+export { assertConfiguredModuleDatabaseCompatibility } from "./modules.js";
 export { resolveModulePackageSpecifiers } from "./module-configuration.js";
 export * from "./control-server.js";
 export interface BotHandle {