@helyx/bot 0.4.36 → 0.4.38

package/dist/interactions.js

@@ -1,7 +1,9 @@
+import { lookup as lookupDns } from "node:dns/promises";
 import { HELYX_SERVICE_NAMES } from "@helyx/sdk";
 import { canUseCommand } from "@helyx/core";
-import { ActionRowBuilder, ButtonBuilder, ButtonStyle, ChannelSelectMenuBuilder, EmbedBuilder, Events, GuildMember, ApplicationIntegrationType, ChannelType, InteractionContextType, LabelBuilder, MessageFlags, MentionableSelectMenuBuilder, ModalBuilder, RoleSelectMenuBuilder, StringSelectMenuBuilder, SlashCommandBuilder, TextInputBuilder, TextInputStyle, UserSelectMenuBuilder, TextDisplayBuilder, PermissionFlagsBits, escapeMarkdown, } from "discord.js";
-import { collectCommandRegistrations, } from "./nexus-commands.js";
+import { commandRegistrationPolicy, contributionRegistrationPolicy, } from "./command-registration-policy.js";
+import { ActionRowBuilder, ButtonBuilder, ButtonStyle, ChannelSelectMenuBuilder, EmbedBuilder, Events, GuildMember, ApplicationIntegrationType, ChannelType, InteractionContextType, LabelBuilder, MessageFlags, MentionableSelectMenuBuilder, ModalBuilder, RoleSelectMenuBuilder, Routes, StringSelectMenuBuilder, SlashCommandBuilder, TextInputBuilder, TextInputStyle, UserSelectMenuBuilder, TextDisplayBuilder, PermissionFlagsBits, escapeMarkdown, } from "discord.js";
+import { collectCommandRegistrations, } from "./shared-commands.js";
 const buttonStyles = {
     primary: ButtonStyle.Primary,
     secondary: ButtonStyle.Secondary,
@@ -10,6 +12,8 @@ const buttonStyles = {
     link: ButtonStyle.Link,
 };
 export const GLOBAL_MODULE_UNAVAILABLE_MESSAGE = "This module is temporarily unavailable for all hosted servers.";
+export const AUTOCOMPLETE_RESPONSE_DEADLINE_MS = 2_000;
+export const DISCORD_DNS_REFRESH_INTERVAL_MS = 30_000;
 async function moduleIsGloballyAvailable(services, moduleId) {
     if (typeof services.has !== "function" ||
         !services.has(HELYX_SERVICE_NAMES.moduleAvailability))
@@ -21,8 +25,10 @@ async function moduleIsGloballyAvailable(services, moduleId) {
 }
 export function installInteractions(client, modules, registration, logger, services) {
     const commands = collectCommandRegistrations(modules);
-    const globalCommands = [...commands.values()].filter(({ contribution }) => contribution.registration === "global");
-    const guildCommands = [...commands.values()].filter(({ contribution }) => contribution.registration === "guild");
+    const modulesById = new Map(modules.map((module) => [module.manifest.id, module]));
+    const allowLegacyCustomerGlobals = (registration.globalCommandMode ?? "legacy") === "legacy";
+    const globalCommands = [...commands.values()].filter(({ moduleId, contribution }) => isApplicationGlobalPolicy(contributionRegistrationPolicy(requiredCommandModule(modulesById, moduleId), contribution, { allowLegacyCustomerGlobals })));
+    const guildCommands = [...commands.values()].filter(({ moduleId, contribution }) => contributionRegistrationPolicy(requiredCommandModule(modulesById, moduleId), contribution, { allowLegacyCustomerGlobals }) === "internal-guild");
     if (guildCommands.length > 0 && !registration.internalGuildId) {
         throw new Error("DISCORD_INTERNAL_GUILD_ID is required when guild commands are loaded");
     }
@@ -54,6 +60,8 @@ export function installInteractions(client, modules, registration, logger, servi
             rejectRegistration(error);
         });
         async function registerCommands() {
+            await warmDiscordRestConnection(readyClient, logger);
+            startDiscordDnsRefresh(logger);
             await registration.prepare?.(readyClient);
             if (registration.synchronise === false) {
                 logger.info({ event: "commands.registration_delegated" }, "Application command registration is owned by the supervisor");
@@ -61,7 +69,8 @@ export function installInteractions(client, modules, registration, logger, servi
             }
             const globalDefinitions = globalCommands.map(toCommandDefinition);
             await readyClient.application.commands.set(globalDefinitions);
-            if (registration.internalGuildId) {
+            if (registration.internalGuildId &&
+                registration.synchroniseInternalGuild !== false) {
                 const guildDefinitions = guildCommands.map(toCommandDefinition);
                 await readyClient.application.commands.set(guildDefinitions, registration.internalGuildId);
             }
@@ -69,6 +78,9 @@ export function installInteractions(client, modules, registration, logger, servi
                 event: "commands.registered",
                 globalCount: globalCommands.length,
                 guildCount: guildCommands.length,
+                internalGuildSynchronisation: registration.synchroniseInternalGuild === false
+                    ? "delegated"
+                    : "startup",
                 ...(registration.internalGuildId
                     ? { internalGuildId: registration.internalGuildId }
                     : {}),
@@ -81,25 +93,48 @@ export function installInteractions(client, modules, registration, logger, servi
     async function handleInteraction(interaction) {
         try {
             if (interaction.isAutocomplete()) {
-                const registered = commands.get(interaction.commandName);
-                const groupName = registered?.contribution.subcommandGroups?.length
-                    ? interaction.options.getSubcommandGroup(false)
-                    : null;
-                const subcommandName = hasNestedCommands(registered?.contribution)
-                    ? interaction.options.getSubcommand(false)
-                    : null;
-                const subcommand = resolveCommandSubcommand(registered?.contribution, subcommandName, groupName);
-                const owner = resolveCommandOwner(registered, subcommandName, groupName);
-                if (!registered ||
-                    !subcommand?.autocomplete ||
-                    !(await authorizeAutocomplete(interaction, owner?.moduleId ?? registered.moduleId, subcommand.permissionId ??
-                        [registered.contribution.name, groupName, subcommand.name]
-                            .filter(Boolean)
-                            .join("."), services, registration.selfAuthorizingGuildModuleIds?.has(owner?.moduleId ?? registered.moduleId) ?? false, subcommand.authorization === "resource-scoped"))) {
-                    await interaction.respond([]);
-                    return;
+                const response = createAutocompleteResponseController(interaction, logger);
+                try {
+                    const registered = commands.get(interaction.commandName);
+                    const groupName = registered?.contribution.subcommandGroups?.length
+                        ? interaction.options.getSubcommandGroup(false)
+                        : null;
+                    const subcommandName = hasNestedCommands(registered?.contribution)
+                        ? interaction.options.getSubcommand(false)
+                        : null;
+                    const subcommand = resolveCommandSubcommand(registered?.contribution, subcommandName, groupName);
+                    const owner = resolveCommandOwner(registered, subcommandName, groupName);
+                    const ownerModuleId = owner?.moduleId ?? registered?.moduleId;
+                    if (!registered ||
+                        !subcommand?.autocomplete ||
+                        !ownerModuleId ||
+                        !(await authorizeAutocomplete(interaction, ownerModuleId, subcommand.permissionId ??
+                            [registered.contribution.name, groupName, subcommand.name]
+                                .filter(Boolean)
+                                .join("."), services, registration.selfAuthorizingGuildModuleIds?.has(ownerModuleId) ??
+                            false, subcommand.authorization === "resource-scoped", isInstallationIndependentModule(modulesById, ownerModuleId), subcommand.authorization))) {
+                        await response.respond([]);
+                        return;
+                    }
+                    await subcommand.autocomplete(createAutocompleteContext(interaction, services, response.respond));
+                }
+                catch (error) {
+                    logger.error({
+                        event: "interaction.failed",
+                        ...interactionLogContext(interaction),
+                        error: safeError(error),
+                    }, "Module autocomplete interaction failed");
+                }
+                finally {
+                    await response.ensureResponded().catch((error) => {
+                        logger.warn({
+                            event: "interaction.autocomplete_response_failed",
+                            ...interactionLogContext(interaction),
+                            error: safeError(error),
+                        }, "Autocomplete response failed");
+                    });
                 }
-                await subcommand.autocomplete(createAutocompleteContext(interaction, services));
+                return;
             }
             else if (interaction.isChatInputCommand()) {
                 const registered = commands.get(interaction.commandName);
@@ -148,12 +183,21 @@ export function installInteractions(client, modules, registration, logger, servi
                     const permissionId = subcommand?.permissionId ?? command.permissionId ?? commandId;
                     const owner = resolveCommandOwner(registered, subcommandName, groupName);
                     const ownerModuleId = owner?.moduleId ?? moduleId;
+                    const installationIndependentCommand = isInstallationIndependentModule(modulesById, ownerModuleId);
                     const acknowledgement = subcommand?.acknowledgement ?? command.acknowledgement;
+                    const authorization = subcommand?.authorization ?? command.authorization;
+                    const rateLimit = subcommand?.rateLimit ?? command.rateLimit;
+                    if (installationIndependentCommand &&
+                        authorization === "public" &&
+                        !rateLimit) {
+                        await execute(createCommandContext(interaction, services));
+                        return;
+                    }
                     if (acknowledgement === "deferred-ephemeral") {
                         await interaction.deferReply({ flags: MessageFlags.Ephemeral });
                     }
-                    if (await authorizeCommand(interaction, ownerModuleId, permissionId, subcommand?.rateLimit ?? command.rateLimit, services, registration.selfAuthorizingGuildModuleIds?.has(ownerModuleId) ??
-                        false, subcommand?.authorization === "resource-scoped", owner?.moduleName)) {
+                    if (await authorizeCommand(interaction, ownerModuleId, permissionId, rateLimit, services, registration.selfAuthorizingGuildModuleIds?.has(ownerModuleId) ??
+                        false, subcommand?.authorization === "resource-scoped", owner?.moduleName, installationIndependentCommand, authorization)) {
                         const context = createCommandContext(interaction, services);
                         await execute(context);
                     }
@@ -162,6 +206,10 @@ export function installInteractions(client, modules, registration, logger, servi
             else if (interaction.isButton()) {
                 const button = buttons.get(interaction.customId) ??
                     resolveComponentPrefix(buttonPrefixes, interaction.customId);
+                if (!button) {
+                    await interaction.reply(staleComponentResponse());
+                    return;
+                }
                 const context = button
                     ? createContext(interaction, services)
                     : undefined;
@@ -176,15 +224,29 @@ export function installInteractions(client, modules, registration, logger, servi
                 }
                 if (button &&
                     context &&
-                    (await authorizeComponent(interaction, button.moduleId, services))) {
+                    button.contribution.authorization === "public") {
+                    await button.contribution.execute(context);
+                }
+                else if (button &&
+                    context &&
+                    (await authorizeComponent(interaction, button.moduleId, services, undefined, isInstallationIndependentModule(modulesById, button.moduleId)))) {
                     await button.contribution.execute(context);
                 }
             }
             else if (interaction.isModalSubmit()) {
                 const modal = modals.get(interaction.customId) ??
                     resolveComponentPrefix(modalPrefixes, interaction.customId);
+                if (!modal) {
+                    await interaction.reply(staleComponentResponse());
+                    return;
+                }
+                if (modal?.contribution.acknowledgement === "deferred-ephemeral" &&
+                    !interaction.deferred &&
+                    !interaction.replied) {
+                    await interaction.deferReply({ flags: MessageFlags.Ephemeral });
+                }
                 if (modal &&
-                    (await authorizeComponent(interaction, modal.moduleId, services))) {
+                    (await authorizeComponent(interaction, modal.moduleId, services, undefined, isInstallationIndependentModule(modulesById, modal.moduleId)))) {
                     await modal.contribution.execute(createModalContext(interaction, services));
                 }
             }
@@ -192,6 +254,10 @@ export function installInteractions(client, modules, registration, logger, servi
                 interaction.isChannelSelectMenu() ||
                 interaction.isRoleSelectMenu()) {
                 const select = selects.get(interaction.customId);
+                if (!select) {
+                    await interaction.reply(staleComponentResponse());
+                    return;
+                }
                 const context = select
                     ? createSelectContext(interaction, services)
                     : undefined;
@@ -199,9 +265,13 @@ export function installInteractions(client, modules, registration, logger, servi
                     select?.contribution.acknowledgement === "deferred-ephemeral") {
                     await context.deferReply?.(true);
                 }
+                if (select &&
+                    select.contribution.acknowledgement === "deferred-update") {
+                    await interaction.deferUpdate();
+                }
                 if (select &&
                     context &&
-                    (await authorizeComponent(interaction, select.moduleId, services))) {
+                    (await authorizeComponent(interaction, select.moduleId, services, undefined, isInstallationIndependentModule(modulesById, select.moduleId)))) {
                     await select.contribution.execute(context);
                 }
             }
@@ -217,18 +287,69 @@ export function installInteractions(client, modules, registration, logger, servi
     }
     return registrationReady;
 }
-export function buildApplicationCommandDefinitions(modules, internalGuildId) {
+export async function warmDiscordRestConnection(client, logger) {
+    const rest = client.rest;
+    if (!rest)
+        return;
+    try {
+        await rest.get(Routes.gateway());
+        logger.info({ event: "discord.rest_connection_warmed" }, "Discord REST connection warmed");
+    }
+    catch (error) {
+        logger.warn({
+            event: "discord.rest_connection_warm_failed",
+            error: safeError(error),
+        }, "Discord REST connection warm-up failed");
+    }
+}
+export function startDiscordDnsRefresh(logger, lookup = lookupDns, intervalMilliseconds = DISCORD_DNS_REFRESH_INTERVAL_MS) {
+    let unavailable = false;
+    const refresh = () => {
+        void lookup("discord.com").then(() => {
+            if (unavailable) {
+                logger.info({ event: "discord.dns_refresh_recovered" }, "Discord DNS refresh recovered");
+            }
+            unavailable = false;
+        }, (error) => {
+            if (!unavailable) {
+                logger.warn({
+                    event: "discord.dns_refresh_failed",
+                    error: safeError(error),
+                }, "Discord DNS refresh failed");
+            }
+            unavailable = true;
+        });
+    };
+    const timer = setInterval(refresh, intervalMilliseconds);
+    timer.unref();
+    return timer;
+}
+export function buildApplicationCommandDefinitions(modules, internalGuildId, globalCommandMode = "legacy") {
     const commands = collectCommandRegistrations(modules);
+    const modulesById = new Map(modules.map((module) => [module.manifest.id, module]));
+    const allowLegacyCustomerGlobals = globalCommandMode === "legacy";
     const global = [...commands.values()]
-        .filter(({ contribution }) => contribution.registration === "global")
+        .filter(({ moduleId, contribution }) => isApplicationGlobalPolicy(contributionRegistrationPolicy(requiredCommandModule(modulesById, moduleId), contribution, { allowLegacyCustomerGlobals })))
         .map(toCommandDefinition);
     const guild = [...commands.values()]
-        .filter(({ contribution }) => contribution.registration === "guild")
+        .filter(({ moduleId, contribution }) => contributionRegistrationPolicy(requiredCommandModule(modulesById, moduleId), contribution, { allowLegacyCustomerGlobals }) === "internal-guild")
         .map(toCommandDefinition);
     if (guild.length > 0 && !internalGuildId)
         throw new Error("DISCORD_INTERNAL_GUILD_ID is required when guild commands are loaded");
     return { global, guild };
 }
+function isApplicationGlobalPolicy(policy) {
+    return policy === "platform-global" || policy === "deployment";
+}
+function requiredCommandModule(modulesById, moduleId) {
+    const module = modulesById.get(moduleId);
+    if (!module)
+        throw new Error(`Command owner is not loaded: ${moduleId}`);
+    return module;
+}
+function isInstallationIndependentModule(modulesById, moduleId) {
+    return isApplicationGlobalPolicy(commandRegistrationPolicy(requiredCommandModule(modulesById, moduleId)));
+}
 export function resolveCommandExecutor(command, subcommandName, groupName = null) {
     if (hasNestedCommands(command)) {
         if (!subcommandName)
@@ -448,6 +569,12 @@ function resolveComponentPrefix(items, customId) {
     }
     return items.find(({ contribution }) => customId.startsWith(contribution.customIdPrefix ?? ""));
 }
+function staleComponentResponse() {
+    return {
+        content: "This control is no longer available. Open the latest Helyx message and try again.",
+        flags: MessageFlags.Ephemeral,
+    };
+}
 function createContext(interaction, services) {
     return {
         interactionId: interaction.id,
@@ -483,7 +610,13 @@ function createContext(interaction, services) {
         reply: (response) => replyToInteraction(interaction, response),
         ...(interaction.isMessageComponent()
             ? {
-                updateResponse: async (response) => interaction.update(toUpdateOptions(response)).then(() => undefined),
+                updateResponse: async (response) => {
+                    if (interaction.deferred || interaction.replied) {
+                        await interaction.editReply(toUpdateOptions(response));
+                        return;
+                    }
+                    await interaction.update(toUpdateOptions(response));
+                },
                 editSourceMessage: async (response) => interaction.webhook
                     .editMessage(interaction.message.id, toUpdateOptions(response))
                     .then(() => undefined),
@@ -532,7 +665,7 @@ function createCommandContext(interaction, services) {
         },
     };
 }
-function createAutocompleteContext(interaction, services) {
+function createAutocompleteContext(interaction, services, respond) {
     const focused = interaction.options.getFocused(true);
     const actor = permissionActor(interaction);
     return {
@@ -546,27 +679,60 @@ function createAutocompleteContext(interaction, services) {
         focusedOptionName: focused.name,
         focusedValue: String(focused.value),
         services,
-        respond: async (choices) => {
-            if (choices.length > 25)
-                throw new Error("Autocomplete supports at most 25 choices");
-            const values = new Set();
-            const normalized = choices.map(({ name, value }) => {
-                const choiceName = name.trim().normalize("NFC");
-                const choiceValue = value.trim().normalize("NFC");
-                if (choiceName.length < 1 ||
-                    choiceName.length > 100 ||
-                    choiceValue.length < 1 ||
-                    choiceValue.length > 100)
-                    throw new Error("Autocomplete names and values must be between 1 and 100 characters");
-                if (values.has(choiceValue))
-                    throw new Error("Autocomplete choice values must be unique");
-                values.add(choiceValue);
-                return { name: choiceName, value: choiceValue };
-            });
-            await interaction.respond(normalized);
+        respond,
+    };
+}
+export function createAutocompleteResponseController(interaction, logger) {
+    let attempted = false;
+    const respond = async (choices) => {
+        const normalized = normalizeAutocompleteChoices(choices);
+        if (attempted)
+            return;
+        attempted = true;
+        clearTimeout(deadline);
+        await interaction.respond(normalized);
+    };
+    const deadline = setTimeout(() => {
+        logger.warn({
+            event: "interaction.autocomplete_deadline",
+            ...interactionLogContext(interaction),
+        }, "Autocomplete reached its response deadline");
+        void respond([]).catch((error) => {
+            logger.warn({
+                event: "interaction.autocomplete_response_failed",
+                ...interactionLogContext(interaction),
+                error: safeError(error),
+            }, "Autocomplete fallback response failed");
+        });
+    }, AUTOCOMPLETE_RESPONSE_DEADLINE_MS);
+    deadline.unref();
+    return {
+        respond,
+        async ensureResponded() {
+            clearTimeout(deadline);
+            if (!attempted)
+                await respond([]);
         },
     };
 }
+function normalizeAutocompleteChoices(choices) {
+    if (choices.length > 25)
+        throw new Error("Autocomplete supports at most 25 choices");
+    const values = new Set();
+    return choices.map(({ name, value }) => {
+        const choiceName = name.trim().normalize("NFC");
+        const choiceValue = value.trim().normalize("NFC");
+        if (choiceName.length < 1 ||
+            choiceName.length > 100 ||
+            choiceValue.length < 1 ||
+            choiceValue.length > 100)
+            throw new Error("Autocomplete names and values must be between 1 and 100 characters");
+        if (values.has(choiceValue))
+            throw new Error("Autocomplete choice values must be unique");
+        values.add(choiceValue);
+        return { name: choiceName, value: choiceValue };
+    });
+}
 function createModalContext(interaction, services) {
     const updateResponse = interaction.isFromMessage()
         ? async (response) => interaction.update(toUpdateOptions(response)).then(() => undefined)
@@ -694,7 +860,9 @@ export async function addChannelMessageReaction(client, channelId, messageId, em
     const message = await channel.messages.fetch(messageId);
     await message.react(emojiIdentifier);
 }
-async function authorizeComponent(interaction, moduleId, services, requiredModuleName) {
+async function authorizeComponent(interaction, moduleId, services, requiredModuleName, installationIndependent = false) {
+    if (installationIndependent)
+        return true;
     if (!(await moduleIsGloballyAvailable(services, moduleId))) {
         await replyEphemeralText(interaction, GLOBAL_MODULE_UNAVAILABLE_MESSAGE);
         return false;
@@ -717,17 +885,39 @@ async function replyEphemeralText(interaction, content) {
     }
     await interaction.reply({ content, flags: MessageFlags.Ephemeral });
 }
-export async function authorizeCommand(interaction, moduleId, commandId, rateLimit, services, selfAuthorizingGuildCommand, resourceScopedCommand = false, requiredModuleName) {
-    if (!interaction.guildId)
-        return true;
-    if (!selfAuthorizingGuildCommand) {
-        if (!(await authorizeComponent(interaction, moduleId, services, requiredModuleName)))
+export async function authorizeCommand(interaction, moduleId, commandId, rateLimit, services, selfAuthorizingGuildCommand, resourceScopedCommand = false, requiredModuleName, installationIndependentCommand = false, authorization) {
+    const bypassPlatformAuthorization = authorization === "public" || authorization === "self-authorized";
+    if (!installationIndependentCommand && !selfAuthorizingGuildCommand) {
+        const installations = interaction.guildId
+            ? services.get(HELYX_SERVICE_NAMES.installations)
+            : undefined;
+        const [globallyAvailable, moduleEnabled] = await Promise.all([
+            moduleIsGloballyAvailable(services, moduleId),
+            installations && !selfAuthorizingGuildCommand
+                ? installations.isModuleEnabled(interaction.guildId, moduleId)
+                : Promise.resolve(true),
+        ]);
+        if (!globallyAvailable) {
+            await replyEphemeralText(interaction, GLOBAL_MODULE_UNAVAILABLE_MESSAGE);
+            return false;
+        }
+        if (!moduleEnabled) {
+            await replyEphemeralText(interaction, requiredModuleName
+                ? `This command needs ${requiredModuleName}. Ask a server administrator to enable it in the Helyx dashboard.`
+                : "This module is disabled in this server. Ask a server administrator to enable it with `/helyx` or in the Helyx dashboard.");
             return false;
+        }
+    }
+    if (!bypassPlatformAuthorization &&
+        interaction.guildId &&
+        !selfAuthorizingGuildCommand) {
         if (!resourceScopedCommand) {
             const permissions = services.get(HELYX_SERVICE_NAMES.permissions);
-            const policy = await permissions.getEffectivePolicy(interaction.guildId, moduleId, commandId);
+            const [policy, guildAccess] = await Promise.all([
+                permissions.getEffectivePolicy(interaction.guildId, moduleId, commandId),
+                permissions.getGuildAccessPolicy?.(interaction.guildId),
+            ]);
             const actor = permissionActor(interaction);
-            const guildAccess = await permissions.getGuildAccessPolicy?.(interaction.guildId);
             if (!canUseCommand(actor, policy, guildAccess)) {
                 await replyEphemeralText(interaction, "You do not have permission to use this command.");
                 return false;
@@ -738,7 +928,9 @@ export async function authorizeCommand(interaction, moduleId, commandId, rateLim
         const limits = services.get(HELYX_SERVICE_NAMES.rateLimits);
         const result = await limits.consume({
             scope: rateLimit.scope,
-            subjectId: rateLimit.scope === "guild" ? interaction.guildId : interaction.user.id,
+            subjectId: rateLimit.scope === "guild"
+                ? (interaction.guildId ?? interaction.user.id)
+                : interaction.user.id,
             action: `${moduleId}:${commandId}`,
             limit: rateLimit.limit,
             windowSeconds: rateLimit.windowSeconds,
@@ -750,19 +942,42 @@ export async function authorizeCommand(interaction, moduleId, commandId, rateLim
     }
     return true;
 }
-async function authorizeAutocomplete(interaction, moduleId, commandId, services, selfAuthorizingGuildCommand, resourceScopedCommand) {
-    if (!(await moduleIsGloballyAvailable(services, moduleId)))
-        return false;
-    if (!interaction.guildId || selfAuthorizingGuildCommand)
+async function authorizeAutocomplete(interaction, moduleId, commandId, services, selfAuthorizingGuildCommand, resourceScopedCommand, installationIndependentCommand = false, authorization) {
+    const bypassPlatformAuthorization = authorization === "public" || authorization === "self-authorized";
+    if (!installationIndependentCommand && !selfAuthorizingGuildCommand) {
+        const installations = interaction.guildId
+            ? services.get(HELYX_SERVICE_NAMES.installations)
+            : undefined;
+        const [globallyAvailable, moduleEnabled] = await Promise.all([
+            moduleIsGloballyAvailable(services, moduleId),
+            installations && !selfAuthorizingGuildCommand
+                ? installations.isModuleEnabled(interaction.guildId, moduleId)
+                : Promise.resolve(true),
+        ]);
+        if (!globallyAvailable || !moduleEnabled)
+            return false;
+    }
+    if (bypassPlatformAuthorization ||
+        !interaction.guildId ||
+        selfAuthorizingGuildCommand)
         return true;
-    const installations = services.get(HELYX_SERVICE_NAMES.installations);
-    if (!(await installations.isModuleEnabled(interaction.guildId, moduleId)))
-        return false;
+    if (installationIndependentCommand) {
+        if (resourceScopedCommand)
+            return true;
+        const permissions = services.get(HELYX_SERVICE_NAMES.permissions);
+        const [policy, guildAccess] = await Promise.all([
+            permissions.getEffectivePolicy(interaction.guildId, moduleId, commandId),
+            permissions.getGuildAccessPolicy?.(interaction.guildId),
+        ]);
+        return canUseCommand(permissionActor(interaction), policy, guildAccess);
+    }
     if (resourceScopedCommand)
         return true;
     const permissions = services.get(HELYX_SERVICE_NAMES.permissions);
-    const policy = await permissions.getEffectivePolicy(interaction.guildId, moduleId, commandId);
-    const guildAccess = await permissions.getGuildAccessPolicy?.(interaction.guildId);
+    const [policy, guildAccess] = await Promise.all([
+        permissions.getEffectivePolicy(interaction.guildId, moduleId, commandId),
+        permissions.getGuildAccessPolicy?.(interaction.guildId),
+    ]);
     return canUseCommand(permissionActor(interaction), policy, guildAccess);
 }
 function permissionActor(interaction) {
@@ -995,7 +1210,7 @@ function toModalLabel(field) {
             input.setMaxLength(field.maxLength);
         if (field.placeholder !== undefined)
             input.setPlaceholder(field.placeholder);
-        if (field.value !== undefined)
+        if (field.value !== undefined && field.value.length > 0)
             input.setValue(field.value);
         label.setTextInputComponent(input);
     }