@helyx/bot 0.4.31 → 0.4.33

package/dist/modules.d.ts

@@ -12,11 +12,13 @@ export interface ConfiguredModulePackage extends LoadedDefinition {
 }
 export declare const secureRandomSelectionWorkerKeyName = "HELYX_INTERNAL_SECURE_RANDOM_SELECTION_KEY";
 interface PlatformServiceEnvironment extends Pick<BotEnvironment, "HELYX_DATA_ENCRYPTION_KEY"> {
+    HELYX_DASHBOARD_PUBLIC_URL?: string;
     HELYX_INTERNAL_SECURE_RANDOM_SELECTION_KEY?: string;
 }
 export declare function deriveSecureRandomSelectionKey(encodedDataEncryptionKey: string): Uint8Array;
 export declare function platformServiceOptions(environment: PlatformServiceEnvironment, modules: readonly ModuleDefinition[]): {
     secureRandomSelectionKey?: Uint8Array;
+    dashboardBaseUrl?: string;
 };
 export declare function loadConfiguredModules(specifiers: readonly string[], importer?: ModuleImporter): Promise<ModuleDefinition[]>;
 export declare function loadConfiguredModulePackages(specifiers: readonly string[], importer?: ModuleImporter, resolvePackageJson?: PackageJsonResolver, readPackageJson?: PackageJsonReader): Promise<ConfiguredModulePackage[]>;

package/dist/modules.js

@@ -21,9 +21,13 @@ export function deriveSecureRandomSelectionKey(encodedDataEncryptionKey) {
         .digest();
 }
 export function platformServiceOptions(environment, modules) {
+    const urls = environment.HELYX_DASHBOARD_PUBLIC_URL
+        ? { dashboardBaseUrl: environment.HELYX_DASHBOARD_PUBLIC_URL }
+        : {};
     const internalSelectionKey = environment.HELYX_INTERNAL_SECURE_RANDOM_SELECTION_KEY;
     if (internalSelectionKey) {
         return {
+            ...urls,
             secureRandomSelectionKey: decodeSecureRandomSelectionKey(internalSelectionKey, secureRandomSelectionWorkerKeyName),
         };
     }
@@ -32,9 +36,10 @@ export function platformServiceOptions(environment, modules) {
         if (modules.some(({ manifest }) => manifest.id === giveawaysModuleId)) {
             throw new Error("HELYX_DATA_ENCRYPTION_KEY is required when Giveaways is loaded");
         }
-        return {};
+        return urls;
     }
     return {
+        ...urls,
         secureRandomSelectionKey: deriveSecureRandomSelectionKey(encodedKey),
     };
 }
@@ -103,7 +108,11 @@ export function validateContributionParity(definition) {
         ...(definition.events?.guildVoiceSession ?? []),
         ...(definition.events?.messageReactionAdd ?? []),
         ...(definition.events?.messageReactionRemove ?? []),
+        ...(definition.events?.messageReactionRemoveAll ?? []),
+        ...(definition.events?.messageReactionRemoveEmoji ?? []),
+        ...(definition.events?.guildMessageUpdate ?? []),
         ...(definition.events?.messageDelete ?? []),
+        ...(definition.events?.guildMessageDeleteBulk ?? []),
         ...(definition.events?.guildMemberAdd ?? []),
         ...(definition.events?.guildMemberRemove ?? []),
         ...(definition.events?.guildRoleDelete ?? []),

package/dist/oauth-module.d.ts

@@ -0,0 +1,2 @@
+export declare function createOAuthModule(): import("@helyx/sdk").ModuleDefinition;
+//# sourceMappingURL=oauth-module.d.ts.map

package/dist/oauth-module.js

@@ -0,0 +1,196 @@
+import { defineModule, HELYX_SERVICE_NAMES, } from "@helyx/sdk";
+const MODULE_ID = "helyx.oauth";
+const MODAL_ID = "helyx.oauth.revoke";
+const SERVICE_FIELD_ID = "helyx.oauth.revoke.service";
+const CONFIRM_FIELD_ID = "helyx.oauth.revoke.confirm";
+const COMMENT_FIELD_ID = "helyx.oauth.revoke.comment";
+const everyonePolicy = {
+    everyone: true,
+    requiredPermissions: [],
+    allowedRoleIds: [],
+    deniedRoleIds: [],
+    allowedUserIds: [],
+    deniedUserIds: [],
+};
+export function createOAuthModule() {
+    return defineModule({
+        manifest: {
+            manifestVersion: "0.1",
+            releaseStatus: "live",
+            id: MODULE_ID,
+            name: "Helyx OAuth",
+            version: "0.1.0",
+            description: "Provides self-service OAuth connection revocation.",
+            entry: "./dist/oauth-module.js",
+            framework: "^0.1.0",
+            dependencies: [],
+            permissions: [],
+            contributions: { commands: ["oauth"], events: [] },
+        },
+        defaultPermissions: {
+            module: everyonePolicy,
+            commands: { "oauth.revoke": everyonePolicy },
+        },
+        interactions: {
+            commands: [
+                {
+                    name: "oauth",
+                    description: "Manage OAuth access granted to Helyx.",
+                    registration: "global",
+                    contexts: ["guild"],
+                    integrationTypes: ["guild_install"],
+                    subcommands: [
+                        {
+                            name: "revoke",
+                            description: "Revoke a service and delete the OAuth details Helyx stores for you.",
+                            rateLimit: { scope: "user", limit: 5, windowSeconds: 60 },
+                            execute: async (context) => {
+                                const oauth = context.services.get(HELYX_SERVICE_NAMES.oauth);
+                                let connections;
+                                try {
+                                    connections = await oauth.listConnections({
+                                        discordUserId: context.userId,
+                                    });
+                                }
+                                catch {
+                                    await context.reply(unavailable());
+                                    return;
+                                }
+                                if (connections.length === 0) {
+                                    await context.reply({
+                                        ephemeral: true,
+                                        componentsV2: {
+                                            text: [
+                                                {
+                                                    content: "You do not have any OAuth services connected to Helyx.",
+                                                },
+                                            ],
+                                        },
+                                    });
+                                    return;
+                                }
+                                await context.showModal({
+                                    customId: MODAL_ID,
+                                    title: "Revoke OAuth access",
+                                    items: [
+                                        {
+                                            type: "text-display",
+                                            content: "Choose one connection. This disconnects the service from Helyx everywhere. Any Helyx module, server or panel using it will lose access.",
+                                        },
+                                        {
+                                            type: "string-select",
+                                            customId: SERVICE_FIELD_ID,
+                                            label: "Connected service",
+                                            placeholder: "Choose a connection",
+                                            required: true,
+                                            minValues: 1,
+                                            maxValues: 1,
+                                            options: connections.slice(0, 25).map((connection) => ({
+                                                label: `${providerName(connection.provider)} — ${connection.displayName}`.slice(0, 100),
+                                                value: connection.selectionRef,
+                                                description: "Remove this connection",
+                                            })),
+                                        },
+                                        {
+                                            type: "string-select",
+                                            customId: CONFIRM_FIELD_ID,
+                                            label: "Confirm removal",
+                                            placeholder: "Select Remove access",
+                                            required: true,
+                                            minValues: 1,
+                                            maxValues: 1,
+                                            options: [
+                                                {
+                                                    label: "Remove access",
+                                                    value: "remove_access",
+                                                    description: "Revoke access and delete my stored details",
+                                                },
+                                            ],
+                                        },
+                                        {
+                                            customId: COMMENT_FIELD_ID,
+                                            label: "Reason or comment (optional)",
+                                            description: "Stored only in Helyx's restricted security audit.",
+                                            style: "paragraph",
+                                            required: false,
+                                            maxLength: 250,
+                                        },
+                                    ],
+                                    fields: [],
+                                });
+                            },
+                        },
+                    ],
+                },
+            ],
+            modals: [
+                {
+                    customId: MODAL_ID,
+                    execute: async (context) => {
+                        const selectionRef = context.getStringSelectValues(SERVICE_FIELD_ID)[0];
+                        const confirmation = context.getStringSelectValues(CONFIRM_FIELD_ID)[0];
+                        if (!selectionRef || confirmation !== "remove_access") {
+                            await context.reply({
+                                ephemeral: true,
+                                componentsV2: {
+                                    text: [{ content: "Access was not removed." }],
+                                },
+                            });
+                            return;
+                        }
+                        const comment = context.getField(COMMENT_FIELD_ID).trim();
+                        await context.deferReply?.(true);
+                        try {
+                            const result = await context.services
+                                .get(HELYX_SERVICE_NAMES.oauth)
+                                .revoke({
+                                discordUserId: context.userId,
+                                selectionRef,
+                                confirmation: "remove_access",
+                                ...(comment ? { comment } : {}),
+                                correlationId: context.interactionId,
+                            });
+                            await context.reply({
+                                ephemeral: true,
+                                componentsV2: {
+                                    text: [
+                                        {
+                                            content: result.outcome === "processing"
+                                                ? `${providerName(result.provider)} access removal is already in progress. Helyx will finish it automatically.`
+                                                : result.outcome === "cleanup_pending"
+                                                    ? `${providerName(result.provider)} credentials were deleted. Helyx is still removing related roles and connection records.`
+                                                    : result.providerRevocation === "completed"
+                                                        ? `${providerName(result.provider)} access has been removed from Helyx. Local credentials were deleted.`
+                                                        : `${providerName(result.provider)} access has been removed from Helyx and local credentials were deleted. Helyx could not confirm provider-side revocation, so you may also remove Helyx from your ${providerName(result.provider)} connected-app settings.`,
+                                        },
+                                    ],
+                                },
+                            });
+                        }
+                        catch {
+                            await context.reply(unavailable());
+                        }
+                    },
+                },
+            ],
+        },
+        start: () => Promise.resolve(),
+        stop: () => Promise.resolve(),
+    });
+}
+function providerName(provider) {
+    return provider === "youtube" ? "YouTube" : "Twitch";
+}
+function unavailable() {
+    return {
+        ephemeral: true,
+        componentsV2: {
+            text: [
+                {
+                    content: "OAuth access could not be updated right now. Nothing new was retained; please try again.",
+                },
+            ],
+        },
+    };
+}
+//# sourceMappingURL=oauth-module.js.map

package/dist/oauth-module.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=oauth-module.test.d.ts.map

package/dist/oauth-module.test.js

@@ -0,0 +1,172 @@
+import { HELYX_SERVICE_NAMES, } from "@helyx/sdk";
+import { describe, expect, it, vi } from "vitest";
+import { createOAuthModule } from "./oauth-module.js";
+describe("global OAuth command", () => {
+    it("is global, guild-scoped and available without management permissions", () => {
+        const module = createOAuthModule();
+        const command = module.interactions?.commands?.[0];
+        const revoke = command?.subcommands?.[0];
+        expect(command).toMatchObject({
+            name: "oauth",
+            registration: "global",
+            contexts: ["guild"],
+            integrationTypes: ["guild_install"],
+        });
+        expect(revoke).toMatchObject({
+            name: "revoke",
+            rateLimit: { scope: "user", limit: 5, windowSeconds: 60 },
+        });
+        expect(module.manifest.permissions).toEqual([]);
+        expect(module.defaultPermissions?.commands["oauth.revoke"]).toMatchObject({
+            everyone: true,
+            requiredPermissions: [],
+        });
+    });
+    it("does not open a modal when the acting user has no connections", async () => {
+        const oauth = oauthService({ connections: [] });
+        const showModal = vi.fn();
+        const replies = [];
+        const command = createOAuthModule().interactions?.commands?.[0]?.subcommands?.[0];
+        await command?.execute(commandContext(oauth, {
+            showModal,
+            reply: (response) => {
+                replies.push(response);
+                return Promise.resolve();
+            },
+        }));
+        expect(showModal).not.toHaveBeenCalled();
+        expect(replies).toEqual([expect.objectContaining({ ephemeral: true })]);
+        expect(replies[0]?.componentsV2?.text?.[0]?.content).toContain("do not have any OAuth services");
+    });
+    it("uses opaque selections and requires explicit removal confirmation", async () => {
+        const oauth = oauthService({
+            connections: [
+                {
+                    selectionRef: "opaque-selection-reference-123",
+                    provider: "youtube",
+                    displayName: "Example creator",
+                    connectedAt: new Date().toISOString(),
+                },
+            ],
+        });
+        const showModal = vi.fn();
+        const command = createOAuthModule().interactions?.commands?.[0]?.subcommands?.[0];
+        await command?.execute(commandContext(oauth, { showModal }));
+        const modal = showModal.mock.calls[0]?.[0];
+        expect(modal?.title).toBe("Revoke OAuth access");
+        const service = modal?.items?.find((item) => "customId" in item && item.customId.endsWith("service"));
+        const confirmation = modal?.items?.find((item) => "customId" in item && item.customId.endsWith("confirm"));
+        expect(service).toMatchObject({
+            type: "string-select",
+            required: true,
+            options: [
+                expect.objectContaining({ value: "opaque-selection-reference-123" }),
+            ],
+        });
+        expect(confirmation).toMatchObject({
+            type: "string-select",
+            required: true,
+            options: [expect.objectContaining({ value: "remove_access" })],
+        });
+    });
+    it("revokes only for the acting user and returns an ephemeral advisory", async () => {
+        const revoke = vi.fn().mockResolvedValue({
+            provider: "twitch",
+            outcome: "completed",
+            providerRevocation: "failed",
+        });
+        const oauth = oauthService({ connections: [], revoke });
+        const replies = [];
+        const modal = createOAuthModule().interactions?.modals?.[0];
+        await modal?.execute(modalContext(oauth, {
+            reply: (response) => {
+                replies.push(response);
+                return Promise.resolve();
+            },
+        }));
+        expect(revoke).toHaveBeenCalledWith({
+            discordUserId: "12345678901234567",
+            selectionRef: "opaque-selection-reference-123",
+            confirmation: "remove_access",
+            comment: "No longer needed",
+            correlationId: "interaction-1",
+        });
+        expect(replies[0]).toMatchObject({ ephemeral: true });
+        expect(replies[0]?.componentsV2?.text?.[0]?.content).toContain("connected-app settings");
+    });
+});
+function oauthService(input) {
+    return {
+        connectionStatus: () => Promise.resolve([]),
+        listConnections: () => Promise.resolve(input.connections),
+        createAuthorization: () => Promise.resolve({
+            authorizationUrl: "https://example.com",
+            expiresAt: "",
+        }),
+        verifyEligibility: () => Promise.resolve({
+            provider: "youtube",
+            status: "unknown",
+            connected: false,
+            checkedAt: new Date().toISOString(),
+        }),
+        revoke: input.revoke ??
+            (() => Promise.resolve({
+                provider: "youtube",
+                outcome: "completed",
+                providerRevocation: "completed",
+            })),
+    };
+}
+function services(oauth) {
+    return {
+        has: (name) => name === HELYX_SERVICE_NAMES.oauth,
+        get: (name) => {
+            if (name !== HELYX_SERVICE_NAMES.oauth)
+                throw new Error("unknown service");
+            return oauth;
+        },
+    };
+}
+function commandContext(oauth, overrides = {}) {
+    return {
+        ...interactionBase(oauth),
+        showModal: () => Promise.resolve(),
+        getStringOption: () => null,
+        getBooleanOption: () => null,
+        getUserOption: () => null,
+        getChannelOption: () => null,
+        getRoleOption: () => null,
+        ...overrides,
+    };
+}
+function modalContext(oauth, overrides = {}) {
+    return {
+        ...interactionBase(oauth),
+        getField: (customId) => customId.endsWith("comment") ? "No longer needed" : "",
+        getStringSelectValues: (customId) => customId.endsWith("service")
+            ? ["opaque-selection-reference-123"]
+            : ["remove_access"],
+        getSelectedUserIds: () => [],
+        getSelectedRoleIds: () => [],
+        getSelectedMentionables: () => ({ userIds: [], roleIds: [] }),
+        getSelectedChannelIds: () => [],
+        ...overrides,
+    };
+}
+function interactionBase(oauth) {
+    return {
+        interactionId: "interaction-1",
+        userId: "12345678901234567",
+        userDisplayName: "Member",
+        userRoleIds: [],
+        isAdministrator: false,
+        serverId: "12345678901234568",
+        services: services(oauth),
+        reply: () => Promise.resolve(),
+        sendToChannel: () => Promise.resolve({ messageId: "message-1" }),
+        deleteChannelMessage: () => Promise.resolve(),
+        editChannelMessage: () => Promise.resolve(),
+        addChannelMessageReaction: () => Promise.resolve(),
+    };
+}
+//# sourceMappingURL=oauth-module.test.js.map

package/dist/oauth-service.d.ts

@@ -0,0 +1,16 @@
+import type { OAuthConnectionSummary, OAuthEligibilityResult, OAuthService } from "@helyx/sdk";
+export declare class HttpOAuthService implements OAuthService {
+    #private;
+    private readonly internalSecret;
+    constructor(baseUrl: string, internalSecret: string);
+    listConnections(input: {
+        discordUserId: string;
+    }): Promise<readonly OAuthConnectionSummary[]>;
+    connectionStatus(input: {
+        discordUserId: string;
+    }): Promise<readonly ("youtube" | "twitch")[]>;
+    createAuthorization(input: Parameters<OAuthService["createAuthorization"]>[0]): ReturnType<OAuthService["createAuthorization"]>;
+    verifyEligibility(input: Parameters<OAuthService["verifyEligibility"]>[0]): Promise<OAuthEligibilityResult>;
+    revoke(input: Parameters<OAuthService["revoke"]>[0]): ReturnType<OAuthService["revoke"]>;
+}
+//# sourceMappingURL=oauth-service.d.ts.map

package/dist/oauth-service.js

@@ -0,0 +1,40 @@
+export class HttpOAuthService {
+    internalSecret;
+    #baseUrl;
+    constructor(baseUrl, internalSecret) {
+        this.internalSecret = internalSecret;
+        this.#baseUrl = new URL(baseUrl);
+    }
+    async listConnections(input) {
+        const result = await this.#request("/v1/internal/oauth/connections", input);
+        return result.connections;
+    }
+    async connectionStatus(input) {
+        const result = await this.#request("/v1/internal/oauth/status", input);
+        return result.providers;
+    }
+    createAuthorization(input) {
+        return this.#request("/v1/internal/oauth/authorizations", input);
+    }
+    verifyEligibility(input) {
+        return this.#request("/v1/internal/oauth/eligibility", input);
+    }
+    revoke(input) {
+        return this.#request("/v1/internal/oauth/revocations", input);
+    }
+    async #request(path, body) {
+        const response = await fetch(new URL(path, this.#baseUrl), {
+            method: "POST",
+            headers: {
+                authorization: `Bearer ${this.internalSecret}`,
+                "content-type": "application/json",
+            },
+            body: JSON.stringify(body),
+            signal: AbortSignal.timeout(15_000),
+        });
+        if (!response.ok)
+            throw new Error(`oauth_service_http_${response.status}`);
+        return (await response.json());
+    }
+}
+//# sourceMappingURL=oauth-service.js.map

package/dist/shard-contracts.d.ts

@@ -359,6 +359,20 @@ export declare const shardControlOperationSchema: z.ZodDiscriminatedUnion<[z.Zod
     expectedRevision: z.ZodNumber;
     value: z.ZodRecord<z.ZodString, z.ZodCustom<ManagedResourceValue, ManagedResourceValue>>;
     actorAuthenticatedAt: z.ZodOptional<z.ZodISODateTime>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"oauth.consumer.cleanup">;
+    consumerBindingId: z.ZodUUID;
+    moduleId: z.ZodString;
+    provider: z.ZodEnum<{
+        youtube: "youtube";
+        twitch: "twitch";
+    }>;
+    guildId: z.ZodString;
+    resourceType: z.ZodString;
+    resourceId: z.ZodString;
+    subjectUserId: z.ZodString;
+    contractVersion: z.ZodNumber;
+    correlationId: z.ZodString;
 }, z.core.$strict>, z.ZodObject<{
     kind: z.ZodLiteral<"support.notification.send">;
     guildId: z.ZodString;
@@ -698,6 +712,20 @@ export declare const shardControlRequestSchema: z.ZodObject<{
         expectedRevision: z.ZodNumber;
         value: z.ZodRecord<z.ZodString, z.ZodCustom<ManagedResourceValue, ManagedResourceValue>>;
         actorAuthenticatedAt: z.ZodOptional<z.ZodISODateTime>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"oauth.consumer.cleanup">;
+        consumerBindingId: z.ZodUUID;
+        moduleId: z.ZodString;
+        provider: z.ZodEnum<{
+            youtube: "youtube";
+            twitch: "twitch";
+        }>;
+        guildId: z.ZodString;
+        resourceType: z.ZodString;
+        resourceId: z.ZodString;
+        subjectUserId: z.ZodString;
+        contractVersion: z.ZodNumber;
+        correlationId: z.ZodString;
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"support.notification.send">;
         guildId: z.ZodString;
@@ -1542,6 +1570,20 @@ export declare const supervisorMessageSchema: z.ZodDiscriminatedUnion<[z.ZodObje
         expectedRevision: z.ZodNumber;
         value: z.ZodRecord<z.ZodString, z.ZodCustom<ManagedResourceValue, ManagedResourceValue>>;
         actorAuthenticatedAt: z.ZodOptional<z.ZodISODateTime>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"oauth.consumer.cleanup">;
+        consumerBindingId: z.ZodUUID;
+        moduleId: z.ZodString;
+        provider: z.ZodEnum<{
+            youtube: "youtube";
+            twitch: "twitch";
+        }>;
+        guildId: z.ZodString;
+        resourceType: z.ZodString;
+        resourceId: z.ZodString;
+        subjectUserId: z.ZodString;
+        contractVersion: z.ZodNumber;
+        correlationId: z.ZodString;
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"support.notification.send">;
         guildId: z.ZodString;

package/dist/shard-contracts.js

@@ -425,6 +425,20 @@ export const shardControlOperationSchema = z.discriminatedUnion("kind", [
         ...mutationContext.shape,
     })
         .strict(),
+    z
+        .object({
+        kind: z.literal("oauth.consumer.cleanup"),
+        consumerBindingId: z.uuid(),
+        moduleId,
+        provider: z.enum(["youtube", "twitch"]),
+        guildId: snowflake,
+        resourceType,
+        resourceId,
+        subjectUserId: snowflake,
+        contractVersion: z.number().int().min(1).max(32_767),
+        correlationId: z.string().trim().min(1).max(200),
+    })
+        .strict(),
     z
         .object({
         kind: z.literal("support.notification.send"),
@@ -1111,6 +1125,18 @@ export async function executeShardControlOperation(handler, operation) {
                     ? { actorAuthenticatedAt: operation.actorAuthenticatedAt }
                     : {}),
             });
+        case "oauth.consumer.cleanup":
+            return handler.cleanupOAuthConsumer({
+                consumerBindingId: operation.consumerBindingId,
+                moduleId: operation.moduleId,
+                provider: operation.provider,
+                guildId: operation.guildId,
+                resourceType: operation.resourceType,
+                resourceId: operation.resourceId,
+                subjectUserId: operation.subjectUserId,
+                contractVersion: operation.contractVersion,
+                correlationId: operation.correlationId,
+            });
         case "support.notification.send": {
             return handler.sendSupportNotification({
                 notificationId: operation.notificationId,

package/dist/shard-router.d.ts

@@ -15,6 +15,7 @@ export declare class ShardControlRouter implements BotControlHandler {
         coordinator?: ShardCoordinator;
         notificationGuildId?: string;
     });
+    cleanupOAuthConsumer(input: Parameters<BotControlHandler["cleanupOAuthConsumer"]>[0]): ReturnType<BotControlHandler["cleanupOAuthConsumer"]>;
     getGuildState(guildId: string): ReturnType<BotControlHandler["getGuildState"]>;
     canAccessDashboard(input: Parameters<BotControlHandler["canAccessDashboard"]>[0]): ReturnType<BotControlHandler["canAccessDashboard"]>;
     getGuildAccessPolicy(input: Parameters<BotControlHandler["getGuildAccessPolicy"]>[0]): ReturnType<BotControlHandler["getGuildAccessPolicy"]>;

package/dist/shard-router.js

@@ -12,6 +12,9 @@ export class ShardControlRouter {
     constructor(input) {
         this.input = input;
     }
+    cleanupOAuthConsumer(input) {
+        return this.#route({ kind: "oauth.consumer.cleanup", ...input });
+    }
     getGuildState(guildId) {
         return this.#route({ kind: "guild.state.get", guildId });
     }