@helyx/bot 0.4.2 → 0.4.5

package/dist/events.js

@@ -1,23 +1,77 @@
 import { HELYX_SERVICE_NAMES } from "@helyx/sdk";
-import { Events, } from "discord.js";
+import { ChannelType, Events, PermissionFlagsBits, RESTJSONErrorCodes, } from "discord.js";
 import { toReplyOptions } from "./interactions.js";
 export function installModuleEvents(client, modules, logger, services) {
     const reactionContributions = modules.flatMap((module) => (module.events?.messageReactionAdd ?? []).map((contribution) => ({
         moduleId: module.manifest.id,
         contribution,
     })));
+    const reactionRemoveContributions = modules.flatMap((module) => (module.events?.messageReactionRemove ?? []).map((contribution) => ({
+        moduleId: module.manifest.id,
+        contribution,
+    })));
+    const messageDeleteContributions = modules.flatMap((module) => (module.events?.messageDelete ?? []).map((contribution) => ({
+        moduleId: module.manifest.id,
+        contribution,
+    })));
     const memberAddContributions = modules.flatMap((module) => (module.events?.guildMemberAdd ?? []).map((contribution) => ({
         moduleId: module.manifest.id,
         contribution,
     })));
-    if (reactionContributions.length === 0 && memberAddContributions.length === 0)
+    const guildRoleDeleteContributions = modules.flatMap((module) => (module.events?.guildRoleDelete ?? []).map((contribution) => ({
+        moduleId: module.manifest.id,
+        contribution,
+    })));
+    const guildRoleUpdateContributions = modules.flatMap((module) => (module.events?.guildRoleUpdate ?? []).map((contribution) => ({
+        moduleId: module.manifest.id,
+        contribution,
+    })));
+    const channelDeleteContributions = modules.flatMap((module) => (module.events?.channelDelete ?? []).map((contribution) => ({
+        moduleId: module.manifest.id,
+        contribution,
+    })));
+    const channelUpdateContributions = modules.flatMap((module) => (module.events?.channelUpdate ?? []).map((contribution) => ({
+        moduleId: module.manifest.id,
+        contribution,
+    })));
+    const guildEmojiDeleteContributions = modules.flatMap((module) => (module.events?.guildEmojiDelete ?? []).map((contribution) => ({
+        moduleId: module.manifest.id,
+        contribution,
+    })));
+    const guildEmojiUpdateContributions = modules.flatMap((module) => (module.events?.guildEmojiUpdate ?? []).map((contribution) => ({
+        moduleId: module.manifest.id,
+        contribution,
+    })));
+    if (reactionContributions.length === 0 &&
+        reactionRemoveContributions.length === 0 &&
+        messageDeleteContributions.length === 0 &&
+        memberAddContributions.length === 0 &&
+        guildRoleDeleteContributions.length === 0 &&
+        guildRoleUpdateContributions.length === 0 &&
+        channelDeleteContributions.length === 0 &&
+        channelUpdateContributions.length === 0 &&
+        guildEmojiDeleteContributions.length === 0 &&
+        guildEmojiUpdateContributions.length === 0)
         return { stop: () => Promise.resolve(), queueDepth: () => 0 };
     const queue = new BoundedGuildEventQueue(logger);
     if (reactionContributions.length > 0) {
-        client.on(Events.MessageReactionAdd, (reaction, user) => {
+        client.on(Events.MessageReactionAdd, (reaction, user, details) => {
             const guildId = reaction.message.guildId;
             if (guildId)
-                queue.enqueue(guildId, () => handleReaction(reaction, user));
+                queue.enqueue(guildId, () => handleReaction(reaction, user, details.burst));
+        });
+    }
+    if (reactionRemoveContributions.length > 0) {
+        client.on(Events.MessageReactionRemove, (reaction, user, details) => {
+            const guildId = reaction.message.guildId;
+            if (guildId)
+                queue.enqueue(guildId, () => handleReactionRemove(reaction, user, details.burst));
+        });
+    }
+    if (messageDeleteContributions.length > 0) {
+        client.on(Events.MessageDelete, (message) => {
+            if (message.guildId)
+                queue.enqueue(message.guildId, () => handleMessageDelete(message));
         });
     }
     if (memberAddContributions.length > 0) {
@@ -25,7 +79,65 @@ export function installModuleEvents(client, modules, logger, services) {
             queue.enqueue(member.guild.id, () => handleMemberAdd(member));
         });
     }
-    async function handleReaction(receivedReaction, receivedUser) {
+    if (guildRoleDeleteContributions.length > 0) {
+        client.on(Events.GuildRoleDelete, (role) => {
+            queue.enqueue(role.guild.id, () => handleResourceLifecycle(guildRoleDeleteContributions, role.guild.id, "roleId", role.id, "guild_role_delete"));
+        });
+    }
+    if (guildRoleUpdateContributions.length > 0) {
+        client.on(Events.GuildRoleUpdate, (_oldRole, role) => {
+            queue.enqueue(role.guild.id, () => handleResourceLifecycle(guildRoleUpdateContributions, role.guild.id, "roleId", role.id, "guild_role_update"));
+        });
+    }
+    if (channelDeleteContributions.length > 0) {
+        client.on(Events.ChannelDelete, (channel) => {
+            if (channel.isDMBased())
+                return;
+            queue.enqueue(channel.guild.id, () => handleResourceLifecycle(channelDeleteContributions, channel.guild.id, "channelId", channel.id, "channel_delete"));
+        });
+    }
+    if (channelUpdateContributions.length > 0) {
+        client.on(Events.ChannelUpdate, (_oldChannel, channel) => {
+            if (channel.isDMBased())
+                return;
+            queue.enqueue(channel.guild.id, () => handleResourceLifecycle(channelUpdateContributions, channel.guild.id, "channelId", channel.id, "channel_update"));
+        });
+    }
+    if (guildEmojiDeleteContributions.length > 0) {
+        client.on(Events.GuildEmojiDelete, (emoji) => {
+            queue.enqueue(emoji.guild.id, () => handleResourceLifecycle(guildEmojiDeleteContributions, emoji.guild.id, "emojiId", emoji.id, "guild_emoji_delete"));
+        });
+    }
+    if (guildEmojiUpdateContributions.length > 0) {
+        client.on(Events.GuildEmojiUpdate, (_oldEmoji, emoji) => {
+            queue.enqueue(emoji.guild.id, () => handleResourceLifecycle(guildEmojiUpdateContributions, emoji.guild.id, "emojiId", emoji.id, "guild_emoji_update"));
+        });
+    }
+    async function handleResourceLifecycle(contributions, serverId, identifier, resourceId, eventName) {
+        const installations = services.get(HELYX_SERVICE_NAMES.installations);
+        for (const { moduleId, contribution } of contributions) {
+            try {
+                if (!(await installations.isModuleEnabled(serverId, moduleId))) {
+                    continue;
+                }
+                await contribution.execute({
+                    serverId,
+                    [identifier]: resourceId,
+                    services,
+                });
+            }
+            catch (error) {
+                logger.warn({
+                    event: `module.${eventName}_failed`,
+                    moduleId,
+                    error: safeError(error),
+                    guildId: serverId,
+                    [identifier]: resourceId,
+                }, "Module resource lifecycle event failed");
+            }
+        }
+    }
+    async function handleReaction(receivedReaction, receivedUser, burst) {
         try {
             const user = receivedUser.partial
                 ? await receivedUser.fetch()
@@ -55,6 +167,7 @@ export function installModuleEvents(client, modules, logger, services) {
                         userId: receivedUser.id,
                         userRoleIds,
                         emojiKey: reactionEmojiKey(reaction),
+                        reactionType: burst ? "burst" : "normal",
                         services,
                         removeAddedReaction: () => reaction.users.remove(user.id).then(() => undefined),
                         removeUserReaction: async (emojiIdentifier) => {
@@ -112,6 +225,74 @@ export function installModuleEvents(client, modules, logger, services) {
             }
         }
     }
+    async function handleReactionRemove(receivedReaction, receivedUser, burst) {
+        try {
+            if (receivedUser.bot)
+                return;
+            const message = receivedReaction.message;
+            if (!message.guildId || !message.channelId)
+                return;
+            const installations = services.get(HELYX_SERVICE_NAMES.installations);
+            for (const { moduleId, contribution } of reactionRemoveContributions) {
+                if (!(await installations.isModuleEnabled(message.guildId, moduleId))) {
+                    continue;
+                }
+                try {
+                    await contribution.execute({
+                        serverId: message.guildId,
+                        channelId: message.channelId,
+                        messageId: message.id,
+                        userId: receivedUser.id,
+                        emojiKey: reactionEmojiKey(receivedReaction),
+                        reactionType: burst ? "burst" : "normal",
+                        services,
+                    });
+                }
+                catch (error) {
+                    logger.warn({
+                        event: "module.reaction_remove_failed",
+                        moduleId,
+                        error: safeError(error),
+                        userId: receivedUser.id,
+                    }, "Module reaction-remove event failed");
+                }
+            }
+        }
+        catch (error) {
+            logger.warn({
+                event: "module.reaction_remove_failed",
+                error: safeError(error),
+                userId: receivedUser.id,
+            }, "Module reaction-remove event failed");
+        }
+    }
+    async function handleMessageDelete(message) {
+        if (!message.guildId || !message.channelId)
+            return;
+        const installations = services.get(HELYX_SERVICE_NAMES.installations);
+        for (const { moduleId, contribution } of messageDeleteContributions) {
+            try {
+                if (!(await installations.isModuleEnabled(message.guildId, moduleId))) {
+                    continue;
+                }
+                await contribution.execute({
+                    serverId: message.guildId,
+                    channelId: message.channelId,
+                    messageId: message.id,
+                    services,
+                });
+            }
+            catch (error) {
+                logger.warn({
+                    event: "module.message_delete_failed",
+                    moduleId,
+                    error: safeError(error),
+                    messageId: message.id,
+                    guildId: message.guildId,
+                }, "Module message-delete event failed");
+            }
+        }
+    }
     return { stop: () => queue.stop(), queueDepth: () => queue.queueDepth() };
 }
 class BoundedGuildEventQueue {
@@ -201,6 +382,377 @@ export function reactionCacheKey(emojiIdentifier) {
     const custom = /^(?:[A-Za-z0-9_]{2,32}):(\d{17,20})$/u.exec(emojiIdentifier);
     return custom?.[1] ?? emojiIdentifier;
 }
+const discordSnowflake = /^\d{17,20}$/u;
+const moduleIdentifier = /^helyx\.[a-z0-9][a-z0-9-]*$/u;
+const customEmojiIdentifier = /^(?:<a?:([A-Za-z0-9_]{2,32}):(\d{17,20})>|([A-Za-z0-9_]{2,32}):(\d{17,20}))$/u;
+const dangerousRolePermissionNames = new Set([
+    "ADMINISTRATOR",
+    "BAN_MEMBERS",
+    "DEAFEN_MEMBERS",
+    "KICK_MEMBERS",
+    "MANAGE_CHANNELS",
+    "MANAGE_EVENTS",
+    "MANAGE_GUILD",
+    "MANAGE_GUILD_EXPRESSIONS",
+    "MANAGE_MESSAGES",
+    "MANAGE_NICKNAMES",
+    "MANAGE_ROLES",
+    "MANAGE_THREADS",
+    "MANAGE_WEBHOOKS",
+    "MENTION_EVERYONE",
+    "MODERATE_MEMBERS",
+    "MOVE_MEMBERS",
+    "MUTE_MEMBERS",
+    "VIEW_AUDIT_LOG",
+]);
+export class DiscordMemberRoleService {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async getCurrentRoleIds(input) {
+        const { member } = await this.fetchGuildAndMember(input);
+        return [...member.roles.cache.keys()];
+    }
+    async addApprovedRole(input) {
+        validateMutationMetadata(input);
+        const { guild, member } = await this.fetchGuildAndMember(input);
+        const role = await fetchSafeRole(guild, input.roleId);
+        if (member.roles.cache.has(role.id))
+            return { changed: false };
+        await member.roles.add(role, discordAuditReason(input));
+        return { changed: true };
+    }
+    async removeApprovedRole(input) {
+        validateMutationMetadata(input);
+        const { guild, member } = await this.fetchGuildAndMember(input);
+        const role = await fetchSafeRole(guild, input.roleId);
+        if (!member.roles.cache.has(role.id))
+            return { changed: false };
+        await member.roles.remove(role, discordAuditReason(input));
+        return { changed: true };
+    }
+    async reconcileApprovedRoles(input) {
+        validateMutationMetadata({
+            ...input,
+            roleId: input.allowedRoleIds[0] ?? "",
+        });
+        validateBoundedRoleSet(input.allowedRoleIds, "allowed");
+        validateBoundedRoleSet(input.desiredRoleIds, "desired");
+        const allowed = new Set(input.allowedRoleIds);
+        if (input.desiredRoleIds.some((roleId) => !allowed.has(roleId))) {
+            throw new Error("Desired roles must be within the approved role set");
+        }
+        const { guild, member } = await this.fetchGuildAndMember(input);
+        const current = member.roles.cache;
+        const desired = new Set(input.desiredRoleIds);
+        const approvedRoles = new Map(await Promise.all(input.allowedRoleIds.map(async (roleId) => [roleId, await fetchSafeRole(guild, roleId)])));
+        const addedIds = input.desiredRoleIds.filter((roleId) => !current.has(roleId));
+        const removedIds = input.allowedRoleIds.filter((roleId) => current.has(roleId) && !desired.has(roleId));
+        const addedRoles = addedIds.map((roleId) => approvedRoles.get(roleId));
+        const removedRoles = removedIds.map((roleId) => approvedRoles.get(roleId));
+        const reason = discordAuditReason(input);
+        if (removedRoles.length > 0)
+            await member.roles.remove(removedRoles, reason);
+        if (addedRoles.length > 0)
+            await member.roles.add(addedRoles, reason);
+        return { added: addedIds, removed: removedIds };
+    }
+    async fetchGuildAndMember(input) {
+        validateSnowflake(input.guildId, "guild");
+        validateSnowflake(input.memberUserId, "member");
+        const guild = await this.client.guilds.fetch(input.guildId);
+        if (guild.id !== input.guildId)
+            throw new Error("Discord guild validation failed");
+        const member = await guild.members.fetch(input.memberUserId);
+        if (member.id !== input.memberUserId || member.guild.id !== guild.id)
+            throw new Error("Discord member validation failed");
+        return { guild, member };
+    }
+}
+export class DiscordResourceInspection {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async resolveMemberSnapshots(input) {
+        const guild = await this.#resolveMemberGuild(input);
+        return Promise.all(input.userIds.map(async (userId) => {
+            const member = await fetchExactMember(guild, userId, "member").catch((error) => {
+                if (isUnknownMember(error))
+                    return null;
+                throw error;
+            });
+            return {
+                userId,
+                exists: member !== null,
+                isBot: member?.user.bot ?? false,
+                roleIds: member
+                    ? [...member.roles.cache.keys()].sort((left, right) => left.localeCompare(right, "en"))
+                    : [],
+                joinedAt: member?.joinedAt ?? null,
+            };
+        }));
+    }
+    async resolveMembers(input) {
+        const guild = await this.#resolveMemberGuild(input);
+        return Promise.all(input.userIds.map(async (userId) => {
+            const member = await fetchExactMember(guild, userId, "member").catch((error) => {
+                if (isUnknownMember(error))
+                    return null;
+                throw error;
+            });
+            return {
+                userId,
+                displayName: member?.displayName ?? null,
+            };
+        }));
+    }
+    async #resolveMemberGuild(input) {
+        validateSnowflake(input.guildId, "guild");
+        if (input.userIds.length > 50 ||
+            new Set(input.userIds).size !== input.userIds.length)
+            throw new Error("Discord member IDs must be unique and bounded");
+        for (const userId of input.userIds)
+            validateSnowflake(userId, "member");
+        const guild = await this.client.guilds.fetch(input.guildId);
+        if (guild.id !== input.guildId)
+            throw new Error("Discord guild validation failed");
+        return guild;
+    }
+    async inspectRole(input) {
+        validateSnowflake(input.guildId, "guild");
+        validateSnowflake(input.roleId, "role");
+        const guild = await this.client.guilds.fetch(input.guildId);
+        if (guild.id !== input.guildId)
+            throw new Error("Discord guild validation failed");
+        const role = await guild.roles.fetch(input.roleId);
+        if (!role)
+            return missingRoleInspection(input, "missing");
+        if (role.guild.id !== guild.id)
+            return missingRoleInspection(input, "guild-mismatch");
+        const me = guild.members.me ?? (await guild.members.fetchMe());
+        const actor = input.actorUserId
+            ? await fetchExactMember(guild, input.actorUserId, "actor")
+            : undefined;
+        const permissions = role.permissions
+            .toArray()
+            .map(normalizePermissionName)
+            .sort();
+        const dangerous = permissions.filter((permission) => dangerousRolePermissionNames.has(permission));
+        const botHierarchy = roleHierarchy(role, guild, me);
+        const actorAssignable = actor === undefined
+            ? botHierarchy === "assignable"
+            : botHierarchy === "assignable" &&
+                (guild.ownerId === actor.id ||
+                    role.comparePositionTo(actor.roles.highest) < 0);
+        const hierarchy = botHierarchy === "assignable" && !actorAssignable
+            ? "above-actor"
+            : botHierarchy;
+        return {
+            guildId: guild.id,
+            roleId: role.id,
+            exists: true,
+            guildMatches: true,
+            name: role.name,
+            managed: role.managed,
+            everyone: role.id === guild.id,
+            assignable: hierarchy === "assignable" && actorAssignable && dangerous.length === 0,
+            actorAssignable,
+            hierarchy,
+            permissionNames: permissions,
+            dangerousPermissionNames: dangerous,
+            helyxHighestRoleId: me.roles.highest.id,
+        };
+    }
+    async inspectEmoji(input) {
+        validateSnowflake(input.guildId, "guild");
+        if (input.emojiIdentifier.length === 0 ||
+            input.emojiIdentifier.length > 128 ||
+            /[\r\n]/u.test(input.emojiIdentifier))
+            throw new Error("Invalid bounded Discord emoji identifier");
+        const guild = await this.client.guilds.fetch(input.guildId);
+        if (guild.id !== input.guildId)
+            throw new Error("Discord guild validation failed");
+        const custom = customEmojiIdentifier.exec(input.emojiIdentifier);
+        if (!custom) {
+            const normalized = input.emojiIdentifier.normalize("NFKC").trim();
+            const valid = isSingleUnicodeEmoji(normalized);
+            return {
+                guildId: guild.id,
+                emojiIdentifier: input.emojiIdentifier,
+                exists: valid,
+                guildMatches: true,
+                usable: valid,
+                kind: "unicode",
+                ...(valid
+                    ? { canonicalEmojiKey: `unicode:${normalized}`, name: normalized }
+                    : {}),
+            };
+        }
+        const emojiId = custom[2] ?? custom[4];
+        const emoji = await guild.emojis.fetch(emojiId).catch(() => null);
+        if (!emoji)
+            return {
+                guildId: guild.id,
+                emojiIdentifier: input.emojiIdentifier,
+                exists: false,
+                guildMatches: false,
+                usable: false,
+                kind: "custom",
+                emojiId,
+            };
+        const guildMatches = emoji.guild.id === guild.id;
+        return {
+            guildId: guild.id,
+            emojiIdentifier: input.emojiIdentifier,
+            exists: true,
+            guildMatches,
+            usable: guildMatches && emoji.available === true,
+            kind: "custom",
+            canonicalEmojiKey: `custom:${emoji.id}`,
+            emojiId: emoji.id,
+            name: emoji.name ?? custom[1] ?? custom[3] ?? "emoji",
+        };
+    }
+    async inspectChannel(input) {
+        validateSnowflake(input.guildId, "guild");
+        validateSnowflake(input.channelId, "channel");
+        const guild = await this.client.guilds.fetch(input.guildId);
+        if (guild.id !== input.guildId)
+            throw new Error("Discord guild validation failed");
+        const channel = await guild.channels.fetch(input.channelId);
+        if (!channel)
+            return {
+                guildId: guild.id,
+                channelId: input.channelId,
+                exists: false,
+                guildMatches: false,
+                type: "missing",
+                effectivePermissionNames: [],
+                viewable: false,
+                sendMessages: false,
+                addReactions: false,
+                readMessageHistory: false,
+            };
+        const guildMatches = channel.guild.id === guild.id;
+        const me = guild.members.me ?? (await guild.members.fetchMe());
+        const effective = channel.permissionsFor(me);
+        const permissionNames = effective?.toArray().map(normalizePermissionName).sort() ?? [];
+        return {
+            guildId: guild.id,
+            channelId: channel.id,
+            exists: true,
+            guildMatches,
+            name: channel.name,
+            type: channel.type === ChannelType.GuildText
+                ? "guild_text"
+                : channel.type === ChannelType.GuildAnnouncement
+                    ? "guild_announcement"
+                    : "other",
+            effectivePermissionNames: permissionNames,
+            viewable: guildMatches &&
+                (effective?.has(PermissionFlagsBits.ViewChannel) ?? false),
+            sendMessages: guildMatches &&
+                (effective?.has(PermissionFlagsBits.SendMessages) ?? false),
+            addReactions: guildMatches &&
+                (effective?.has(PermissionFlagsBits.AddReactions) ?? false),
+            readMessageHistory: guildMatches &&
+                (effective?.has(PermissionFlagsBits.ReadMessageHistory) ?? false),
+        };
+    }
+}
+async function fetchSafeRole(guild, roleId) {
+    validateSnowflake(roleId, "role");
+    const role = await guild.roles.fetch(roleId);
+    if (!role || role.guild.id !== guild.id)
+        throw new Error("Approved Discord role was not found in this guild");
+    const me = guild.members.me ?? (await guild.members.fetchMe());
+    const hierarchy = roleHierarchy(role, guild, me);
+    if (hierarchy !== "assignable")
+        throw new Error("Approved Discord role cannot be managed by Helyx");
+    if (role.permissions
+        .toArray()
+        .map(normalizePermissionName)
+        .some((permission) => dangerousRolePermissionNames.has(permission)))
+        throw new Error("Approved Discord role has dangerous permissions");
+    return role;
+}
+function roleHierarchy(role, guild, me) {
+    if (role.id === guild.id)
+        return "everyone";
+    if (role.managed)
+        return "managed";
+    if (!me.permissions.has(PermissionFlagsBits.ManageRoles))
+        return "missing-manage-roles";
+    if (role.comparePositionTo(me.roles.highest) >= 0)
+        return "above-helyx";
+    return "assignable";
+}
+function missingRoleInspection(input, hierarchy) {
+    return {
+        guildId: input.guildId,
+        roleId: input.roleId,
+        exists: false,
+        guildMatches: false,
+        managed: false,
+        everyone: false,
+        assignable: false,
+        actorAssignable: false,
+        hierarchy,
+        permissionNames: [],
+        dangerousPermissionNames: [],
+    };
+}
+function validateMutationMetadata(input) {
+    validateSnowflake(input.guildId, "guild");
+    validateSnowflake(input.memberUserId, "member");
+    if (input.roleId)
+        validateSnowflake(input.roleId, "role");
+    if (input.moduleId.length > 100 || !moduleIdentifier.test(input.moduleId))
+        throw new Error("Role mutation requires a valid Helyx module ID");
+    if (input.reason.trim().length === 0 ||
+        input.reason.length > 400 ||
+        /[\r\n]/u.test(input.reason))
+        throw new Error("Role mutation requires a bounded audit reason");
+}
+async function fetchExactMember(guild, memberUserId, label) {
+    validateSnowflake(memberUserId, label);
+    const member = await guild.members.fetch(memberUserId);
+    if (member.id !== memberUserId || member.guild.id !== guild.id)
+        throw new Error(`Discord ${label} validation failed`);
+    return member;
+}
+function isUnknownMember(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        error.code === RESTJSONErrorCodes.UnknownMember);
+}
+function validateBoundedRoleSet(roleIds, label) {
+    if (roleIds.length > 100 || new Set(roleIds).size !== roleIds.length)
+        throw new Error(`${label} role IDs must be unique and bounded`);
+    for (const roleId of roleIds)
+        validateSnowflake(roleId, `${label} role`);
+}
+function validateSnowflake(value, label) {
+    if (!discordSnowflake.test(value))
+        throw new Error(`Invalid Discord ${label} ID`);
+}
+function discordAuditReason(input) {
+    return `Helyx ${input.moduleId}: ${input.reason.trim()}`;
+}
+function normalizePermissionName(permission) {
+    return permission.replaceAll(/([a-z0-9])([A-Z])/g, "$1_$2").toUpperCase();
+}
+function isSingleUnicodeEmoji(value) {
+    if (!value || !/\p{Emoji}/u.test(value))
+        return false;
+    const graphemes = [
+        ...new Intl.Segmenter("en", { granularity: "grapheme" }).segment(value),
+    ];
+    return graphemes.length === 1;
+}
 function safeError(error) {
     const value = error instanceof Error ? error : new Error(String(error));
     return { name: value.name, message: value.message };