@helyx/bot 1.5.1 → 1.5.3

package/dist/message-protection-coordinator.d.ts

@@ -0,0 +1,73 @@
+import type { Client, Guild } from "discord.js";
+import type { ModuleDefinition } from "@helyx/sdk";
+import type { LocalModuleMutationObserver } from "@helyx/platform";
+import { type MessageProtectionOwnerIdentity, type MessageProtectionOwnerPort } from "@helyx/database-contracts";
+import type { MessageProtectionEligibility } from "./guild-message-protection-delivery.js";
+import type { MessageProtectionColdResult, MessageProtectionColdScope } from "./message-protection-cold-data.js";
+import type { MessageProtectionSettingsLoader } from "./message-protection-settings.js";
+export interface MessageProtectionGuildObserver {
+    ready(): void;
+    beforeSync(guild: Guild): (() => void) | undefined;
+    invalidateGuild(guildId: string): void;
+    invalidateAll(): void;
+}
+/**
+ * Dormant standalone composition. No production construction, SQL on messages,
+ * module authority, timer, automatic reconnect/reclaim or sharded-mode grant.
+ */
+export declare class MessageProtectionCoordinator {
+    #private;
+    private readonly options;
+    readonly eligibility: MessageProtectionEligibility;
+    readonly guildObserver: MessageProtectionGuildObserver;
+    readonly localModuleMutations: LocalModuleMutationObserver;
+    constructor(options: {
+        identity: MessageProtectionOwnerIdentity;
+        client: Client;
+        owners: MessageProtectionOwnerPort;
+        coldData: {
+            read(scope: MessageProtectionColdScope): Promise<MessageProtectionColdResult>;
+        };
+        settings: MessageProtectionSettingsLoader;
+        leaseMs: number;
+        maximumAgeMs: number;
+        capacity: number;
+        maximumConcurrentReads: number;
+        maximumConcurrentMutations: number;
+        modules: readonly ModuleDefinition[];
+        now?: () => number;
+    });
+    /** Call once at accepted ready identity; a failed boot never recaptures. */
+    start(): Promise<boolean>;
+    renew(): Promise<boolean>;
+    /** Gateway ready/resume does not restore guild epochs or old tokens. */
+    resume(): boolean;
+    disconnect(): void;
+    invalidateGuild(guildId: string): void;
+    private invalidateGuildAdmissions;
+    invalidateScope(scope: MessageProtectionColdScope): void;
+    get pendingReadCount(): number;
+    get activeLocalMutationCount(): number;
+    get localReloadJobCount(): number;
+    whenLocalReloadsSettled(): Promise<void>;
+    reload(scope: MessageProtectionColdScope): Promise<boolean>;
+    private reloadReserved;
+    /** Revocation is synchronous; durable release/drain follows it. */
+    stop(): Promise<void>;
+    private beforeSync;
+    private beginLocalMutation;
+    private enqueueLocalReload;
+    private startLocalDrain;
+    private drainLocalReloads;
+    private sourceGuild;
+    private guildCurrent;
+    private readyIdentity;
+    private ownerCurrent;
+    private acceptLease;
+    private time;
+    private revoke;
+    private pruneTokens;
+    private deleteToken;
+    private releaseQuietly;
+}
+//# sourceMappingURL=message-protection-coordinator.d.ts.map

package/dist/message-protection-coordinator.js

@@ -0,0 +1,622 @@
+import { createHash } from "node:crypto";
+import { assertMessageProtectionOwnerIdentity, assertMessageProtectionOwnerLease, assertMessageProtectionOwnerLeaseMs, } from "@helyx/database-contracts";
+import { MessageProtectionAdmissionPublisher } from "./message-protection-admission.js";
+const unavailable = Object.freeze({ state: "unavailable" });
+/**
+ * Dormant standalone composition. No production construction, SQL on messages,
+ * module authority, timer, automatic reconnect/reclaim or sharded-mode grant.
+ */
+export class MessageProtectionCoordinator {
+    options;
+    eligibility;
+    guildObserver;
+    localModuleMutations;
+    #identity;
+    #publisher;
+    #guilds = new Map();
+    #tokens = new Map();
+    #scopeTokens = new Map();
+    #reloads = new Map();
+    #pendingReads = new Map();
+    #localHolds = new Map();
+    #localJobs = new Map();
+    #localModuleIds;
+    #activeLocalMutations = 0;
+    #localDrain;
+    #clock;
+    #lastNow = -Infinity;
+    #started = false;
+    #stopped = false;
+    #gatewayReady = false;
+    #gatewayEpoch = 0n;
+    #guildEpoch = 0n;
+    #lease;
+    #ownerDeadline = -Infinity;
+    #renewal;
+    #stop;
+    constructor(options) {
+        this.options = options;
+        assertMessageProtectionOwnerIdentity(options.identity);
+        assertMessageProtectionOwnerLeaseMs(options.leaseMs);
+        if (!Number.isSafeInteger(options.maximumConcurrentMutations) ||
+            options.maximumConcurrentMutations < 1 ||
+            options.maximumConcurrentMutations > 256)
+            throw new TypeError("Invalid protection mutation concurrency");
+        const moduleIds = options.modules
+            .filter((module) => Boolean(module.events?.guildMessageUpdateMetadata?.length) ||
+            module.events?.guildMessageCreate?.some((contribution) => contribution.protection))
+            .map((module) => module.manifest.id);
+        if (moduleIds.length > options.capacity ||
+            new Set(moduleIds).size !== moduleIds.length)
+            throw new TypeError("Invalid protection reload recipients");
+        this.#localModuleIds = Object.freeze(moduleIds);
+        if (!Number.isSafeInteger(options.maximumConcurrentReads) ||
+            options.maximumConcurrentReads < 1 ||
+            options.maximumConcurrentReads > Math.min(options.capacity, 256))
+            throw new TypeError("Invalid protection cold-read concurrency");
+        this.#identity = Object.freeze({ ...options.identity });
+        this.options = Object.freeze({ ...options, identity: this.#identity });
+        this.#clock = options.now ?? (() => performance.now());
+        this.#publisher = new MessageProtectionAdmissionPublisher({
+            owner: { ...this.#identity, mode: "standalone" },
+            capacity: options.capacity,
+            maxAgeMs: options.maximumAgeMs,
+            now: () => this.time(),
+        });
+        this.eligibility = Object.freeze({
+            read: (guildId, moduleId) => {
+                if (!this.ownerCurrent() ||
+                    this.#localHolds.has(guildId) ||
+                    !this.guildCurrent(guildId) ||
+                    !this.options.settings.isCurrent({ moduleId }))
+                    return unavailable;
+                const admission = this.#publisher.eligibility.read(guildId, moduleId);
+                if (admission.state !== "enabled")
+                    return admission;
+                const key = scopeKey({ guildId, moduleId });
+                const previous = this.#scopeTokens.get(key);
+                if (previous && previous !== admission.generation)
+                    this.#tokens.delete(previous);
+                if (!this.#tokens.has(admission.generation) &&
+                    this.#tokens.size >= options.capacity)
+                    this.pruneTokens();
+                if (!this.#tokens.has(admission.generation) &&
+                    this.#tokens.size >= options.capacity)
+                    return unavailable;
+                this.#tokens.set(admission.generation, {
+                    token: admission.generation,
+                    scope: { guildId, moduleId },
+                });
+                this.#scopeTokens.set(key, admission.generation);
+                return admission;
+            },
+            isCurrent: (token) => {
+                const entry = this.#tokens.get(token);
+                return Boolean(entry &&
+                    !this.#localHolds.has(entry.scope.guildId) &&
+                    this.ownerCurrent() &&
+                    this.guildCurrent(entry.scope.guildId) &&
+                    this.options.settings.isCurrent(entry.scope) &&
+                    this.#publisher.eligibility.isCurrent(token));
+            },
+        });
+        this.guildObserver = Object.freeze({
+            ready: () => {
+                this.resume();
+            },
+            beforeSync: (guild) => this.beforeSync(guild),
+            invalidateGuild: (guildId) => this.invalidateGuild(guildId),
+            invalidateAll: () => this.disconnect(),
+        });
+        this.localModuleMutations = Object.freeze({
+            begin: (scope) => this.beginLocalMutation(scope.guildId),
+        });
+    }
+    /** Call once at accepted ready identity; a failed boot never recaptures. */
+    async start() {
+        if (this.#started || this.#stopped)
+            return false;
+        this.#started = true;
+        if (!this.readyIdentity()) {
+            this.revoke();
+            return false;
+        }
+        const gatewayEpoch = this.#gatewayEpoch;
+        try {
+            const capture = await this.options.owners.capture(this.#identity);
+            if (this.#stopped ||
+                gatewayEpoch !== this.#gatewayEpoch ||
+                !this.readyIdentity()) {
+                this.revoke();
+                return false;
+            }
+            const capturedAt = this.time();
+            if (!Number.isFinite(capturedAt))
+                return false;
+            const lease = await this.options.owners.claim({
+                capture,
+                leaseMs: this.options.leaseMs,
+            });
+            if (!lease) {
+                this.revoke();
+                return false;
+            }
+            if (this.#stopped ||
+                gatewayEpoch !== this.#gatewayEpoch ||
+                !this.readyIdentity() ||
+                !this.acceptLease(lease, capturedAt, capture)) {
+                this.revoke();
+                await this.releaseQuietly(lease);
+                return false;
+            }
+            this.#gatewayReady = true;
+            return true;
+        }
+        catch {
+            this.revoke();
+            return false;
+        }
+    }
+    renew() {
+        if (this.#renewal)
+            return this.#renewal;
+        if (!this.ownerCurrent() || !this.#lease)
+            return Promise.resolve(false);
+        const lease = this.#lease;
+        const capturedAt = this.time();
+        this.#renewal = (async () => {
+            try {
+                const renewed = await this.options.owners.renew({
+                    lease,
+                    leaseMs: this.options.leaseMs,
+                });
+                if (!renewed) {
+                    this.revoke();
+                    return false;
+                }
+                // A delayed response may not revive a lease whose prior local budget expired.
+                if (this.#stopped ||
+                    !this.ownerCurrent() ||
+                    !this.acceptLease(renewed, capturedAt, lease)) {
+                    this.revoke();
+                    await this.releaseQuietly(renewed);
+                    return false;
+                }
+                return true;
+            }
+            catch {
+                this.revoke();
+                return false;
+            }
+            finally {
+                this.#renewal = undefined;
+            }
+        })();
+        return this.#renewal;
+    }
+    /** Gateway ready/resume does not restore guild epochs or old tokens. */
+    resume() {
+        if (!this.ownerCurrent() || !this.readyIdentity())
+            return false;
+        this.#gatewayReady = true;
+        return true;
+    }
+    disconnect() {
+        this.#gatewayEpoch += 1n;
+        this.#gatewayReady = false;
+        this.#publisher.invalidateAll();
+        this.#guilds.clear();
+        this.#tokens.clear();
+        this.#scopeTokens.clear();
+        this.#reloads.clear();
+        this.#localJobs.clear();
+    }
+    invalidateGuild(guildId) {
+        this.#guilds.delete(guildId);
+        this.#localJobs.delete(guildId);
+        this.invalidateGuildAdmissions(guildId);
+    }
+    invalidateGuildAdmissions(guildId) {
+        this.#publisher.invalidateGuild(guildId);
+        for (const [token, entry] of this.#tokens)
+            if (entry.scope.guildId === guildId)
+                this.deleteToken(token, entry);
+        for (const key of this.#reloads.keys())
+            if (key.startsWith(`${guildId}:`))
+                this.#reloads.delete(key);
+    }
+    invalidateScope(scope) {
+        this.#publisher.invalidateScope(scope);
+        this.#reloads.delete(scopeKey(scope));
+        const token = this.#scopeTokens.get(scopeKey(scope));
+        const entry = token ? this.#tokens.get(token) : undefined;
+        if (token && entry)
+            this.deleteToken(token, entry);
+    }
+    get pendingReadCount() {
+        return this.#pendingReads.size;
+    }
+    get activeLocalMutationCount() {
+        return this.#activeLocalMutations;
+    }
+    get localReloadJobCount() {
+        return this.#localJobs.size;
+    }
+    async whenLocalReloadsSettled() {
+        while (this.#localDrain)
+            await this.#localDrain;
+    }
+    reload(scope) {
+        const key = scopeKey(scope);
+        const pending = this.#pendingReads.get(key);
+        if (pending)
+            return pending;
+        if (this.#stopped ||
+            this.#localHolds.has(scope.guildId) ||
+            this.#pendingReads.size >= this.options.maximumConcurrentReads)
+            return Promise.resolve(false);
+        const stableScope = Object.freeze({
+            guildId: scope.guildId,
+            moduleId: scope.moduleId,
+        });
+        // Reserve before invoking any reader, including a synchronously reentrant port.
+        const operation = Promise.resolve()
+            .then(() => this.reloadReserved(stableScope))
+            .finally(() => {
+            if (this.#pendingReads.get(key) === operation)
+                this.#pendingReads.delete(key);
+        });
+        this.#pendingReads.set(key, operation);
+        return operation;
+    }
+    async reloadReserved(scope) {
+        if (!this.ownerCurrent() ||
+            this.#localHolds.has(scope.guildId) ||
+            !this.guildCurrent(scope.guildId))
+            return false;
+        const guild = this.#guilds.get(scope.guildId);
+        const ticket = this.#publisher.captureReload(scope);
+        if (!ticket)
+            return false;
+        const key = scopeKey(scope);
+        this.#reloads.set(key, ticket);
+        let data;
+        try {
+            data = await this.options.coldData.read(scope);
+        }
+        catch {
+            if (this.#reloads.get(key) === ticket)
+                this.invalidateScope(scope);
+            return false;
+        }
+        if (this.#reloads.get(key) !== ticket)
+            return false;
+        if (!this.ownerCurrent() ||
+            this.#localHolds.has(scope.guildId) ||
+            !this.guildCurrent(scope.guildId) ||
+            this.#guilds.get(scope.guildId) !== guild ||
+            data.kind !== "observed" ||
+            data.configuredApplicationId !== this.#identity.applicationId ||
+            data.scope.guildId !== scope.guildId ||
+            data.scope.moduleId !== scope.moduleId) {
+            this.invalidateScope(scope);
+            return false;
+        }
+        // This first slice admits standalone observations only; old shard tuples hold.
+        if (data.guild?.ownership.kind !== "unbound") {
+            this.invalidateScope(scope);
+            return false;
+        }
+        // This await retains the original ticket, capture deadline and pending-read slot.
+        let settings;
+        try {
+            settings = await this.options.settings.read(data);
+        }
+        catch {
+            if (this.#reloads.get(key) === ticket)
+                this.invalidateScope(scope);
+            return false;
+        }
+        if (this.#reloads.get(key) !== ticket)
+            return false;
+        if (!this.ownerCurrent() ||
+            this.#localHolds.has(scope.guildId) ||
+            !this.guildCurrent(scope.guildId) ||
+            this.#guilds.get(scope.guildId) !== guild ||
+            settings.kind === "unavailable" ||
+            !/^[a-f0-9]{64}$/u.test(settings.revisionFingerprint)) {
+            this.invalidateScope(scope);
+            return false;
+        }
+        const expiresAt = Math.min(this.#ownerDeadline, data.freshness.expiresAt, ticket.capturedAt + this.options.maximumAgeMs);
+        const now = this.time();
+        if (!Number.isFinite(now) ||
+            !Number.isFinite(expiresAt) ||
+            !Number.isFinite(data.freshness.capturedAt) ||
+            !Number.isFinite(data.freshness.completedAt) ||
+            expiresAt <= now ||
+            data.freshness.capturedAt < ticket.capturedAt ||
+            data.freshness.completedAt < data.freshness.capturedAt ||
+            data.freshness.completedAt > now ||
+            !/^[a-f0-9]{64}$/u.test(data.revisionFingerprint) ||
+            !this.options.settings.isCurrent(scope)) {
+            this.invalidateScope(scope);
+            return false;
+        }
+        const enabled = Boolean(data.guild &&
+            data.installation?.enabled &&
+            !(data.availability.present && data.availability.globallyDisabled) &&
+            data.tierAccess.granted);
+        const revisionFingerprint = createHash("sha256")
+            .update(JSON.stringify([
+            1,
+            this.#identity,
+            this.#lease?.lineageId,
+            this.#lease?.ownershipId,
+            guild.epoch,
+            data.revisionFingerprint,
+            settings.revisionFingerprint,
+        ]))
+            .digest("hex");
+        this.#reloads.delete(key);
+        return this.#publisher.publish(ticket, {
+            state: enabled ? "enabled" : "disabled",
+            revisionFingerprint,
+            validForMs: expiresAt - ticket.capturedAt,
+        });
+    }
+    /** Revocation is synchronous; durable release/drain follows it. */
+    stop() {
+        if (this.#stop)
+            return this.#stop;
+        this.revoke();
+        this.#stop = (async () => {
+            await this.#renewal;
+            if (this.#lease)
+                await this.releaseQuietly(this.#lease);
+        })();
+        return this.#stop;
+    }
+    beforeSync(guild) {
+        if (!this.ownerCurrent() || !this.#gatewayReady || !this.sourceGuild(guild))
+            return undefined;
+        let entry = this.#guilds.get(guild.id);
+        if (!entry || entry.guild !== guild) {
+            if (!entry && this.#guilds.size >= this.options.capacity)
+                return undefined;
+            this.invalidateGuild(guild.id);
+            entry = { guild, epoch: String(++this.#guildEpoch), accepted: false };
+            this.#guilds.set(guild.id, entry);
+        }
+        const captured = entry;
+        let used = false;
+        return () => {
+            if (used)
+                return;
+            used = true;
+            if (this.ownerCurrent() &&
+                this.#gatewayReady &&
+                this.#guilds.get(guild.id) === captured &&
+                this.sourceGuild(guild))
+                captured.accepted = true;
+        };
+    }
+    beginLocalMutation(guildId) {
+        if (!/^\d{17,20}$/u.test(guildId))
+            throw new TypeError("Invalid protection mutation guild");
+        if (this.#stopped)
+            return Object.freeze({ settled() { } });
+        if (this.#activeLocalMutations >= this.options.maximumConcurrentMutations) {
+            this.revoke();
+            throw new Error("Protection local mutation capacity exceeded");
+        }
+        this.invalidateGuildAdmissions(guildId);
+        this.#localJobs.delete(guildId);
+        let hold = this.#localHolds.get(guildId);
+        if (!hold) {
+            hold = { count: 0 };
+            this.#localHolds.set(guildId, hold);
+        }
+        hold.count++;
+        this.#activeLocalMutations++;
+        const captured = hold;
+        let settled = false;
+        return Object.freeze({
+            settled: () => {
+                if (settled)
+                    return;
+                settled = true;
+                this.#activeLocalMutations--;
+                captured.count--;
+                if (this.#localHolds.get(guildId) !== captured || captured.count > 0)
+                    return;
+                this.#localHolds.delete(guildId);
+                if (this.#stopped)
+                    return;
+                try {
+                    this.enqueueLocalReload(guildId);
+                }
+                catch {
+                    this.revoke();
+                }
+            },
+        });
+    }
+    enqueueLocalReload(guildId) {
+        if (!this.ownerCurrent() ||
+            this.#localHolds.has(guildId) ||
+            !this.guildCurrent(guildId) ||
+            this.#localModuleIds.length === 0)
+            return;
+        if (!this.#localJobs.has(guildId) &&
+            this.#localJobs.size >= this.options.capacity) {
+            this.revoke();
+            return;
+        }
+        this.#localJobs.set(guildId, {
+            guild: this.#guilds.get(guildId),
+            gatewayEpoch: this.#gatewayEpoch,
+            cursor: 0,
+        });
+        this.startLocalDrain();
+    }
+    startLocalDrain() {
+        if (this.#localDrain)
+            return;
+        this.#localDrain = Promise.resolve()
+            .then(() => this.drainLocalReloads())
+            .catch(() => {
+            this.revoke();
+        })
+            .finally(() => {
+            this.#localDrain = undefined;
+            if (!this.#stopped && this.#localJobs.size > 0)
+                this.startLocalDrain();
+        });
+    }
+    async drainLocalReloads() {
+        while (!this.#stopped && this.#localJobs.size > 0) {
+            const [guildId, job] = this.#localJobs.entries().next().value;
+            const current = () => !this.#stopped &&
+                this.#localJobs.get(guildId) === job &&
+                this.#guilds.get(guildId) === job.guild &&
+                this.#gatewayEpoch === job.gatewayEpoch &&
+                !this.#localHolds.has(guildId) &&
+                this.ownerCurrent() &&
+                this.guildCurrent(guildId);
+            if (!current()) {
+                if (this.#localJobs.get(guildId) === job)
+                    this.#localJobs.delete(guildId);
+                continue;
+            }
+            const moduleId = this.#localModuleIds[job.cursor];
+            const scope = { guildId, moduleId };
+            // A read issued before mutation is still charged, but is not fresh reconciliation.
+            const previous = this.#pendingReads.get(scopeKey(scope));
+            if (previous)
+                await previous.catch(() => false);
+            while (current() &&
+                this.#pendingReads.size >= this.options.maximumConcurrentReads)
+                await Promise.race(this.#pendingReads.values()).catch(() => false);
+            if (!current())
+                continue;
+            await this.reload(scope).catch(() => false);
+            if (this.#localJobs.get(guildId) !== job)
+                continue;
+            job.cursor++;
+            this.#localJobs.delete(guildId);
+            // One fresh attempt per recipient; failure remains held, without retry spinning.
+            if (job.cursor < this.#localModuleIds.length &&
+                currentEpoch(this.#guilds.get(guildId), job.guild, this.#gatewayEpoch, job.gatewayEpoch))
+                this.#localJobs.set(guildId, job);
+        }
+    }
+    sourceGuild(guild) {
+        return Boolean(this.readyIdentity() &&
+            guild.client === this.options.client &&
+            guild.available &&
+            this.options.client.guilds.cache.get(guild.id) === guild);
+    }
+    guildCurrent(guildId) {
+        const entry = this.#guilds.get(guildId);
+        if (!this.#gatewayReady ||
+            !entry?.accepted ||
+            !this.sourceGuild(entry.guild)) {
+            if (entry)
+                this.invalidateGuild(guildId);
+            return false;
+        }
+        return true;
+    }
+    readyIdentity() {
+        const client = this.options.client;
+        return Boolean(client.isReady() &&
+            client.user?.id === this.#identity.applicationId &&
+            client.application?.id === this.#identity.applicationId);
+    }
+    ownerCurrent() {
+        if (this.#stopped || !this.#lease)
+            return false;
+        const now = this.time();
+        if (!Number.isFinite(now) || now >= this.#ownerDeadline) {
+            this.revoke();
+            return false;
+        }
+        return true;
+    }
+    acceptLease(lease, capturedAt, previous) {
+        assertMessageProtectionOwnerLease(lease);
+        if (lease.identity.applicationId !== this.#identity.applicationId ||
+            lease.identity.instanceId !== this.#identity.instanceId ||
+            lease.lineageId !== previous.lineageId ||
+            ("ownershipId" in previous &&
+                lease.ownershipId !== previous.ownershipId) ||
+            BigInt(lease.version) !== BigInt(previous.version) + 1n)
+            return false;
+        const budget = Date.parse(lease.expiresAt) - Date.parse(lease.databaseObservedAt) - 1;
+        const deadline = capturedAt + Math.min(budget, this.options.leaseMs - 1);
+        if (!Number.isFinite(deadline) || deadline <= this.time() || this.#stopped)
+            return false;
+        this.#lease = Object.freeze({ ...lease, identity: this.#identity });
+        this.#ownerDeadline = deadline;
+        return true;
+    }
+    time() {
+        if (this.#stopped)
+            return NaN;
+        let now;
+        try {
+            now = this.#clock();
+        }
+        catch {
+            this.revoke();
+            return NaN;
+        }
+        if (this.#stopped ||
+            !Number.isFinite(now) ||
+            now < 0 ||
+            now > Number.MAX_SAFE_INTEGER - 600_000 ||
+            now < this.#lastNow) {
+            this.revoke();
+            return NaN;
+        }
+        this.#lastNow = now;
+        return now;
+    }
+    revoke() {
+        this.#stopped = true;
+        this.#gatewayReady = false;
+        this.#publisher.stop();
+        this.#guilds.clear();
+        this.#tokens.clear();
+        this.#scopeTokens.clear();
+        this.#reloads.clear();
+        this.#localJobs.clear();
+    }
+    pruneTokens() {
+        for (const [token, entry] of this.#tokens)
+            if (!this.#publisher.eligibility.isCurrent(token) ||
+                !this.guildCurrent(entry.scope.guildId))
+                this.deleteToken(token, entry);
+    }
+    deleteToken(token, entry) {
+        this.#tokens.delete(token);
+        if (this.#scopeTokens.get(scopeKey(entry.scope)) === token)
+            this.#scopeTokens.delete(scopeKey(entry.scope));
+    }
+    async releaseQuietly(lease) {
+        try {
+            await this.options.owners.release(lease);
+        }
+        catch {
+            /* Local owner remains revoked; durable lease expires. */
+        }
+    }
+}
+function currentEpoch(current, expected, actualGateway, expectedGateway) {
+    return current === expected && actualGateway === expectedGateway;
+}
+function scopeKey(scope) {
+    return `${scope.guildId}:${scope.moduleId}`;
+}
+//# sourceMappingURL=message-protection-coordinator.js.map