@helyx/bot 1.5.2 → 1.5.4

package/dist/emergency-deletion-rest-transport.js

@@ -0,0 +1,253 @@
+import { DefaultRestOptions, DiscordAPIError, HTTPError, RateLimitError, REST, } from "@discordjs/rest";
+import { Agent } from "undici";
+import { GuardedDiscordDispatcher, GuardedDiscordDispatchError, } from "./guarded-discord-dispatcher.js";
+const scopeFields = [
+    "guildId",
+    "moduleId",
+    "channelId",
+    "messageId",
+    "admissionToken",
+];
+const restMethods = [
+    "delete",
+    "request",
+    "queueRequest",
+    "resolveRequest",
+    "createHandler",
+];
+const installedRestMethods = Object.freeze(restMethods.map((key) => [key, Reflect.get(REST.prototype, key)]));
+const installedDelete = Reflect.get(REST.prototype, "delete");
+// Identity only; this method is called by the existing REST manager, never detached here.
+const installedStrategy = Reflect.get(DefaultRestOptions, "makeRequest");
+const networkCodes = new Set([
+    "ECONNRESET",
+    "ECONNREFUSED",
+    "ETIMEDOUT",
+    "EAI_AGAIN",
+    "ENETUNREACH",
+    "UND_ERR_CONNECT_TIMEOUT",
+    "UND_ERR_HEADERS_TIMEOUT",
+    "UND_ERR_BODY_TIMEOUT",
+    "UND_ERR_SOCKET",
+]);
+const failed = Object.freeze({ kind: "failed" });
+/**
+ * Dormant transport. Core owns grants/lifecycle and the standard shared REST manager.
+ * Its method/strategy/handler surfaces must remain stable: a custom replacement that
+ * ignores dispatcher during REST's internal waits is outside this wire-fence contract.
+ */
+export class EmergencyMessageDeletionRestTransport {
+    #client;
+    #rest;
+    #agent;
+    #applicationId;
+    #origin;
+    #api;
+    #version;
+    #options;
+    #strategy;
+    constructor(options) {
+        this.#client = options.client;
+        this.#rest = options.client.rest;
+        this.#agent = options.agent;
+        this.#applicationId = options.expectedApplicationId;
+        const api = new URL(this.#rest.options.api);
+        if (process.release.name !== "node" ||
+            "bun" in process.versions ||
+            "deno" in process.versions ||
+            !(this.#rest instanceof REST) ||
+            !(this.#agent instanceof Agent) ||
+            typeof this.#applicationId !== "string" ||
+            !/^\d{17,20}$/u.test(this.#applicationId) ||
+            api.username ||
+            api.password ||
+            api.search ||
+            api.hash ||
+            api.pathname !== "/api" ||
+            !(api.protocol === "https:" ||
+                (api.protocol === "http:" &&
+                    ["127.0.0.1", "[::1]"].includes(api.hostname))) ||
+            !/^[1-9]\d?$/u.test(this.#rest.options.version) ||
+            !Number.isSafeInteger(options.maximumAgeMs) ||
+            options.maximumAgeMs < 1 ||
+            options.maximumAgeMs > 600_000 ||
+            !Number.isSafeInteger(options.maximumDispatches) ||
+            options.maximumDispatches < 1 ||
+            options.maximumDispatches > 16 ||
+            (options.now !== undefined && typeof options.now !== "function"))
+            throw new TypeError("Unsupported emergency REST transport context");
+        this.#origin = api.origin;
+        this.#api = this.#rest.options.api;
+        this.#version = this.#rest.options.version;
+        // This function selects installed Undici on the supported Node runtime.
+        this.#strategy = installedStrategy;
+        this.#options = Object.freeze({
+            maximumAgeMs: options.maximumAgeMs,
+            maximumDispatches: options.maximumDispatches,
+            ...(options.now ? { now: options.now } : {}),
+        });
+        if (!this.#sharedContext())
+            throw new TypeError("Unsupported emergency REST request strategy");
+    }
+    async deleteExact(input, attempt, grant) {
+        let guard;
+        try {
+            const target = Object.freeze({
+                guildId: input.guildId,
+                moduleId: input.moduleId,
+                channelId: input.channelId,
+                messageId: input.messageId,
+                admissionToken: input.admissionToken,
+            });
+            if (!validTarget(target) || !grant)
+                return failed;
+            const authorityScope = grant.scope;
+            const authorityCurrent = grant.isCurrent;
+            const attemptCurrent = attempt.isCurrent;
+            if (!scopeFields.every((key) => authorityScope[key] === target[key]) ||
+                typeof authorityCurrent !== "function" ||
+                typeof attemptCurrent !== "function")
+                return failed;
+            let refused = false;
+            const current = () => {
+                if (refused)
+                    return false;
+                try {
+                    if (!this.#ready() ||
+                        grant.scope !== authorityScope ||
+                        !scopeFields.every((key) => authorityScope[key] === target[key]) ||
+                        attemptCurrent() !== true ||
+                        authorityCurrent() !== true ||
+                        !this.#ready() ||
+                        attemptCurrent() !== true)
+                        refused = true;
+                }
+                catch {
+                    refused = true;
+                }
+                return !refused;
+            };
+            if (!current())
+                return failed;
+            guard = new GuardedDiscordDispatcher({
+                agent: this.#agent,
+                origin: this.#origin,
+                path: `/api/v${this.#version}/channels/${target.channelId}/messages/${target.messageId}`,
+                method: "DELETE",
+                isCurrent: current,
+                ...this.#options,
+            });
+            if (!current())
+                return failed;
+            await Reflect.apply(installedDelete, this.#rest, [
+                `/channels/${target.channelId}/messages/${target.messageId}`,
+                { dispatcher: guard },
+            ]);
+            return { kind: "deleted" };
+        }
+        catch (error) {
+            return classify(error);
+        }
+        finally {
+            // Only this request's facade is owned here. Never close/destroy the shared Agent.
+            guard?.stop();
+        }
+    }
+    #sharedContext() {
+        try {
+            return (this.#client.rest === this.#rest &&
+                Object.getPrototypeOf(this.#rest) === REST.prototype &&
+                this.#rest.agent === this.#agent &&
+                !this.#agent.closed &&
+                !this.#agent.destroyed &&
+                this.#rest.options.api === this.#api &&
+                this.#rest.options.version === this.#version &&
+                this.#rest.options.authPrefix === "Bot" &&
+                this.#rest.options.makeRequest === this.#strategy &&
+                DefaultRestOptions.makeRequest === this.#strategy &&
+                installedRestMethods.every(([key, method]) => {
+                    const descriptor = Object.getOwnPropertyDescriptor(REST.prototype, key);
+                    return (!Object.hasOwn(this.#rest, key) &&
+                        typeof method === "function" &&
+                        descriptor !== undefined &&
+                        "value" in descriptor &&
+                        descriptor.value === method);
+                }));
+        }
+        catch {
+            return false;
+        }
+    }
+    #ready() {
+        try {
+            return (this.#sharedContext() &&
+                this.#client.isReady() === true &&
+                this.#client.user?.id === this.#applicationId &&
+                this.#client.application?.id === this.#applicationId &&
+                this.#sharedContext());
+        }
+        catch {
+            return false;
+        }
+    }
+}
+function validTarget(input) {
+    return ([input.guildId, input.channelId, input.messageId].every((id) => typeof id === "string" && /^\d{17,20}$/u.test(id)) &&
+        typeof input.moduleId === "string" &&
+        /^helyx\.[a-z0-9][a-z0-9-]{0,79}$/u.test(input.moduleId) &&
+        typeof input.admissionToken === "string" &&
+        /^[A-Za-z0-9._:-]{1,256}$/u.test(input.admissionToken));
+}
+function classify(error) {
+    try {
+        if (error instanceof GuardedDiscordDispatchError)
+            return {
+                kind: error.code === "selector_mismatch" ? "invalid-request" : "transient",
+            };
+        if (error instanceof DiscordAPIError) {
+            const status = error.status, code = error.code;
+            if (status === 404 && code === 10008)
+                return { kind: "already-absent" };
+            if (status === 403)
+                return { kind: "missing-permission" };
+            if (status === 401)
+                return failed;
+            if (Number.isInteger(status) && status >= 400 && status < 500)
+                return { kind: "invalid-request" };
+            return failed;
+        }
+        if (error instanceof HTTPError)
+            return {
+                kind: Number.isInteger(error.status) &&
+                    error.status >= 500 &&
+                    error.status < 600
+                    ? "transient"
+                    : "failed",
+            };
+        if (error instanceof RateLimitError) {
+            const delays = [
+                error.retryAfter,
+                error.sublimitTimeout,
+                error.timeToReset,
+            ];
+            if (typeof error.global !== "boolean" ||
+                delays.some((delay) => !Number.isFinite(delay) || delay < 0 || delay > 86_400_000))
+                return failed;
+            const afterMs = Math.max(...delays);
+            return afterMs > 0
+                ? { kind: "retry", afterMs, scope: error.global ? "global" : "route" }
+                : failed;
+        }
+        if (error instanceof Error) {
+            const code = Reflect.get(error, "code");
+            if (error.name === "AbortError" ||
+                (typeof code === "string" && networkCodes.has(code)))
+                return { kind: "transient" };
+        }
+    }
+    catch {
+        /* No raw provider fields escape this classifier. */
+    }
+    return failed;
+}
+//# sourceMappingURL=emergency-deletion-rest-transport.js.map

package/dist/events.d.ts

@@ -3,10 +3,15 @@ import { inspectDiscordChannelAudit } from "./discord-channel-audit.js";
 import { type Client, type MessageReaction, type PartialMessageReaction } from "discord.js";
 import { type InteractionLogger } from "./interactions.js";
 import type { TransientViolationEvidenceStore } from "./transient-violation-evidence.js";
+import type { EmergencyDeletionDispatcher } from "./emergency-deletion-dispatcher.js";
+import { type MessageProtectionEligibility } from "./guild-message-protection-delivery.js";
 export declare function availabilityAwareInstallations(services: ServiceAccess, modulesById?: ReadonlyMap<string, ModuleDefinition>): Pick<InstallationService, "isModuleEnabled">;
 export declare function installModuleEvents(client: Client, modules: readonly ModuleDefinition[], logger: InteractionLogger, services: ServiceAccess, options?: {
     runtimeProfile?: "hosted" | "self-hosted";
     evidenceStore?: TransientViolationEvidenceStore;
+    messageProtectionEligibility?: MessageProtectionEligibility;
+    messageProtectionDeletion?: EmergencyDeletionDispatcher;
+    messageProtectionExpectedApplicationId?: string;
 }): ModuleEventHandle;
 export interface ModuleEventHandle {
     stop(): Promise<void>;

package/dist/events.js

@@ -10,6 +10,9 @@ import { canAccessModule } from "./premium-access.js";
 import { fromDiscordAction, toRuleSnapshot, } from "./discord-auto-moderation-service.js";
 import { PrivilegedMessageMetadataCache } from "./privileged-message-metadata-cache.js";
 import { DiscordAutoModerationExecutionIds } from "./discord-automod-execution-ids.js";
+import { createMessageProtectionAuthorityFactory } from "./guild-message-protection-deletion.js";
+import { GuildMessageUpdateMetadataDelivery } from "./guild-message-update-metadata.js";
+import { GuildMessageProtectionDelivery, } from "./guild-message-protection-delivery.js";
 export function availabilityAwareInstallations(services, modulesById) {
     const installations = services.get(HELYX_SERVICE_NAMES.installations);
     const candidate = typeof services.has === "function" &&
@@ -90,6 +93,7 @@ export function installModuleEvents(client, modules, logger, services, options)
         moduleId: module.manifest.id,
         classificationRequested: module.requiredDiscordCapabilities?.includes("message-content") ??
             false,
+        deletionAllowed: module.manifest.permissions?.includes("MANAGE_MESSAGES") ?? false,
         contribution,
     })));
     const guildVoiceSessionContributions = modules.flatMap((module) => (module.events?.guildVoiceSession ?? []).map((contribution) => ({
@@ -99,6 +103,9 @@ export function installModuleEvents(client, modules, logger, services, options)
     const messageClassificationRequested = modules.some((module) => module.requiredDiscordCapabilities?.includes("message-content"));
     const messageClassificationAvailable = messageClassificationRequested &&
         client.options.intents.has(GatewayIntentBits.MessageContent);
+    const protectionDelivery = new GuildMessageProtectionDelivery(options?.messageProtectionEligibility, services, messageClassificationAvailable, () => client.user?.id, () => client.application?.id, options?.messageProtectionDeletion, createMessageProtectionAuthorityFactory(client, options?.messageProtectionExpectedApplicationId, options?.messageProtectionEligibility, options?.messageProtectionDeletion));
+    const legacyMessageContributions = guildMessageContributions.filter(({ contribution }) => !contribution.protection);
+    const protectionMessageContributions = guildMessageContributions.filter(({ contribution }) => contribution.protection);
     const reactionContributions = modules.flatMap((module) => (module.events?.messageReactionAdd ?? []).map((contribution) => ({
         moduleId: module.manifest.id,
         contribution,
@@ -119,6 +126,11 @@ export function installModuleEvents(client, modules, logger, services, options)
         moduleId: module.manifest.id,
         contribution,
     })));
+    const messageUpdateMetadataContributions = modules.flatMap((module) => (module.events?.guildMessageUpdateMetadata ?? []).map((contribution) => ({
+        moduleId: module.manifest.id,
+        contribution,
+    })));
+    const updateMetadataDelivery = new GuildMessageUpdateMetadataDelivery(client, options?.messageProtectionExpectedApplicationId, options?.messageProtectionEligibility);
     const messageDeleteContributions = modules.flatMap((module) => (module.events?.messageDelete ?? []).map((contribution) => ({
         moduleId: module.manifest.id,
         contribution,
@@ -172,6 +184,7 @@ export function installModuleEvents(client, modules, logger, services, options)
         reactionRemoveAllContributions.length === 0 &&
         reactionRemoveEmojiContributions.length === 0 &&
         messageUpdateContributions.length === 0 &&
+        messageUpdateMetadataContributions.length === 0 &&
         messageDeleteContributions.length === 0 &&
         messageDeleteBulkContributions.length === 0 &&
         memberAddContributions.length === 0 &&
@@ -184,6 +197,14 @@ export function installModuleEvents(client, modules, logger, services, options)
         guildEmojiUpdateContributions.length === 0)
         return { stop: () => Promise.resolve(), queueDepth: () => 0 };
     const queue = new BoundedGuildEventQueue(logger);
+    const updateMetadataQueue = messageUpdateMetadataContributions.length
+        ? new BoundedGuildEventQueue(logger)
+        : undefined;
+    const updateMetadataError = (moduleId, error) => logger.warn({
+        event: "module.message_update_metadata_failed",
+        moduleId,
+        error: safeError(error),
+    }, "Module update metadata event failed");
     const privilegedMetadata = new PrivilegedMessageMetadataCache();
     const voiceSessions = new Map();
     const privilegedEligibilityQueue = privilegedMessageContributions.length > 0
@@ -272,15 +293,25 @@ export function installModuleEvents(client, modules, logger, services, options)
     }
     if (guildMessageContributions.length > 0) {
         client.on(Events.MessageCreate, (message) => {
-            if (!message.guildId ||
-                !guildMessageQueue ||
-                message.author.bot ||
-                message.author.system ||
-                Boolean(message.webhookId) ||
-                message.system) {
+            if (!message.guildId || !guildMessageQueue)
                 return;
-            }
-            guildMessageQueue.enqueue(message.guildId, () => handleGuildMessageCreate(message));
+            const protection = protectionDelivery.select(message, protectionMessageContributions);
+            const legacy = legacyMessageContributions.length > 0 &&
+                !message.author.bot &&
+                !message.author.system &&
+                !message.webhookId &&
+                !message.system;
+            if (!legacy && protection.length === 0)
+                return;
+            guildMessageQueue.enqueue(message.guildId, async () => {
+                await protectionDelivery.execute(message, protection, (moduleId, error) => logger.warn({
+                    event: "module.guild_message_protection_failed",
+                    moduleId,
+                    error: safeError(error),
+                }, "Module protection event failed"));
+                if (legacy)
+                    await handleGuildMessageCreate(message);
+            });
         });
     }
     if (guildVoiceSessionContributions.length > 0) {
@@ -323,6 +354,13 @@ export function installModuleEvents(client, modules, logger, services, options)
                 queue.enqueue(message.guildId, () => handleMessageUpdate(message));
         });
     }
+    if (updateMetadataQueue) {
+        client.on(Events.MessageUpdate, (_before, message) => {
+            const prepared = updateMetadataDelivery.prepare(message, messageUpdateMetadataContributions, updateMetadataError);
+            if (prepared)
+                updateMetadataQueue.enqueue(prepared.guildId, prepared.run);
+        });
+    }
     if (privilegedMessageUpdateContributions.length > 0) {
         client.on(Events.MessageUpdate, (_before, message) => {
             if (message.guildId)
@@ -614,7 +652,7 @@ export function installModuleEvents(client, modules, logger, services, options)
             message.author.username;
         const mentionedUserIds = [...message.mentions.users.keys()].slice(0, 25);
         let classifiedMessage;
-        for (const { moduleId, classificationRequested, contribution, } of guildMessageContributions) {
+        for (const { moduleId, classificationRequested, contribution, } of legacyMessageContributions) {
             try {
                 if (!(await installations.isModuleEnabled(message.guildId, moduleId))) {
                     continue;
@@ -1095,15 +1133,20 @@ export function installModuleEvents(client, modules, logger, services, options)
     }
     return {
         stop: async () => {
+            updateMetadataDelivery.stop();
+            protectionDelivery.stop();
+            options?.messageProtectionDeletion?.stop();
             await privilegedEligibilityQueue?.stop();
             await guildMessageQueue?.stop();
+            await updateMetadataQueue?.stop();
             await queue.stop();
             voiceSessions.clear();
             privilegedMetadata.clear();
         },
         queueDepth: () => queue.queueDepth() +
             (privilegedEligibilityQueue?.queueDepth() ?? 0) +
-            (guildMessageQueue?.queueDepth() ?? 0),
+            (guildMessageQueue?.queueDepth() ?? 0) +
+            (updateMetadataQueue?.queueDepth() ?? 0),
     };
 }
 class BoundedGuildEventQueue {

package/dist/guarded-discord-dispatcher.d.ts

@@ -0,0 +1,29 @@
+import { Agent, type Dispatcher } from "undici";
+type Refusal = "selector_mismatch" | "stopped" | "revoked" | "expired" | "clock_invalid" | "budget_exhausted";
+/** Private refusal, deliberately outside the REST AbortError/ECONNRESET retry classifier. */
+export declare class GuardedDiscordDispatchError extends Error {
+    readonly code: Refusal;
+    constructor(code: Refusal);
+}
+interface Options {
+    agent: Agent;
+    origin: string;
+    path: string;
+    method: "DELETE";
+    isCurrent(this: void): boolean;
+    maximumAgeMs: number;
+    maximumDispatches: number;
+    now?: () => number;
+}
+/** Dormant exact-request facade. It delegates connections and their ownership to the supplied agent. */
+export declare class GuardedDiscordDispatcher extends Agent {
+    #private;
+    constructor(options: Options);
+    /** Admissions immediately before socket dispatch, not confirmed HTTP deliveries or outer queue attempts. */
+    get admittedConnects(): number;
+    /** Does not close or destroy the shared agent, and cannot recall requests already dispatched. */
+    stop(): void;
+    dispatch(options: Agent.DispatchOptions, handler: Dispatcher.DispatchHandlers): boolean;
+}
+export {};
+//# sourceMappingURL=guarded-discord-dispatcher.d.ts.map

package/dist/guarded-discord-dispatcher.js

@@ -0,0 +1,204 @@
+import { performance } from "node:perf_hooks";
+import { Agent } from "undici";
+/** Private refusal, deliberately outside the REST AbortError/ECONNRESET retry classifier. */
+export class GuardedDiscordDispatchError extends Error {
+    code;
+    constructor(code) {
+        super("Guarded Discord dispatch refused");
+        this.name = "GuardedDiscordDispatchError";
+        this.code = code;
+    }
+}
+/** Dormant exact-request facade. It delegates connections and their ownership to the supplied agent. */
+export class GuardedDiscordDispatcher extends Agent {
+    #agent;
+    #origin;
+    #path;
+    #isCurrent;
+    #now;
+    #acceptedAt;
+    #maximumAgeMs;
+    #maximumDispatches;
+    #lastNow;
+    #admittedConnects = 0;
+    #refused;
+    constructor(options) {
+        super({
+            factory() {
+                throw new Error("Guarded facade must not create a connection pool");
+            },
+        });
+        const origin = canonicalOrigin(options.origin);
+        if (!(options.agent instanceof Agent) ||
+            !origin ||
+            options.method !== "DELETE" ||
+            !/^\/api\/v[1-9]\d?\/channels\/\d{17,20}\/messages\/\d{17,20}$/u.test(options.path) ||
+            typeof options.isCurrent !== "function" ||
+            (options.now !== undefined && typeof options.now !== "function") ||
+            !Number.isSafeInteger(options.maximumAgeMs) ||
+            options.maximumAgeMs < 1 ||
+            options.maximumAgeMs > 600_000 ||
+            !Number.isSafeInteger(options.maximumDispatches) ||
+            options.maximumDispatches < 1 ||
+            options.maximumDispatches > 16)
+            throw new TypeError("Invalid guarded Discord dispatcher options");
+        this.#agent = options.agent;
+        this.#origin = origin;
+        this.#path = options.path;
+        this.#isCurrent = options.isCurrent;
+        this.#maximumAgeMs = options.maximumAgeMs;
+        this.#maximumDispatches = options.maximumDispatches;
+        this.#now = options.now ?? (() => performance.now());
+        const now = this.#now();
+        if (!Number.isFinite(now) ||
+            now < 0 ||
+            now > Number.MAX_SAFE_INTEGER - this.#maximumAgeMs)
+            throw new TypeError("Invalid guarded Discord dispatcher clock");
+        this.#acceptedAt = this.#lastNow = now;
+    }
+    /** Admissions immediately before socket dispatch, not confirmed HTTP deliveries or outer queue attempts. */
+    get admittedConnects() {
+        return this.#admittedConnects;
+    }
+    /** Does not close or destroy the shared agent, and cannot recall requests already dispatched. */
+    stop() {
+        this.#refused ??= "stopped";
+    }
+    dispatch(options, handler) {
+        const snapshot = { ...options };
+        const captured = Object.freeze({
+            ...snapshot,
+            origin: canonicalOrigin(snapshot.origin) ?? "",
+        });
+        const failure = this.#matches(captured)
+            ? this.#check()
+            : "selector_mismatch";
+        if (failure) {
+            const error = new GuardedDiscordDispatchError(failure);
+            if (!handler.onError)
+                throw error;
+            handler.onError(error);
+            return false;
+        }
+        const guarded = new Proxy({}, {
+            get: (_facade, key) => {
+                const target = handler;
+                if (key === "onConnect")
+                    return (abort, ...arguments_) => {
+                        const failure = this.#check();
+                        if (failure) {
+                            abort(new GuardedDiscordDispatchError(failure));
+                            return;
+                        }
+                        const callback = Reflect.get(target, key, target);
+                        const beforeCallback = this.#check();
+                        if (beforeCallback) {
+                            abort(new GuardedDiscordDispatchError(beforeCallback));
+                            return;
+                        }
+                        const result = typeof callback === "function"
+                            ? Reflect.apply(callback, target, [abort, ...arguments_])
+                            : undefined;
+                        const finalFailure = this.#check();
+                        if (finalFailure) {
+                            abort(new GuardedDiscordDispatchError(finalFailure));
+                            return;
+                        }
+                        this.#admittedConnects++;
+                        return result;
+                    };
+                const value = Reflect.get(target, key, target);
+                const forwarded = typeof value === "function" ? value.bind(target) : value;
+                return forwarded;
+            },
+        });
+        return this.#agent.dispatch(captured, guarded);
+    }
+    #matches(options) {
+        return (options.method === "DELETE" &&
+            canonicalOrigin(options.origin) === this.#origin &&
+            options.path === this.#path &&
+            options.query === undefined &&
+            (options.body === undefined || options.body === null) &&
+            (options.upgrade === undefined ||
+                options.upgrade === null ||
+                options.upgrade === false));
+    }
+    #check() {
+        const terminal = this.#terminal();
+        if (terminal)
+            return terminal;
+        const clockFailure = this.#checkClock();
+        if (clockFailure)
+            return clockFailure;
+        if (this.#admittedConnects >= this.#maximumDispatches)
+            return this.#refuse("budget_exhausted");
+        try {
+            const current = this.#isCurrent();
+            const afterAuthority = this.#terminal();
+            if (afterAuthority)
+                return afterAuthority;
+            if (current !== true)
+                return this.#refuse("revoked");
+        }
+        catch {
+            return this.#refuse("revoked");
+        }
+        const finalClockFailure = this.#checkClock();
+        if (finalClockFailure)
+            return finalClockFailure;
+        if (this.#admittedConnects >= this.#maximumDispatches)
+            return this.#refuse("budget_exhausted");
+        return undefined;
+    }
+    #checkClock() {
+        let now;
+        try {
+            now = this.#now();
+        }
+        catch {
+            return this.#refuse("clock_invalid");
+        }
+        const afterClock = this.#terminal();
+        if (afterClock)
+            return afterClock;
+        if (!Number.isFinite(now) ||
+            now < this.#lastNow ||
+            now > Number.MAX_SAFE_INTEGER)
+            return this.#refuse("clock_invalid");
+        this.#lastNow = now;
+        if (now - this.#acceptedAt >= this.#maximumAgeMs)
+            return this.#refuse("expired");
+        return undefined;
+    }
+    #terminal() {
+        if (this.#refused)
+            return this.#refused;
+        if (this.closed || this.destroyed)
+            return this.#refuse("stopped");
+        return undefined;
+    }
+    #refuse(code) {
+        this.#refused ??= code;
+        return this.#refused;
+    }
+}
+function canonicalOrigin(input) {
+    if (!(typeof input === "string" || input instanceof URL))
+        return undefined;
+    try {
+        const url = new URL(input);
+        if (!/^https?:$/u.test(url.protocol) ||
+            url.username ||
+            url.password ||
+            url.pathname !== "/" ||
+            url.search ||
+            url.hash)
+            return undefined;
+        return url.origin;
+    }
+    catch {
+        return undefined;
+    }
+}
+//# sourceMappingURL=guarded-discord-dispatcher.js.map

package/dist/guild-command-discord-client.d.ts

@@ -4,6 +4,7 @@ export interface GuildCommandDiscordRest {
     put(route: `/${string}`, options: {
         body: unknown;
     }): Promise<unknown>;
+    delete(route: `/${string}`): Promise<unknown>;
 }
 export declare class GuildCommandDiscordClient {
     #private;
@@ -16,6 +17,7 @@ export declare class GuildCommandDiscordClient {
     });
     canWrite(guildId: string): boolean;
     observe(guildId: string): Promise<ObservedGuildCommand[]>;
+    remove(guildId: string, commandId: string): Promise<void>;
     replace(guildId: string, definitions: readonly ProjectedGuildCommand[]): Promise<ObservedGuildCommand[]>;
 }
 //# sourceMappingURL=guild-command-discord-client.d.ts.map

package/dist/guild-command-discord-client.js

@@ -24,6 +24,13 @@ export class GuildCommandDiscordClient {
         validateSnowflake(guildId, "Guild ID");
         return parseCommandCollection(await this.#rest.get(Routes.applicationGuildCommands(this.#applicationId, guildId)));
     }
+    async remove(guildId, commandId) {
+        validateSnowflake(guildId, "Guild ID");
+        validateSnowflake(commandId, "Command ID");
+        if (!this.canWrite(guildId))
+            throw new Error("Guild command write target is not allowlisted");
+        await this.#rest.delete(Routes.applicationGuildCommand(this.#applicationId, guildId, commandId));
+    }
     async replace(guildId, definitions) {
         validateSnowflake(guildId, "Guild ID");
         if (!this.canWrite(guildId))