@helyx/bot 0.4.9 → 0.4.13

package/dist/numeric-write-behind-redis.js

@@ -0,0 +1,1281 @@
+import {} from "@helyx/sdk";
+import {} from "@helyx/platform";
+import { randomUUID } from "node:crypto";
+import { createClient } from "redis";
+const REDIS_FLUSH_INTERVAL_MS = 30_000;
+const REDIS_BATCH_SIZE = 100;
+const REDIS_CAPACITY = 10_000;
+const REDIS_CLAIM_LEASE_MS = 30_000;
+const REDIS_RETRY_BASE_MS = 250;
+const REDIS_RETRY_MAX_MS = 30_000;
+const REDIS_BARRIER_LEASE_MS = 60_000;
+const REDIS_SUPPRESSION_DRAIN_TIMEOUT_MS = 5_000;
+const REDIS_SUPPRESSION_POLL_MS = 25;
+// Stay inside the database receipt's 30-day retention window.
+const REDIS_RETRY_RETENTION_MS = 29 * 24 * 60 * 60 * 1_000;
+const SAFE_NAMESPACE = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu;
+export class RedisNumericWriteBehindService {
+    #redis;
+    #prefix;
+    #writer;
+    #registrations = new Map();
+    #subscribers = new Map();
+    #subjectSuppressions = new Map();
+    #guildSuppressions = new Map();
+    #flushIntervalMs;
+    #capacity;
+    #onError;
+    #supervisorId;
+    #shardLeaseKeyPrefix;
+    #barrierLeaseMs;
+    #suppressionDrainTimeoutMs;
+    #suppressionPollMs;
+    #timer;
+    #healthTimer;
+    #flushTail = Promise.resolve();
+    #started = false;
+    #accepting = true;
+    #health = emptyHealth();
+    constructor(options) {
+        if (!SAFE_NAMESPACE.test(options.namespace))
+            throw new Error("Numeric write-behind Redis namespace is invalid");
+        if (!Number.isSafeInteger(options.capacity ?? REDIS_CAPACITY) ||
+            (options.capacity ?? REDIS_CAPACITY) < 1 ||
+            (options.capacity ?? REDIS_CAPACITY) > 100_000)
+            throw new Error("Numeric write-behind Redis capacity is invalid");
+        this.#redis =
+            options.client ??
+                createClient({ url: options.redisUrl });
+        this.#prefix = `helyx:numeric-write-behind:v1:${options.namespace}`;
+        this.#writer = options.writer;
+        this.#flushIntervalMs = options.flushIntervalMs ?? REDIS_FLUSH_INTERVAL_MS;
+        this.#capacity = options.capacity ?? REDIS_CAPACITY;
+        this.#onError = options.onError;
+        this.#supervisorId = options.supervisorId;
+        this.#shardLeaseKeyPrefix = options.shardLeaseKeyPrefix;
+        this.#barrierLeaseMs = options.barrierLeaseMs ?? REDIS_BARRIER_LEASE_MS;
+        this.#suppressionDrainTimeoutMs =
+            options.suppressionDrainTimeoutMs ?? REDIS_SUPPRESSION_DRAIN_TIMEOUT_MS;
+        this.#suppressionPollMs =
+            options.suppressionPollMs ?? REDIS_SUPPRESSION_POLL_MS;
+        if (!Number.isSafeInteger(this.#barrierLeaseMs) ||
+            this.#barrierLeaseMs < 1_000 ||
+            this.#barrierLeaseMs > 10 * 60_000)
+            throw new Error("Numeric write-behind barrier lease is invalid");
+        if (!Number.isSafeInteger(this.#suppressionDrainTimeoutMs) ||
+            this.#suppressionDrainTimeoutMs < 1 ||
+            this.#suppressionDrainTimeoutMs > 60_000 ||
+            !Number.isSafeInteger(this.#suppressionPollMs) ||
+            this.#suppressionPollMs < 1 ||
+            this.#suppressionPollMs > 1_000)
+            throw new Error("Numeric write-behind suppression wait is invalid");
+        if ((this.#supervisorId === undefined) !==
+            (this.#shardLeaseKeyPrefix === undefined))
+            throw new Error("Redis numeric shard fencing configuration is incomplete");
+        for (const registration of options.registrations) {
+            const key = scopeKey(registration);
+            if (this.#registrations.has(key))
+                throw new Error("Duplicate numeric write-behind Redis registration");
+            this.#registrations.set(key, registration);
+        }
+    }
+    async start() {
+        if (this.#started)
+            return;
+        await this.#redis.connect();
+        this.#started = true;
+        this.#timer = setInterval(() => {
+            void this.#serial(() => this.#drainAll(false)).catch((error) => this.#onError?.(toError(error)));
+        }, this.#flushIntervalMs);
+        this.#timer.unref();
+        const refreshHealth = () => {
+            void this.#refreshHealth().catch((error) => this.#onError?.(toError(error)));
+        };
+        refreshHealth();
+        this.#healthTimer = setInterval(refreshHealth, Math.min(this.#flushIntervalMs, 5_000));
+        this.#healthTimer.unref();
+    }
+    async enqueue(input) {
+        if (this.#supervisorId)
+            return { outcome: "unavailable" };
+        return this.#enqueue(input);
+    }
+    enqueueFenced(input, fence) {
+        return this.#enqueue(input, fence);
+    }
+    async #enqueue(input, fence) {
+        this.#registration(input);
+        if (!this.#started)
+            return { outcome: "unavailable" };
+        if (!this.#accepting)
+            return { outcome: "paused" };
+        try {
+            const result = await this.#redis.eval(ENQUEUE_SCRIPT, {
+                keys: [...keysFor(this.#prefix, input), fence?.leaseKey ?? ""],
+                arguments: [
+                    memberKey(input.guildId, input.subjectId),
+                    input.guildId,
+                    input.subjectId,
+                    String(input.occurredAt.getTime()),
+                    String(input.cooldownSeconds * 1_000),
+                    JSON.stringify(encodeEntry(input, fence?.shardId)),
+                    String(this.#capacity),
+                    fence?.leaseValue ?? "",
+                    String(Date.now()),
+                ],
+            });
+            const outcomes = [
+                "accepted",
+                "cooldown",
+                "suppressed",
+                "paused",
+                "capacity",
+                "unavailable",
+            ];
+            const outcome = outcomes[Number(result) - 1];
+            if (!outcome)
+                throw new Error("Redis enqueue returned an invalid outcome");
+            if (outcome !== "accepted")
+                this.#health = {
+                    ...this.#health,
+                    rejectedCount: this.#health.rejectedCount + 1,
+                };
+            return { outcome };
+        }
+        catch (error) {
+            this.#onError?.(toError(error));
+            return { outcome: "unavailable" };
+        }
+    }
+    async pendingMemberSnapshot(input) {
+        this.#assertAvailable(input);
+        const raw = await this.#redis.eval(SNAPSHOT_SCRIPT, {
+            keys: keysFor(this.#prefix, input),
+            arguments: [input.guildId, input.subjectId],
+        });
+        const entries = parseEntries(raw);
+        const increments = {};
+        const maxima = {};
+        let oldest = null;
+        for (const entry of entries) {
+            for (const [field, value] of Object.entries(entry.increments))
+                increments[field] = (increments[field] ?? 0) + value;
+            for (const [field, value] of Object.entries(entry.maxima)) {
+                const candidate = new Date(value);
+                const current = maxima[field];
+                if (!current || candidate > current)
+                    maxima[field] = candidate;
+            }
+            oldest =
+                oldest === null ? entry.acceptedAt : Math.min(oldest, entry.acceptedAt);
+        }
+        return {
+            increments,
+            maxima,
+            oldestAcceptedAt: oldest === null ? null : new Date(oldest),
+        };
+    }
+    flushMember(input) {
+        return this.#flush(input, input.guildId, input.subjectId, true);
+    }
+    flushGuild(input) {
+        return this.#flush(input, input.guildId, "", true);
+    }
+    flushSubject(input) {
+        return this.#flush(input, "", input.subjectId, true);
+    }
+    flushModule(input) {
+        return this.#flush(input, "", "", true);
+    }
+    async runMemberBarrier(input, operation) {
+        const barrierId = await this.#acquireBarrier(input, "member", input.guildId, input.subjectId);
+        const stopRenewal = this.#startBarrierRenewal(input, "member", input.guildId, input.subjectId, barrierId);
+        try {
+            await this.flushMember(input);
+            return await operation();
+        }
+        finally {
+            stopRenewal();
+            await this.#releaseBarrier(input, "member", input.guildId, input.subjectId, barrierId);
+        }
+    }
+    async runGuildBarrier(input, operation) {
+        const barrierId = await this.#acquireBarrier(input, "guild", input.guildId, "");
+        const stopRenewal = this.#startBarrierRenewal(input, "guild", input.guildId, "", barrierId);
+        try {
+            await this.flushGuild(input);
+            return await operation();
+        }
+        finally {
+            stopRenewal();
+            await this.#releaseBarrier(input, "guild", input.guildId, "", barrierId);
+        }
+    }
+    async runSubjectBarrier(input, operation) {
+        const barrierId = await this.#acquireBarrier(input, "subject", "", input.subjectId);
+        const stopRenewal = this.#startBarrierRenewal(input, "subject", "", input.subjectId, barrierId);
+        try {
+            await this.flushSubject(input);
+            return await operation();
+        }
+        finally {
+            stopRenewal();
+            await this.#releaseBarrier(input, "subject", "", input.subjectId, barrierId);
+        }
+    }
+    async suppressSubject(input) {
+        this.#assertAvailable(input);
+        const suppressionId = randomUUID();
+        const result = await this.#redis.eval(SUPPRESS_SUBJECT_SCRIPT, {
+            keys: keysFor(this.#prefix, input),
+            arguments: [
+                input.subjectId,
+                String(input.cutoff.getTime()),
+                suppressionId,
+            ],
+        });
+        const discarded = Number(result);
+        if (!Number.isSafeInteger(discarded) || discarded < 0)
+            throw new Error("Redis suppression returned an invalid count");
+        this.#subjectSuppressions.set(subjectSuppressionKey(input, input.subjectId), { suppressionId, cutoff: new Date(input.cutoff) });
+        await this.#waitForSuppression(input, SUPPRESSION_STATUS_SCRIPT, [
+            input.subjectId,
+            String(input.cutoff.getTime()),
+        ]);
+        return { suppressionId, discarded };
+    }
+    async suppressGuild(input) {
+        this.#assertAvailable(input);
+        const suppressionId = randomUUID();
+        const discarded = Number(await this.#redis.eval(SUPPRESS_GUILD_SCRIPT, {
+            keys: keysFor(this.#prefix, input),
+            arguments: [input.guildId, suppressionId],
+        }));
+        if (!Number.isSafeInteger(discarded) || discarded < 0)
+            throw new Error("Redis guild suppression returned an invalid count");
+        this.#guildSuppressions.set(guildSuppressionKey(input, input.guildId), suppressionId);
+        await this.#waitForSuppression(input, GUILD_SUPPRESSION_STATUS_SCRIPT, [
+            input.guildId,
+        ]);
+        return { suppressionId, discarded };
+    }
+    async releaseGuild(input) {
+        this.#assertAvailable(input);
+        const released = Number(await this.#redis.eval(RELEASE_GUILD_SCRIPT, {
+            keys: keysFor(this.#prefix, input),
+            arguments: [input.guildId, input.suppressionId],
+        })) === 1;
+        if (released)
+            this.#guildSuppressions.delete(guildSuppressionKey(input, input.guildId));
+        return { released };
+    }
+    async releaseSubject(input) {
+        this.#assertAvailable(input);
+        const result = await this.#redis.eval(RELEASE_SUBJECT_SCRIPT, {
+            keys: keysFor(this.#prefix, input),
+            arguments: [input.subjectId, input.suppressionId],
+        });
+        const released = Number(result) === 1;
+        if (released)
+            this.#subjectSuppressions.delete(subjectSuppressionKey(input, input.subjectId));
+        return { released };
+    }
+    async clearMemberCooldown(input) {
+        this.#assertAvailable(input);
+        await this.#redis.eval(CLEAR_COOLDOWN_SCRIPT, {
+            keys: keysFor(this.#prefix, input),
+            arguments: [memberKey(input.guildId, input.subjectId), input.subjectId],
+        });
+    }
+    async clearSubjectCooldown(input) {
+        this.#assertAvailable(input);
+        await this.#redis.eval(CLEAR_SUBJECT_COOLDOWNS_SCRIPT, {
+            keys: keysFor(this.#prefix, input),
+            arguments: [input.subjectId],
+        });
+    }
+    subscribeCommitted(input, handler) {
+        this.#registration(input);
+        const key = scopeKey(input);
+        const subscribers = this.#subscribers.get(key) ?? new Set();
+        subscribers.add(handler);
+        this.#subscribers.set(key, subscribers);
+        return () => {
+            subscribers.delete(handler);
+            if (subscribers.size === 0)
+                this.#subscribers.delete(key);
+        };
+    }
+    health() {
+        return this.#health;
+    }
+    acquireBarrier(input) {
+        return this.#acquireBarrier(input.scope, input.barrierType, input.guildId ?? "", input.subjectId ?? "").then((barrierId) => ({ barrierId }));
+    }
+    releaseBarrier(input) {
+        return this.#releaseBarrier(input.scope, input.barrierType, input.guildId ?? "", input.subjectId ?? "", input.barrierId);
+    }
+    renewBarrier(input) {
+        return this.#renewBarrier(input.scope, input.barrierType, input.guildId ?? "", input.subjectId ?? "", input.barrierId);
+    }
+    async stop(timeoutMs = 5_000) {
+        this.#accepting = false;
+        this.#health = { ...this.#health, accepting: false };
+        if (this.#timer)
+            clearInterval(this.#timer);
+        if (this.#healthTimer)
+            clearInterval(this.#healthTimer);
+        if (!this.#started)
+            return { drained: true };
+        let timeout;
+        const drain = this.#serial(() => this.#drainAll(true));
+        let drainError;
+        const completed = drain.then(() => true, (error) => {
+            drainError = error;
+            return true;
+        });
+        const finished = await Promise.race([
+            completed,
+            new Promise((resolve) => {
+                timeout = setTimeout(() => resolve(false), timeoutMs);
+                timeout.unref();
+            }),
+        ]);
+        if (timeout)
+            clearTimeout(timeout);
+        if (finished) {
+            await this.#redis.quit();
+            this.#started = false;
+            if (drainError)
+                throw toError(drainError);
+        }
+        else {
+            void completed
+                .then(() => this.#redis.quit().finally(() => {
+                this.#started = false;
+            }))
+                .catch((error) => this.#onError?.(toError(error)));
+        }
+        return { drained: finished };
+    }
+    #flush(scope, guildId, subjectId, force) {
+        this.#assertAvailable(scope);
+        return this.#serial(() => this.#drainRegistration(this.#registration(scope), guildId, subjectId, force));
+    }
+    #serial(run) {
+        const result = this.#flushTail.then(run, run);
+        this.#flushTail = result.catch(() => undefined);
+        return result;
+    }
+    async #drainAll(force) {
+        for (const registration of this.#registrations.values())
+            await this.#drainRegistration(registration, "", "", force);
+        await this.#refreshHealth().catch((error) => this.#onError?.(toError(error)));
+    }
+    async #refreshHealth() {
+        let pendingEntries = 0;
+        let retryBatches = 0;
+        let quarantinedBatches = 0;
+        let suppressedGuilds = 0;
+        let suppressedMembers = 0;
+        let suppressedSubjects = 0;
+        let oldestAcceptedAt = null;
+        for (const registration of this.#registrations.values()) {
+            const raw = await this.#redis.eval(HEALTH_SCRIPT, {
+                keys: keysFor(this.#prefix, registration),
+                arguments: [],
+            });
+            if (typeof raw !== "string")
+                throw new Error("Redis numeric health response was invalid");
+            const parsed = JSON.parse(raw);
+            if (!isRedisHealthSnapshot(parsed))
+                throw new Error("Redis numeric health response was invalid");
+            pendingEntries += parsed.pendingEntries;
+            retryBatches += parsed.retryBatches;
+            quarantinedBatches += parsed.quarantinedBatches;
+            suppressedGuilds += parsed.suppressedGuilds;
+            suppressedMembers += parsed.suppressedMembers;
+            suppressedSubjects += parsed.suppressedSubjects;
+            if (parsed.oldestAcceptedAt !== null)
+                oldestAcceptedAt =
+                    oldestAcceptedAt === null
+                        ? parsed.oldestAcceptedAt
+                        : Math.min(oldestAcceptedAt, parsed.oldestAcceptedAt);
+        }
+        this.#health = {
+            ...this.#health,
+            accepting: this.#accepting,
+            pendingEntries,
+            retryBatches,
+            quarantinedBatches,
+            oldestPendingAgeMs: oldestAcceptedAt === null
+                ? null
+                : Math.max(0, Date.now() - oldestAcceptedAt),
+            suppressedGuilds,
+            suppressedMembers,
+            suppressedSubjects,
+        };
+    }
+    async #drainRegistration(registration, guildId, subjectId, force) {
+        while (true) {
+            const proposedOperationId = randomUUID();
+            const raw = await this.#redis.eval(CLAIM_SCRIPT, {
+                keys: keysFor(this.#prefix, registration),
+                arguments: [
+                    String(Date.now()),
+                    String(REDIS_CLAIM_LEASE_MS),
+                    proposedOperationId,
+                    String(REDIS_BATCH_SIZE),
+                    guildId,
+                    subjectId,
+                    force ? "1" : "0",
+                    this.#supervisorId ?? "",
+                    this.#shardLeaseKeyPrefix ?? "",
+                    String(REDIS_RETRY_RETENTION_MS),
+                ],
+            });
+            if (raw === null)
+                return;
+            const parsed = parseClaim(raw);
+            if ("empty" in parsed) {
+                this.#health = {
+                    ...this.#health,
+                    quarantinedBatches: parsed.quarantined,
+                };
+                return;
+            }
+            const claim = parsed;
+            const startedAt = Date.now();
+            this.#health = {
+                ...this.#health,
+                inFlightEntries: claim.entries.length,
+            };
+            try {
+                const output = await this.#writer.mutateNumericBatch({
+                    moduleId: registration.moduleId,
+                    collection: registration.collection,
+                    operationId: claim.operationId,
+                    uniqueBy: registration.uniqueBy,
+                    mutations: claim.entries.map(decodeMutation),
+                    select: registration.select,
+                });
+                if (output.results.length !== claim.entries.length)
+                    throw new Error("Redis numeric writer result count was invalid");
+                const committed = {
+                    moduleId: registration.moduleId,
+                    collection: registration.collection,
+                    operationId: claim.operationId,
+                    replayed: output.replayed,
+                    mutations: claim.entries.map(decodeMutation),
+                    results: output.results,
+                };
+                for (const subscriber of this.#subscribers.get(scopeKey(registration)) ?? [])
+                    await subscriber(committed);
+                const acknowledged = await this.#redis.eval(ACK_SCRIPT, {
+                    keys: keysFor(this.#prefix, registration),
+                    arguments: [claim.operationId],
+                });
+                if (Number(acknowledged) !== 1)
+                    throw new Error("Redis numeric claim ownership changed");
+            }
+            catch (error) {
+                const attempt = claim.attempt + 1;
+                const retryAt = Date.now() +
+                    Math.min(REDIS_RETRY_MAX_MS, REDIS_RETRY_BASE_MS * 2 ** Math.min(claim.attempt, 16));
+                await this.#redis.eval(RETRY_SCRIPT, {
+                    keys: keysFor(this.#prefix, registration),
+                    arguments: [claim.operationId, String(attempt), String(retryAt)],
+                });
+                this.#health = {
+                    ...this.#health,
+                    retryCount: this.#health.retryCount + 1,
+                    inFlightEntries: 0,
+                    lastFlushDurationMs: Math.max(0, Date.now() - startedAt),
+                };
+                this.#onError?.(toError(error));
+                if (force)
+                    throw error;
+                return;
+            }
+            this.#health = {
+                ...this.#health,
+                inFlightEntries: 0,
+                lastFlushDurationMs: Math.max(0, Date.now() - startedAt),
+            };
+        }
+    }
+    async #acquireBarrier(scope, kind, guildId, subjectId) {
+        this.#assertAvailable(scope);
+        const barrierId = randomUUID();
+        const result = await this.#redis.eval(ACQUIRE_BARRIER_SCRIPT, {
+            keys: keysFor(this.#prefix, scope),
+            arguments: [
+                kind,
+                guildId,
+                subjectId,
+                barrierId,
+                String(Date.now()),
+                String(Date.now() + this.#barrierLeaseMs),
+            ],
+        });
+        if (Number(result) === 2)
+            throw new Error("Numeric write-behind member is suppressed");
+        if (Number(result) !== 1)
+            throw new Error("Numeric write-behind barrier is already held");
+        return barrierId;
+    }
+    async #releaseBarrier(scope, kind, guildId, subjectId, barrierId) {
+        const result = await this.#redis.eval(RELEASE_BARRIER_SCRIPT, {
+            keys: keysFor(this.#prefix, scope),
+            arguments: [kind, guildId, subjectId, barrierId, String(Date.now())],
+        });
+        if (Number(result) !== 1)
+            throw new Error("Numeric write-behind barrier ownership changed");
+    }
+    async #renewBarrier(scope, kind, guildId, subjectId, barrierId) {
+        const now = Date.now();
+        const result = await this.#redis.eval(RENEW_BARRIER_SCRIPT, {
+            keys: keysFor(this.#prefix, scope),
+            arguments: [
+                kind,
+                guildId,
+                subjectId,
+                barrierId,
+                String(now),
+                String(now + this.#barrierLeaseMs),
+            ],
+        });
+        if (Number(result) !== 1)
+            throw new Error("Numeric write-behind barrier lease expired");
+    }
+    #startBarrierRenewal(scope, kind, guildId, subjectId, barrierId) {
+        const timer = setInterval(() => {
+            void this.#renewBarrier(scope, kind, guildId, subjectId, barrierId).catch((error) => this.#onError?.(toError(error)));
+        }, Math.max(250, Math.floor(this.#barrierLeaseMs / 3)));
+        timer.unref();
+        return () => clearInterval(timer);
+    }
+    async #waitForSuppression(scope, script, arguments_) {
+        const deadline = Date.now() + this.#suppressionDrainTimeoutMs;
+        while (true) {
+            const active = Number(await this.#redis.eval(script, {
+                keys: keysFor(this.#prefix, scope),
+                arguments: arguments_,
+            }));
+            if (!Number.isSafeInteger(active) || active < 0)
+                throw new Error("Redis suppression status was invalid");
+            if (active === 0)
+                return;
+            if (Date.now() >= deadline)
+                throw new Error("Numeric write-behind suppression is waiting for active writes");
+            await delay(Math.min(this.#suppressionPollMs, Math.max(1, deadline - Date.now())));
+        }
+    }
+    #registration(scope) {
+        const registration = this.#registrations.get(scopeKey(scope));
+        if (!registration)
+            throw new Error("Unknown numeric write-behind Redis registration");
+        return registration;
+    }
+    #assertAvailable(scope) {
+        this.#registration(scope);
+        if (!this.#started)
+            throw new Error("Numeric write-behind Redis service is unavailable");
+    }
+}
+export async function executeRedisNumericOperation(service, operation, fence) {
+    const scoped = {
+        moduleId: operation.moduleId,
+        collection: operation.collection,
+    };
+    switch (operation.kind) {
+        case "enqueue": {
+            const input = {
+                ...scoped,
+                guildId: operation.guildId,
+                subjectId: operation.subjectId,
+                occurredAt: new Date(operation.occurredAt),
+                cooldownSeconds: operation.cooldownSeconds,
+                identity: decodeWireRecord(operation.identity),
+                insert: decodeWireRecord(operation.insert),
+                increments: operation.increments,
+                ...(operation.maxima
+                    ? {
+                        maxima: Object.fromEntries(Object.entries(operation.maxima).map(([field, value]) => [
+                            field,
+                            new Date(value),
+                        ])),
+                    }
+                    : {}),
+            };
+            if (!fence)
+                return service.enqueue(input);
+            const lease = {
+                generation: fence.identity.generation,
+                deploymentOrder: fence.identity.deploymentOrder,
+                supervisorId: fence.identity.supervisorId,
+                shardId: fence.identity.shardId,
+                fencingToken: fence.identity.fencingToken,
+            };
+            return service.enqueueFenced(input, {
+                shardId: fence.identity.shardId,
+                leaseKey: `${fence.shardLeaseKeyPrefix}${String(fence.identity.shardId)}`,
+                leaseValue: JSON.stringify(lease),
+            });
+        }
+        case "pending.member":
+            return service.pendingMemberSnapshot({ ...scoped, ...operation });
+        case "flush.member":
+            await service.flushMember({ ...scoped, ...operation });
+            return null;
+        case "flush.guild":
+            await service.flushGuild({ ...scoped, guildId: operation.guildId });
+            return null;
+        case "flush.subject":
+            await service.flushSubject({
+                ...scoped,
+                subjectId: operation.subjectId,
+            });
+            return null;
+        case "flush.module":
+            await service.flushModule(scoped);
+            return null;
+        case "barrier.acquire":
+            return service.acquireBarrier({
+                scope: scoped,
+                barrierType: operation.barrierType,
+                ...(operation.guildId ? { guildId: operation.guildId } : {}),
+                ...(operation.subjectId ? { subjectId: operation.subjectId } : {}),
+            });
+        case "barrier.release":
+            await service.releaseBarrier({
+                scope: scoped,
+                barrierType: operation.barrierType,
+                ...(operation.guildId ? { guildId: operation.guildId } : {}),
+                ...(operation.subjectId ? { subjectId: operation.subjectId } : {}),
+                barrierId: operation.barrierId,
+            });
+            return null;
+        case "barrier.renew":
+            await service.renewBarrier({
+                scope: scoped,
+                barrierType: operation.barrierType,
+                ...(operation.guildId ? { guildId: operation.guildId } : {}),
+                ...(operation.subjectId ? { subjectId: operation.subjectId } : {}),
+                barrierId: operation.barrierId,
+            });
+            return null;
+        case "suppress.subject":
+            return service.suppressSubject({
+                ...scoped,
+                subjectId: operation.subjectId,
+                cutoff: new Date(operation.cutoff),
+            });
+        case "suppress.guild":
+            return service.suppressGuild({
+                ...scoped,
+                guildId: operation.guildId,
+            });
+        case "release.guild":
+            return service.releaseGuild({
+                ...scoped,
+                guildId: operation.guildId,
+                suppressionId: operation.suppressionId,
+            });
+        case "release.subject":
+            return service.releaseSubject({
+                ...scoped,
+                subjectId: operation.subjectId,
+                suppressionId: operation.suppressionId,
+            });
+        case "cooldown.member.clear":
+            await service.clearMemberCooldown({ ...scoped, ...operation });
+            return null;
+        case "cooldown.subject.clear":
+            await service.clearSubjectCooldown({
+                ...scoped,
+                subjectId: operation.subjectId,
+            });
+            return null;
+    }
+}
+function keysFor(prefix, scope) {
+    const root = `${prefix}:${scope.moduleId}:${scope.collection}`;
+    return [
+        `${root}:pending`,
+        `${root}:pending-index`,
+        `${root}:staged`,
+        `${root}:claims`,
+        `${root}:claim-retry`,
+        `${root}:cooldown:`,
+        `${root}:subject-cooldowns:`,
+        `${root}:suppressed-subjects`,
+        `${root}:paused-guilds`,
+        `${root}:paused-members`,
+        `${root}:paused-subjects`,
+        `${root}:subject-claims:`,
+        `${root}:suppressed-guilds`,
+        `${root}:guild-claims:`,
+        `${root}:quarantine`,
+    ];
+}
+function encodeEntry(input, shardId) {
+    return {
+        guildId: input.guildId,
+        subjectId: input.subjectId,
+        acceptedAt: input.occurredAt.getTime(),
+        ...(shardId === undefined ? {} : { shardId }),
+        identity: encodeRecord(input.identity),
+        insert: encodeRecord(input.insert),
+        increments: { ...input.increments },
+        maxima: Object.fromEntries(Object.entries(input.maxima ?? {}).map(([field, value]) => [
+            field,
+            value.toISOString(),
+        ])),
+    };
+}
+function encodeRecord(input) {
+    return Object.fromEntries(Object.entries(input).map(([field, value]) => [
+        field,
+        value instanceof Date
+            ? { type: "date", value: value.toISOString() }
+            : { type: typeof value, value },
+    ]));
+}
+function decodeMutation(entry) {
+    return {
+        identity: decodeRecord(entry.identity),
+        insert: decodeRecord(entry.insert),
+        increments: entry.increments,
+        ...(Object.keys(entry.maxima).length > 0
+            ? {
+                maxima: Object.fromEntries(Object.entries(entry.maxima).map(([field, value]) => [
+                    field,
+                    new Date(value),
+                ])),
+            }
+            : {}),
+    };
+}
+function decodeRecord(input) {
+    return Object.fromEntries(Object.entries(input).map(([field, value]) => [
+        field,
+        value.type === "date" ? new Date(value.value) : value.value,
+    ]));
+}
+function decodeWireRecord(input) {
+    return decodeRecord(input);
+}
+function parseClaim(raw) {
+    if (typeof raw !== "string")
+        throw new Error("Redis numeric claim was invalid");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed === "object" &&
+        parsed !== null &&
+        "empty" in parsed &&
+        parsed.empty === true &&
+        "quarantined" in parsed &&
+        Number.isSafeInteger(parsed.quarantined) &&
+        parsed.quarantined >= 0)
+        return { empty: true, quarantined: parsed.quarantined };
+    if (typeof parsed !== "object" ||
+        parsed === null ||
+        !("operationId" in parsed) ||
+        typeof parsed.operationId !== "string" ||
+        !UUID.test(parsed.operationId) ||
+        !("entries" in parsed) ||
+        !Array.isArray(parsed.entries) ||
+        parsed.entries.length < 1 ||
+        parsed.entries.length > REDIS_BATCH_SIZE ||
+        !("attempt" in parsed) ||
+        !Number.isSafeInteger(parsed.attempt) ||
+        parsed.attempt < 0 ||
+        !("expiresAt" in parsed) ||
+        !Number.isFinite(parsed.expiresAt) ||
+        parsed.expiresAt <= 0)
+        throw new Error("Redis numeric claim was invalid");
+    return parsed;
+}
+function parseEntries(raw) {
+    if (typeof raw !== "string")
+        throw new Error("Redis numeric snapshot was invalid");
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed))
+        throw new Error("Redis numeric snapshot was invalid");
+    return parsed;
+}
+function isRedisHealthSnapshot(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const snapshot = value;
+    const nonnegativeInteger = (field) => Number.isSafeInteger(snapshot[field]) && snapshot[field] >= 0;
+    return (nonnegativeInteger("pendingEntries") &&
+        nonnegativeInteger("retryBatches") &&
+        nonnegativeInteger("quarantinedBatches") &&
+        (snapshot["oldestAcceptedAt"] === null ||
+            (Number.isSafeInteger(snapshot["oldestAcceptedAt"]) &&
+                snapshot["oldestAcceptedAt"] >= 0)) &&
+        nonnegativeInteger("suppressedGuilds") &&
+        nonnegativeInteger("suppressedMembers") &&
+        nonnegativeInteger("suppressedSubjects"));
+}
+function scopeKey(scope) {
+    return `${scope.moduleId}\u0000${scope.collection}`;
+}
+function subjectSuppressionKey(scope, subjectId) {
+    return `${scopeKey(scope)}\u0000${subjectId}`;
+}
+function guildSuppressionKey(scope, guildId) {
+    return `${scopeKey(scope)}\u0000${guildId}`;
+}
+function memberKey(guildId, subjectId) {
+    return `${guildId}\u0000${subjectId}`;
+}
+function emptyHealth() {
+    return {
+        accepting: true,
+        pendingEntries: 0,
+        retryBatches: 0,
+        quarantinedBatches: 0,
+        inFlightEntries: 0,
+        oldestPendingAgeMs: null,
+        lastFlushDurationMs: null,
+        retryCount: 0,
+        rejectedCount: 0,
+        suppressedGuilds: 0,
+        suppressedMembers: 0,
+        suppressedSubjects: 0,
+    };
+}
+function toError(error) {
+    return error instanceof Error
+        ? error
+        : new Error("Unknown Redis numeric error");
+}
+function delay(milliseconds) {
+    return new Promise((resolve) => {
+        const timer = setTimeout(resolve, milliseconds);
+        timer.unref();
+    });
+}
+const MERGE_LUA = `
+local function merge(existing_json, incoming_json)
+  if not existing_json then return incoming_json end
+  local existing = cjson.decode(existing_json)
+  local incoming = cjson.decode(incoming_json)
+  for field, value in pairs(incoming.increments) do
+    existing.increments[field] = (existing.increments[field] or 0) + value
+  end
+  for field, value in pairs(incoming.maxima) do
+    if not existing.maxima[field] or value > existing.maxima[field] then
+      existing.maxima[field] = value
+    end
+  end
+  if incoming.acceptedAt < existing.acceptedAt then
+    existing.acceptedAt = incoming.acceptedAt
+  end
+  return cjson.encode(existing)
+end
+`;
+const BARRIER_HELPERS_LUA = `
+local function barrier_active(hash, key, now)
+  local payload = redis.call('HGET', hash, key)
+  if not payload then return false end
+  local valid, parsed = pcall(cjson.decode, payload)
+  if not valid or not parsed.expiresAt or tonumber(parsed.expiresAt) <= now then
+    redis.call('HDEL', hash, key)
+    return false
+  end
+  return true
+end
+local function member_blocked(guild_id, subject_id, now)
+  return barrier_active(KEYS[9], guild_id, now) or
+         barrier_active(KEYS[10], guild_id .. string.char(0) .. subject_id, now) or
+         barrier_active(KEYS[11], subject_id, now)
+end
+`;
+const ENQUEUE_SCRIPT = `${MERGE_LUA}
+${BARRIER_HELPERS_LUA}
+if KEYS[16] ~= '' and redis.call('GET', KEYS[16]) ~= ARGV[8] then return 6 end
+local member_key = ARGV[1]
+local guild_id = ARGV[2]
+local subject_id = ARGV[3]
+local occurred_at = tonumber(ARGV[4])
+local cooldown_ms = tonumber(ARGV[5])
+local payload = ARGV[6]
+local capacity = tonumber(ARGV[7])
+if redis.call('HEXISTS', KEYS[13], guild_id) == 1 then return 3 end
+local suppression = redis.call('HGET', KEYS[8], subject_id)
+if suppression then
+  local parsed = cjson.decode(suppression)
+  if occurred_at <= tonumber(parsed.cutoff) then return 3 end
+end
+if redis.call('EXISTS', KEYS[6] .. member_key) == 1 then return 2 end
+local paused = member_blocked(guild_id, subject_id, tonumber(ARGV[9]))
+if not paused then
+  local staged = redis.call('HGET', KEYS[3], member_key)
+  if staged then
+    local staged_entry = cjson.decode(staged)
+    redis.call('HSET', KEYS[1], member_key, merge(redis.call('HGET', KEYS[1], member_key), staged))
+    redis.call('ZADD', KEYS[2], staged_entry.acceptedAt, member_key)
+    redis.call('HDEL', KEYS[3], member_key)
+  end
+end
+local target = paused and KEYS[3] or KEYS[1]
+if redis.call('HEXISTS', target, member_key) == 0 then
+  local retained = redis.call('HLEN', KEYS[1]) + redis.call('HLEN', KEYS[3])
+  local claims = (redis.call('HLEN', KEYS[4]) + redis.call('HLEN', KEYS[15])) * 100
+  if retained + claims >= capacity then return 5 end
+end
+redis.call('HSET', target, member_key, merge(redis.call('HGET', target, member_key), payload))
+if not paused then redis.call('ZADD', KEYS[2], occurred_at, member_key) end
+redis.call('SET', KEYS[6] .. member_key, '1', 'PX', cooldown_ms, 'NX')
+redis.call('SADD', KEYS[7] .. subject_id, member_key)
+return 1
+`;
+const CLAIM_SCRIPT = `${MERGE_LUA}
+${BARRIER_HELPERS_LUA}
+local now = tonumber(ARGV[1])
+local lease_ms = tonumber(ARGV[2])
+local proposed_id = ARGV[3]
+local limit = tonumber(ARGV[4])
+local guild_filter = ARGV[5]
+local subject_filter = ARGV[6]
+local force = ARGV[7] == '1'
+local owner = ARGV[8]
+local lease_prefix = ARGV[9]
+local retry_retention_ms = tonumber(ARGV[10])
+local staged = redis.call('HGETALL', KEYS[3])
+for index = 1, #staged, 2 do
+  local member_key = staged[index]
+  local payload = staged[index + 1]
+  local entry = cjson.decode(payload)
+  if not member_blocked(entry.guildId, entry.subjectId, now) then
+    redis.call('HSET', KEYS[1], member_key, merge(redis.call('HGET', KEYS[1], member_key), payload))
+    redis.call('ZADD', KEYS[2], entry.acceptedAt, member_key)
+    redis.call('HDEL', KEYS[3], member_key)
+  end
+end
+local due = redis.call('ZRANGEBYSCORE', KEYS[5], '-inf', force and '+inf' or now, 'LIMIT', 0, 100)
+for _, operation_id in ipairs(due) do
+  local payload = redis.call('HGET', KEYS[4], operation_id)
+  if payload then
+    local claim = cjson.decode(payload)
+    if not claim.expiresAt then
+      claim.expiresAt = now + retry_retention_ms
+      redis.call('HSET', KEYS[4], operation_id, cjson.encode(claim))
+      payload = cjson.encode(claim)
+    end
+    if tonumber(claim.expiresAt) <= now then
+      for _, expired_entry in ipairs(claim.entries) do
+        redis.call('SREM', KEYS[12] .. expired_entry.subjectId, operation_id)
+        redis.call('SREM', KEYS[14] .. expired_entry.guildId, operation_id)
+      end
+      redis.call('HSET', KEYS[15], operation_id, cjson.encode(claim))
+      redis.call('HDEL', KEYS[4], operation_id)
+      redis.call('ZREM', KEYS[5], operation_id)
+      payload = nil
+    end
+  end
+  if payload then
+    local claim = cjson.decode(payload)
+    local entry = claim.entries[1]
+    local eligible = owner == ''
+    local lease_key = ''
+    local lease_value = ''
+    if not eligible and entry and entry.shardId then
+      lease_key = lease_prefix .. tostring(entry.shardId)
+      lease_value = redis.call('GET', lease_key)
+      if lease_value then
+        local lease = cjson.decode(lease_value)
+        eligible = lease.supervisorId == owner
+      end
+    end
+    if eligible then
+      for _, claimed_entry in ipairs(claim.entries) do
+        redis.call('SADD', KEYS[12] .. claimed_entry.subjectId, operation_id)
+        redis.call('SADD', KEYS[14] .. claimed_entry.guildId, operation_id)
+      end
+      claim.leaseKey = lease_key
+      claim.leaseValue = lease_value
+      local encoded = cjson.encode(claim)
+      redis.call('HSET', KEYS[4], operation_id, encoded)
+      redis.call('ZADD', KEYS[5], now + lease_ms, operation_id)
+      return encoded
+    end
+  else
+    redis.call('ZREM', KEYS[5], operation_id)
+  end
+end
+local candidates = redis.call('ZRANGE', KEYS[2], 0, -1)
+local entries = {}
+local claimed_shard = nil
+local claimed_lease_key = ''
+local claimed_lease_value = ''
+for _, member_key in ipairs(candidates) do
+  if #entries >= limit then break end
+  local payload = redis.call('HGET', KEYS[1], member_key)
+  if payload then
+    local entry = cjson.decode(payload)
+    local eligible = owner == ''
+    local lease_key = ''
+    local lease_value = ''
+    if not eligible and entry.shardId and (not claimed_shard or claimed_shard == entry.shardId) then
+      lease_key = lease_prefix .. tostring(entry.shardId)
+      lease_value = redis.call('GET', lease_key)
+      if lease_value then
+        local lease = cjson.decode(lease_value)
+        eligible = lease.supervisorId == owner
+      end
+    end
+    if eligible and (not claimed_shard or not entry.shardId or claimed_shard == entry.shardId) and
+       (guild_filter == '' or entry.guildId == guild_filter) and
+       (subject_filter == '' or entry.subjectId == subject_filter) then
+      if entry.shardId then
+        claimed_shard = entry.shardId
+        claimed_lease_key = lease_key
+        claimed_lease_value = lease_value
+      end
+      table.insert(entries, entry)
+      redis.call('HDEL', KEYS[1], member_key)
+      redis.call('ZREM', KEYS[2], member_key)
+    end
+  end
+end
+if #entries == 0 then
+  return cjson.encode({empty = true, quarantined = redis.call('HLEN', KEYS[15])})
+end
+local claim = {
+  operationId = proposed_id,
+  entries = entries,
+  attempt = 0,
+  expiresAt = now + retry_retention_ms,
+  leaseKey = claimed_lease_key,
+  leaseValue = claimed_lease_value
+}
+local encoded = cjson.encode(claim)
+redis.call('HSET', KEYS[4], proposed_id, encoded)
+redis.call('ZADD', KEYS[5], now + lease_ms, proposed_id)
+for _, claimed_entry in ipairs(entries) do
+  redis.call('SADD', KEYS[12] .. claimed_entry.subjectId, proposed_id)
+  redis.call('SADD', KEYS[14] .. claimed_entry.guildId, proposed_id)
+end
+return encoded
+`;
+const ACK_SCRIPT = `
+local payload = redis.call('HGET', KEYS[4], ARGV[1])
+if not payload then return 0 end
+local claim = cjson.decode(payload)
+if claim.leaseKey and claim.leaseKey ~= '' and
+   redis.call('GET', claim.leaseKey) ~= claim.leaseValue then return 0 end
+for _, entry in ipairs(claim.entries) do
+  redis.call('SREM', KEYS[12] .. entry.subjectId, ARGV[1])
+  redis.call('SREM', KEYS[14] .. entry.guildId, ARGV[1])
+end
+redis.call('HDEL', KEYS[4], ARGV[1])
+redis.call('ZREM', KEYS[5], ARGV[1])
+return 1
+`;
+const RETRY_SCRIPT = `
+local payload = redis.call('HGET', KEYS[4], ARGV[1])
+if not payload then return 0 end
+local claim = cjson.decode(payload)
+claim.attempt = tonumber(ARGV[2])
+redis.call('HSET', KEYS[4], ARGV[1], cjson.encode(claim))
+local retry_at = tonumber(ARGV[3])
+if claim.expiresAt and retry_at > tonumber(claim.expiresAt) then retry_at = tonumber(claim.expiresAt) end
+redis.call('ZADD', KEYS[5], retry_at, ARGV[1])
+return 1
+`;
+const HEALTH_SCRIPT = `
+local oldest = redis.call('ZRANGE', KEYS[2], 0, 0, 'WITHSCORES')
+return cjson.encode({
+  pendingEntries = redis.call('HLEN', KEYS[1]) + redis.call('HLEN', KEYS[3]),
+  retryBatches = redis.call('HLEN', KEYS[4]),
+  quarantinedBatches = redis.call('HLEN', KEYS[15]),
+  oldestAcceptedAt = oldest[2] and tonumber(oldest[2]) or cjson.null,
+  suppressedGuilds = redis.call('HLEN', KEYS[13]),
+  suppressedMembers = redis.call('HLEN', KEYS[10]),
+  suppressedSubjects = redis.call('HLEN', KEYS[8])
+})
+`;
+const SNAPSHOT_SCRIPT = `
+local guild_id = ARGV[1]
+local subject_id = ARGV[2]
+local member_key = guild_id .. string.char(0) .. subject_id
+local result = {}
+local pending = redis.call('HGET', KEYS[1], member_key)
+if pending then table.insert(result, cjson.decode(pending)) end
+local staged = redis.call('HGET', KEYS[3], member_key)
+if staged then table.insert(result, cjson.decode(staged)) end
+for _, encoded in ipairs(redis.call('HVALS', KEYS[4])) do
+  local claim = cjson.decode(encoded)
+  for _, entry in ipairs(claim.entries) do
+    if entry.guildId == guild_id and entry.subjectId == subject_id then
+      table.insert(result, entry)
+    end
+  end
+end
+if #result == 0 then return '[]' end
+return cjson.encode(result)
+`;
+const ACQUIRE_BARRIER_SCRIPT = `
+if ARGV[1] == 'member' and
+   (redis.call('HEXISTS', KEYS[13], ARGV[2]) == 1 or
+    redis.call('HEXISTS', KEYS[8], ARGV[3]) == 1) then return 2 end
+local hash = ARGV[1] == 'guild' and KEYS[9] or (ARGV[1] == 'subject' and KEYS[11] or KEYS[10])
+local key = ARGV[1] == 'guild' and ARGV[2] or (ARGV[1] == 'subject' and ARGV[3] or (ARGV[2] .. string.char(0) .. ARGV[3]))
+local current = redis.call('HGET', hash, key)
+if current then
+  local valid, parsed = pcall(cjson.decode, current)
+  if valid and parsed.expiresAt and tonumber(parsed.expiresAt) > tonumber(ARGV[5]) then return 0 end
+end
+redis.call('HSET', hash, key, cjson.encode({id = ARGV[4], expiresAt = tonumber(ARGV[6])}))
+return 1
+`;
+const RELEASE_BARRIER_SCRIPT = `${MERGE_LUA}
+${BARRIER_HELPERS_LUA}
+local hash = ARGV[1] == 'guild' and KEYS[9] or (ARGV[1] == 'subject' and KEYS[11] or KEYS[10])
+local barrier_key = ARGV[1] == 'guild' and ARGV[2] or (ARGV[1] == 'subject' and ARGV[3] or (ARGV[2] .. string.char(0) .. ARGV[3]))
+local current = redis.call('HGET', hash, barrier_key)
+if not current then return 0 end
+local valid, parsed = pcall(cjson.decode, current)
+if not valid or parsed.id ~= ARGV[4] then return 0 end
+redis.call('HDEL', hash, barrier_key)
+local staged = redis.call('HGETALL', KEYS[3])
+for index = 1, #staged, 2 do
+  local member_key = staged[index]
+  local payload = staged[index + 1]
+  local entry = cjson.decode(payload)
+  local matches = (ARGV[1] == 'guild' and entry.guildId == ARGV[2]) or
+                  (ARGV[1] == 'subject' and entry.subjectId == ARGV[3]) or
+                  (ARGV[1] == 'member' and entry.guildId == ARGV[2] and entry.subjectId == ARGV[3])
+  if matches and not member_blocked(entry.guildId, entry.subjectId, tonumber(ARGV[5])) then
+    redis.call('HSET', KEYS[1], member_key, merge(redis.call('HGET', KEYS[1], member_key), payload))
+    redis.call('ZADD', KEYS[2], entry.acceptedAt, member_key)
+    redis.call('HDEL', KEYS[3], member_key)
+  end
+end
+return 1
+`;
+const RENEW_BARRIER_SCRIPT = `
+local hash = ARGV[1] == 'guild' and KEYS[9] or (ARGV[1] == 'subject' and KEYS[11] or KEYS[10])
+local key = ARGV[1] == 'guild' and ARGV[2] or (ARGV[1] == 'subject' and ARGV[3] or (ARGV[2] .. string.char(0) .. ARGV[3]))
+local current = redis.call('HGET', hash, key)
+if not current then return 0 end
+local valid, parsed = pcall(cjson.decode, current)
+if not valid or parsed.id ~= ARGV[4] or tonumber(parsed.expiresAt) <= tonumber(ARGV[5]) then return 0 end
+parsed.expiresAt = tonumber(ARGV[6])
+redis.call('HSET', hash, key, cjson.encode(parsed))
+return 1
+`;
+const SUPPRESS_SUBJECT_SCRIPT = `
+local subject_id = ARGV[1]
+local cutoff = tonumber(ARGV[2])
+local suppression_id = ARGV[3]
+local current = redis.call('HGET', KEYS[8], subject_id)
+if current then
+  local parsed = cjson.decode(current)
+  if tonumber(parsed.cutoff) > cutoff then cutoff = tonumber(parsed.cutoff) end
+end
+redis.call('HSET', KEYS[8], subject_id, cjson.encode({cutoff = cutoff, id = suppression_id}))
+local discarded = 0
+for _, hash in ipairs({KEYS[1], KEYS[3]}) do
+  local values = redis.call('HGETALL', hash)
+  for index = 1, #values, 2 do
+    local entry = cjson.decode(values[index + 1])
+    if entry.subjectId == subject_id and tonumber(entry.acceptedAt) <= cutoff then
+      redis.call('HDEL', hash, values[index])
+      redis.call('ZREM', KEYS[2], values[index])
+      discarded = discarded + 1
+    end
+  end
+end
+for _, member_key in ipairs(redis.call('SMEMBERS', KEYS[7] .. subject_id)) do
+  redis.call('DEL', KEYS[6] .. member_key)
+end
+redis.call('DEL', KEYS[7] .. subject_id)
+return discarded
+`;
+const SUPPRESSION_STATUS_SCRIPT = `
+local subject_id = ARGV[1]
+local cutoff = tonumber(ARGV[2])
+local active = 0
+for _, operation_id in ipairs(redis.call('SMEMBERS', KEYS[12] .. subject_id)) do
+  local encoded = redis.call('HGET', KEYS[4], operation_id)
+  if not encoded then
+    redis.call('SREM', KEYS[12] .. subject_id, operation_id)
+  else
+    local claim = cjson.decode(encoded)
+    local matched = false
+    for _, entry in ipairs(claim.entries) do
+      if entry.subjectId == subject_id and tonumber(entry.acceptedAt) <= cutoff then matched = true end
+    end
+    if matched then active = active + 1 end
+  end
+end
+return active
+`;
+const RELEASE_SUBJECT_SCRIPT = `
+local current = redis.call('HGET', KEYS[8], ARGV[1])
+if not current then return 0 end
+local parsed = cjson.decode(current)
+if parsed.id ~= ARGV[2] then return 0 end
+redis.call('HDEL', KEYS[8], ARGV[1])
+return 1
+`;
+const SUPPRESS_GUILD_SCRIPT = `
+local guild_id = ARGV[1]
+local suppression_id = ARGV[2]
+redis.call('HSET', KEYS[13], guild_id, suppression_id)
+local discarded = 0
+for _, hash in ipairs({KEYS[1], KEYS[3]}) do
+  local values = redis.call('HGETALL', hash)
+  for index = 1, #values, 2 do
+    local entry = cjson.decode(values[index + 1])
+    if entry.guildId == guild_id then
+      redis.call('HDEL', hash, values[index])
+      redis.call('ZREM', KEYS[2], values[index])
+      discarded = discarded + 1
+    end
+  end
+end
+return discarded
+`;
+const GUILD_SUPPRESSION_STATUS_SCRIPT = `
+local guild_id = ARGV[1]
+local active = 0
+for _, operation_id in ipairs(redis.call('SMEMBERS', KEYS[14] .. guild_id)) do
+  local encoded = redis.call('HGET', KEYS[4], operation_id)
+  if not encoded then
+    redis.call('SREM', KEYS[14] .. guild_id, operation_id)
+  else
+    local claim = cjson.decode(encoded)
+    local matched = false
+    for _, entry in ipairs(claim.entries) do
+      if entry.guildId == guild_id then matched = true end
+    end
+    if matched then active = active + 1 end
+  end
+end
+return active
+`;
+const RELEASE_GUILD_SCRIPT = `
+if redis.call('HGET', KEYS[13], ARGV[1]) ~= ARGV[2] then return 0 end
+redis.call('HDEL', KEYS[13], ARGV[1])
+return 1
+`;
+const CLEAR_COOLDOWN_SCRIPT = `
+redis.call('DEL', KEYS[6] .. ARGV[1])
+redis.call('SREM', KEYS[7] .. ARGV[2], ARGV[1])
+return 1
+`;
+const CLEAR_SUBJECT_COOLDOWNS_SCRIPT = `
+for _, member_key in ipairs(redis.call('SMEMBERS', KEYS[7] .. ARGV[1])) do
+  redis.call('DEL', KEYS[6] .. member_key)
+end
+redis.call('DEL', KEYS[7] .. ARGV[1])
+return 1
+`;
+//# sourceMappingURL=numeric-write-behind-redis.js.map