@kodelyth/discord 2026.5.39 → 2026.6.1

package/dist/account-inspect-Dqw-enky.js

@@ -0,0 +1,81 @@
+import { a as mergeDiscordAccountConfig, l as resolveDiscordAccountConfig, o as resolveDefaultDiscordAccountId } from "./accounts-B7OBFePq.js";
+import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "klaw/plugin-sdk/account-id";
+import { hasConfiguredSecretInput, normalizeSecretInputString } from "klaw/plugin-sdk/secret-input";
+import { normalizeOptionalString } from "klaw/plugin-sdk/string-coerce-runtime";
+//#region extensions/discord/src/account-inspect.ts
+function inspectDiscordTokenValue(value) {
+	const normalized = normalizeSecretInputString(value);
+	if (normalized) return {
+		token: normalized.replace(/^Bot\s+/i, ""),
+		tokenSource: "config",
+		tokenStatus: "available"
+	};
+	if (hasConfiguredSecretInput(value)) return {
+		token: "",
+		tokenSource: "config",
+		tokenStatus: "configured_unavailable"
+	};
+	return null;
+}
+function inspectDiscordAccount(params) {
+	const accountId = normalizeAccountId(params.accountId ?? resolveDefaultDiscordAccountId(params.cfg));
+	const merged = mergeDiscordAccountConfig(params.cfg, accountId);
+	const enabled = params.cfg.channels?.discord?.enabled !== false && merged.enabled !== false;
+	const accountConfig = resolveDiscordAccountConfig(params.cfg, accountId);
+	const hasAccountToken = Boolean(accountConfig && Object.prototype.hasOwnProperty.call(accountConfig, "token"));
+	const accountToken = inspectDiscordTokenValue(accountConfig?.token);
+	if (accountToken) return {
+		accountId,
+		enabled,
+		name: normalizeOptionalString(merged.name),
+		token: accountToken.token,
+		tokenSource: accountToken.tokenSource,
+		tokenStatus: accountToken.tokenStatus,
+		configured: true,
+		config: merged
+	};
+	if (hasAccountToken) return {
+		accountId,
+		enabled,
+		name: normalizeOptionalString(merged.name),
+		token: "",
+		tokenSource: "none",
+		tokenStatus: "missing",
+		configured: false,
+		config: merged
+	};
+	const channelToken = inspectDiscordTokenValue(params.cfg.channels?.discord?.token);
+	if (channelToken) return {
+		accountId,
+		enabled,
+		name: normalizeOptionalString(merged.name),
+		token: channelToken.token,
+		tokenSource: channelToken.tokenSource,
+		tokenStatus: channelToken.tokenStatus,
+		configured: true,
+		config: merged
+	};
+	const envToken = accountId === DEFAULT_ACCOUNT_ID ? normalizeSecretInputString(params.envToken ?? process.env.DISCORD_BOT_TOKEN) : void 0;
+	if (envToken) return {
+		accountId,
+		enabled,
+		name: normalizeOptionalString(merged.name),
+		token: envToken.replace(/^Bot\s+/i, ""),
+		tokenSource: "env",
+		tokenStatus: "available",
+		configured: true,
+		config: merged
+	};
+	return {
+		accountId,
+		enabled,
+		name: normalizeOptionalString(merged.name),
+		token: "",
+		tokenSource: "none",
+		tokenStatus: "missing",
+		configured: false,
+		config: merged
+	};
+}
+//#endregion
+export { inspectDiscordAccount as t };

package/dist/account-inspect-api.js

@@ -0,0 +1,10 @@
+import { t as inspectDiscordAccount } from "./account-inspect-Dqw-enky.js";
+//#region extensions/discord/account-inspect-api.ts
+function inspectDiscordReadOnlyAccount(cfg, accountId) {
+	return inspectDiscordAccount({
+		cfg,
+		accountId
+	});
+}
+//#endregion
+export { inspectDiscordReadOnlyAccount };

package/dist/accounts-B7OBFePq.js

@@ -0,0 +1,224 @@
+import { normalizeAccountId } from "klaw/plugin-sdk/account-id";
+import { normalizeResolvedSecretInputString, resolveSecretInputString } from "klaw/plugin-sdk/secret-input";
+import { normalizeOptionalString } from "klaw/plugin-sdk/string-coerce-runtime";
+import { createAccountActionGate, createAccountListHelpers, resolveMergedAccountConfig } from "klaw/plugin-sdk/account-helpers";
+import { mapAllowFromEntries, normalizeChannelDmPolicy, resolveChannelDmAllowFrom, resolveChannelDmPolicy } from "klaw/plugin-sdk/channel-config-helpers";
+import { DEFAULT_ACCOUNT_ID as DEFAULT_ACCOUNT_ID$1, normalizeAccountId as normalizeAccountId$1, resolveAccountEntry } from "klaw/plugin-sdk/routing";
+import { getRuntimeConfigSnapshot, getRuntimeConfigSourceSnapshot, selectApplicableRuntimeConfig } from "klaw/plugin-sdk/runtime-config-snapshot";
+//#region extensions/discord/src/runtime-config.ts
+function selectDiscordRuntimeConfig(inputConfig) {
+	return selectApplicableRuntimeConfig({
+		inputConfig,
+		runtimeConfig: getRuntimeConfigSnapshot(),
+		runtimeSourceConfig: getRuntimeConfigSourceSnapshot()
+	}) ?? inputConfig;
+}
+//#endregion
+//#region extensions/discord/src/token.ts
+function stripDiscordBotPrefix(token) {
+	return token.replace(/^Bot\s+/i, "");
+}
+function normalizeDiscordToken(raw, path) {
+	const trimmed = normalizeResolvedSecretInputString({
+		value: raw,
+		path
+	});
+	if (!trimmed) return;
+	return stripDiscordBotPrefix(trimmed);
+}
+function resolveDiscordTokenValue(params) {
+	const resolved = resolveSecretInputString({
+		value: params.value,
+		path: params.path,
+		defaults: params.cfg.secrets?.defaults,
+		mode: "inspect"
+	});
+	if (resolved.status === "available") return {
+		status: "available",
+		value: stripDiscordBotPrefix(resolved.value)
+	};
+	if (resolved.status === "configured_unavailable") return { status: "configured_unavailable" };
+	return { status: "missing" };
+}
+function resolveDiscordToken(cfg, opts = {}) {
+	const selectedCfg = selectDiscordRuntimeConfig(cfg);
+	const accountId = normalizeAccountId$1(opts.accountId);
+	const discordCfg = selectedCfg?.channels?.discord;
+	const accountCfg = resolveAccountEntry(discordCfg?.accounts, accountId);
+	const hasAccountToken = Boolean(accountCfg && Object.prototype.hasOwnProperty.call(accountCfg, "token"));
+	const accountToken = resolveDiscordTokenValue({
+		cfg: selectedCfg,
+		value: accountCfg?.token,
+		path: `channels.discord.accounts.${accountId}.token`
+	});
+	if (accountToken.status === "available" && accountToken.value) return {
+		token: accountToken.value,
+		source: "config",
+		tokenStatus: "available"
+	};
+	if (accountToken.status === "configured_unavailable") return {
+		token: "",
+		source: "config",
+		tokenStatus: "configured_unavailable"
+	};
+	if (hasAccountToken) return {
+		token: "",
+		source: "none",
+		tokenStatus: "missing"
+	};
+	const configToken = resolveDiscordTokenValue({
+		cfg: selectedCfg,
+		value: discordCfg?.token,
+		path: "channels.discord.token"
+	});
+	if (configToken.status === "available" && configToken.value) return {
+		token: configToken.value,
+		source: "config",
+		tokenStatus: "available"
+	};
+	if (configToken.status === "configured_unavailable") return {
+		token: "",
+		source: "config",
+		tokenStatus: "configured_unavailable"
+	};
+	const envToken = accountId === DEFAULT_ACCOUNT_ID$1 ? normalizeDiscordToken(opts.envToken ?? process.env.DISCORD_BOT_TOKEN, "DISCORD_BOT_TOKEN") : void 0;
+	if (envToken) return {
+		token: envToken,
+		source: "env",
+		tokenStatus: "available"
+	};
+	return {
+		token: "",
+		source: "none",
+		tokenStatus: "missing"
+	};
+}
+//#endregion
+//#region extensions/discord/src/accounts.ts
+const { listAccountIds, resolveDefaultAccountId } = createAccountListHelpers("discord", { implicitDefaultAccount: {
+	channelKeys: ["token"],
+	envVars: ["DISCORD_BOT_TOKEN"]
+} });
+const listDiscordAccountIds = listAccountIds;
+const resolveDefaultDiscordAccountId = resolveDefaultAccountId;
+function resolveDiscordAccountConfig(cfg, accountId) {
+	return resolveAccountEntry(cfg.channels?.discord?.accounts, accountId);
+}
+function mergeDiscordAccountConfig(cfg, accountId) {
+	return resolveMergedAccountConfig({
+		channelConfig: cfg.channels?.discord,
+		accounts: cfg.channels?.discord?.accounts,
+		accountId,
+		nestedObjectKeys: ["botLoopProtection"]
+	});
+}
+function resolveDiscordAccountAllowFrom(params) {
+	const accountId = normalizeAccountId(params.accountId ?? resolveDefaultDiscordAccountId(params.cfg));
+	const accountConfig = resolveDiscordAccountConfig(params.cfg, accountId);
+	const rootConfig = params.cfg.channels?.discord;
+	const allowFrom = resolveChannelDmAllowFrom({
+		account: accountConfig,
+		parent: rootConfig
+	});
+	return allowFrom ? mapAllowFromEntries(allowFrom) : void 0;
+}
+function resolveDiscordAccountDmPolicy(params) {
+	const accountId = normalizeAccountId(params.accountId ?? resolveDefaultDiscordAccountId(params.cfg));
+	const accountConfig = resolveDiscordAccountConfig(params.cfg, accountId);
+	const rootConfig = params.cfg.channels?.discord;
+	return normalizeChannelDmPolicy(resolveChannelDmPolicy({
+		account: accountConfig,
+		parent: rootConfig,
+		defaultPolicy: "pairing"
+	}));
+}
+function createDiscordActionGate(params) {
+	const accountId = normalizeAccountId(params.accountId ?? resolveDefaultDiscordAccountId(params.cfg));
+	return createAccountActionGate({
+		baseActions: params.cfg.channels?.discord?.actions,
+		accountActions: resolveDiscordAccountConfig(params.cfg, accountId)?.actions
+	});
+}
+function resolveDiscordAccount(params) {
+	const cfg = selectDiscordRuntimeConfig(params.cfg);
+	const accountId = normalizeAccountId(params.accountId ?? resolveDefaultDiscordAccountId(cfg));
+	const baseEnabled = cfg.channels?.discord?.enabled !== false;
+	const merged = mergeDiscordAccountConfig(cfg, accountId);
+	const accountEnabled = merged.enabled !== false;
+	const enabled = baseEnabled && accountEnabled;
+	const tokenResolution = resolveDiscordToken(cfg, { accountId });
+	return {
+		accountId,
+		enabled,
+		name: normalizeOptionalString(merged.name),
+		token: tokenResolution.token,
+		tokenSource: tokenResolution.source,
+		tokenStatus: tokenResolution.tokenStatus,
+		config: merged
+	};
+}
+function resolveDiscordMaxLinesPerMessage(params) {
+	if (typeof params.discordConfig?.maxLinesPerMessage === "number") return params.discordConfig.maxLinesPerMessage;
+	return resolveDiscordAccount({
+		cfg: params.cfg,
+		accountId: params.accountId
+	}).config.maxLinesPerMessage;
+}
+function resolveDiscordAccountTokenOwner(params) {
+	const token = params.token.trim();
+	if (!token) return;
+	let owner;
+	const accountIds = listDiscordAccountIds(params.cfg);
+	for (const [index, accountId] of accountIds.entries()) {
+		const account = resolveDiscordAccount({
+			cfg: params.cfg,
+			accountId
+		});
+		const accountToken = account.token.trim();
+		if (!account.enabled || accountToken !== token) continue;
+		const priority = account.tokenSource === "config" ? 2 : account.tokenSource === "env" ? 1 : 0;
+		if (!owner || priority > owner.priority) {
+			owner = {
+				accountId: account.accountId,
+				priority,
+				index
+			};
+			continue;
+		}
+		if (priority === owner.priority && index < owner.index) owner = {
+			accountId: account.accountId,
+			priority,
+			index
+		};
+	}
+	return owner?.accountId;
+}
+function resolveDiscordDuplicateTokenOwner(params) {
+	const owner = resolveDiscordAccountTokenOwner({
+		cfg: params.cfg,
+		token: params.account.token
+	});
+	return owner && owner !== params.account.accountId ? owner : void 0;
+}
+function isDiscordAccountEnabledForRuntime(account, cfg) {
+	return account.enabled && !resolveDiscordDuplicateTokenOwner({
+		cfg,
+		account
+	});
+}
+function resolveDiscordAccountDisabledReason(account, cfg) {
+	if (!account.enabled) return "disabled";
+	const owner = resolveDiscordDuplicateTokenOwner({
+		cfg,
+		account
+	});
+	return owner ? `duplicate bot token; using account "${owner}"` : "disabled";
+}
+function listEnabledDiscordAccounts(cfg) {
+	return listDiscordAccountIds(cfg).map((accountId) => resolveDiscordAccount({
+		cfg,
+		accountId
+	})).filter((account) => isDiscordAccountEnabledForRuntime(account, cfg));
+}
+//#endregion
+export { mergeDiscordAccountConfig as a, resolveDiscordAccountAllowFrom as c, resolveDiscordAccountDmPolicy as d, resolveDiscordMaxLinesPerMessage as f, listEnabledDiscordAccounts as i, resolveDiscordAccountConfig as l, resolveDiscordToken as m, isDiscordAccountEnabledForRuntime as n, resolveDefaultDiscordAccountId as o, normalizeDiscordToken as p, listDiscordAccountIds as r, resolveDiscordAccount as s, createDiscordActionGate as t, resolveDiscordAccountDisabledReason as u };

package/dist/action-runtime-api.js

@@ -0,0 +1,2 @@
+import { t as handleDiscordAction } from "./runtime-DUaw66V_.js";
+export { handleDiscordAction };

package/dist/agent-components.runtime-DVY_1VB4.js

@@ -0,0 +1,4 @@
+import { buildPluginBindingResolvedText, parsePluginBindingApprovalCustomId, recordInboundSession, resolvePluginConversationBindingApproval } from "klaw/plugin-sdk/conversation-runtime";
+import { dispatchPluginInteractiveHandler } from "klaw/plugin-sdk/plugin-runtime";
+import { createReplyReferencePlanner, dispatchReplyWithBufferedBlockDispatcher, finalizeInboundContext, resolveChunkMode, resolveTextChunkLimit } from "klaw/plugin-sdk/reply-runtime";
+export { buildPluginBindingResolvedText, createReplyReferencePlanner, dispatchPluginInteractiveHandler, dispatchReplyWithBufferedBlockDispatcher, finalizeInboundContext, parsePluginBindingApprovalCustomId, recordInboundSession, resolveChunkMode, resolvePluginConversationBindingApproval, resolveTextChunkLimit };

package/dist/allow-list-B0s7evD7.js

@@ -0,0 +1,354 @@
+import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "klaw/plugin-sdk/string-coerce-runtime";
+import { buildChannelKeyCandidates, resolveChannelEntryMatchWithFallback, resolveChannelMatchConfig } from "klaw/plugin-sdk/channel-targets";
+//#region extensions/discord/src/monitor/format.ts
+function resolveDiscordSystemLocation(params) {
+	const { isDirectMessage, isGroupDm, guild, channelName } = params;
+	if (isDirectMessage) return "DM";
+	if (isGroupDm) return `Group DM #${channelName}`;
+	return guild?.name ? `${guild.name} #${channelName}` : `#${channelName}`;
+}
+function formatDiscordReactionEmoji(emoji) {
+	if (emoji.id && emoji.name) return `<:${emoji.name}:${emoji.id}>`;
+	if (emoji.id) return `emoji:${emoji.id}`;
+	return emoji.name ?? "emoji";
+}
+function formatDiscordUserTag(user) {
+	const discriminator = (user.discriminator ?? "").trim();
+	if (discriminator && discriminator !== "0") return `${user.username}#${discriminator}`;
+	return user.username ?? user.id;
+}
+function resolveTimestampMs(timestamp) {
+	if (!timestamp) return;
+	const parsed = Date.parse(timestamp);
+	return Number.isNaN(parsed) ? void 0 : parsed;
+}
+//#endregion
+//#region extensions/discord/src/monitor/allow-list.ts
+const DISCORD_OWNER_ALLOWLIST_PREFIXES = [
+	"discord:",
+	"user:",
+	"pk:"
+];
+function normalizeDiscordAllowList(raw, prefixes) {
+	if (!raw || raw.length === 0) return null;
+	const ids = /* @__PURE__ */ new Set();
+	const names = /* @__PURE__ */ new Set();
+	const allowAll = raw.some((entry) => (normalizeOptionalString(entry) ?? "") === "*");
+	for (const entry of raw) {
+		const text = normalizeOptionalString(entry) ?? "";
+		if (!text || text === "*") continue;
+		const normalized = normalizeDiscordSlug(text);
+		const maybeId = text.replace(/^<@!?/, "").replace(/>$/, "");
+		if (/^\d+$/.test(maybeId)) {
+			ids.add(maybeId);
+			continue;
+		}
+		const prefix = prefixes.find((entry) => text.startsWith(entry));
+		if (prefix) {
+			const candidate = text.slice(prefix.length);
+			if (candidate) ids.add(candidate);
+			continue;
+		}
+		if (normalized) names.add(normalized);
+	}
+	return {
+		allowAll,
+		ids,
+		names
+	};
+}
+function normalizeDiscordSlug(value) {
+	return normalizeLowercaseStringOrEmpty(value).replace(/^#/, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function normalizeDiscordDisplaySlug(value) {
+	return normalizeLowercaseStringOrEmpty(value).normalize("NFC").replace(/^#/, "").replace(/[\s_]+/g, "-").replace(/[^\p{L}\p{M}\p{N}-]+/gu, "-").replace(/-{2,}/g, "-").replace(/^-+|-+$/g, "");
+}
+function resolveDiscordAllowListNameMatch(list, candidate) {
+	const nameSlug = candidate.name ? normalizeDiscordSlug(candidate.name) : "";
+	if (nameSlug && list.names.has(nameSlug)) return {
+		matchKey: nameSlug,
+		matchSource: "name"
+	};
+	const tagSlug = candidate.tag ? normalizeDiscordSlug(candidate.tag) : "";
+	if (tagSlug && list.names.has(tagSlug)) return {
+		matchKey: tagSlug,
+		matchSource: "tag"
+	};
+	return null;
+}
+function allowListMatches(list, candidate, params) {
+	if (list.allowAll) return true;
+	if (candidate.id && list.ids.has(candidate.id)) return true;
+	if (params?.allowNameMatching === true) {
+		if (resolveDiscordAllowListNameMatch(list, candidate)) return true;
+	}
+	return false;
+}
+function resolveDiscordAllowListMatch(params) {
+	const { allowList, candidate } = params;
+	if (allowList.allowAll) return {
+		allowed: true,
+		matchKey: "*",
+		matchSource: "wildcard"
+	};
+	if (candidate.id && allowList.ids.has(candidate.id)) return {
+		allowed: true,
+		matchKey: candidate.id,
+		matchSource: "id"
+	};
+	if (params.allowNameMatching === true) {
+		const namedMatch = resolveDiscordAllowListNameMatch(allowList, candidate);
+		if (namedMatch) return {
+			allowed: true,
+			...namedMatch
+		};
+	}
+	return { allowed: false };
+}
+function resolveDiscordUserAllowed(params) {
+	const allowList = normalizeDiscordAllowList(params.allowList, [
+		"discord:",
+		"user:",
+		"pk:"
+	]);
+	if (!allowList) return true;
+	return allowListMatches(allowList, {
+		id: params.userId,
+		name: params.userName,
+		tag: params.userTag
+	}, { allowNameMatching: params.allowNameMatching });
+}
+function resolveDiscordRoleAllowed(params) {
+	const allowList = normalizeDiscordAllowList(params.allowList, ["role:"]);
+	if (!allowList) return true;
+	if (allowList.allowAll) return true;
+	return params.memberRoleIds.some((roleId) => allowList.ids.has(roleId));
+}
+function resolveDiscordMemberAllowed(params) {
+	const hasUserRestriction = Array.isArray(params.userAllowList) && params.userAllowList.length > 0;
+	const hasRoleRestriction = Array.isArray(params.roleAllowList) && params.roleAllowList.length > 0;
+	if (!hasUserRestriction && !hasRoleRestriction) return true;
+	const userOk = hasUserRestriction ? resolveDiscordUserAllowed({
+		allowList: params.userAllowList,
+		userId: params.userId,
+		userName: params.userName,
+		userTag: params.userTag,
+		allowNameMatching: params.allowNameMatching
+	}) : false;
+	const roleOk = hasRoleRestriction ? resolveDiscordRoleAllowed({
+		allowList: params.roleAllowList,
+		memberRoleIds: params.memberRoleIds
+	}) : false;
+	return userOk || roleOk;
+}
+function resolveDiscordMemberAccessState(params) {
+	const channelUsers = params.channelConfig?.users ?? params.guildInfo?.users;
+	const channelRoles = params.channelConfig?.roles ?? params.guildInfo?.roles;
+	return {
+		channelUsers,
+		channelRoles,
+		hasAccessRestrictions: Array.isArray(channelUsers) && channelUsers.length > 0 || Array.isArray(channelRoles) && channelRoles.length > 0,
+		memberAllowed: resolveDiscordMemberAllowed({
+			userAllowList: channelUsers,
+			roleAllowList: channelRoles,
+			memberRoleIds: params.memberRoleIds,
+			userId: params.sender.id,
+			userName: params.sender.name,
+			userTag: params.sender.tag,
+			allowNameMatching: params.allowNameMatching
+		})
+	};
+}
+function resolveDiscordOwnerAllowFrom(params) {
+	const rawAllowList = params.channelConfig?.users ?? params.guildInfo?.users;
+	if (!Array.isArray(rawAllowList) || rawAllowList.length === 0) return;
+	const allowList = normalizeDiscordAllowList(rawAllowList, [
+		"discord:",
+		"user:",
+		"pk:"
+	]);
+	if (!allowList) return;
+	const match = resolveDiscordAllowListMatch({
+		allowList,
+		candidate: {
+			id: params.sender.id,
+			name: params.sender.name,
+			tag: params.sender.tag
+		},
+		allowNameMatching: params.allowNameMatching
+	});
+	if (!match.allowed || !match.matchKey || match.matchKey === "*") return;
+	return [match.matchKey];
+}
+function resolveDiscordOwnerAccess(params) {
+	const ownerAllowFrom = params.allowFrom?.filter((entry) => (normalizeOptionalString(entry) ?? "") !== "*");
+	const ownerAllowList = normalizeDiscordAllowList(ownerAllowFrom && ownerAllowFrom.length > 0 ? ownerAllowFrom : void 0, DISCORD_OWNER_ALLOWLIST_PREFIXES);
+	return {
+		ownerAllowList,
+		ownerAllowed: ownerAllowList ? allowListMatches(ownerAllowList, {
+			id: params.sender.id,
+			name: params.sender.name,
+			tag: params.sender.tag
+		}, { allowNameMatching: params.allowNameMatching }) : false
+	};
+}
+function resolveDiscordCommandAuthorized(params) {
+	if (!params.isDirectMessage) return true;
+	const allowList = normalizeDiscordAllowList(params.allowFrom, [
+		"discord:",
+		"user:",
+		"pk:"
+	]);
+	if (!allowList) return true;
+	return allowListMatches(allowList, {
+		id: params.author.id,
+		name: params.author.username,
+		tag: formatDiscordUserTag(params.author)
+	}, { allowNameMatching: params.allowNameMatching });
+}
+function resolveDiscordGuildEntry(params) {
+	const guild = params.guild;
+	const entries = params.guildEntries;
+	const guildId = params.guildId?.trim() || guild?.id;
+	if (!entries) return null;
+	const byId = guildId ? entries[guildId] : void 0;
+	if (byId) return {
+		...byId,
+		id: guildId
+	};
+	if (!guild) return null;
+	const slug = normalizeDiscordSlug(guild.name ?? "");
+	const bySlug = entries[slug];
+	if (bySlug) return {
+		...bySlug,
+		id: guildId ?? guild.id,
+		slug: slug || bySlug.slug
+	};
+	const wildcard = entries["*"];
+	if (wildcard) return {
+		...wildcard,
+		id: guildId ?? guild.id,
+		slug: slug || wildcard.slug
+	};
+	return null;
+}
+function buildDiscordChannelKeys(params) {
+	const allowNameMatch = params.allowNameMatch !== false;
+	return buildChannelKeyCandidates(params.id, allowNameMatch ? params.slug : void 0, allowNameMatch ? params.name : void 0);
+}
+function resolveDiscordChannelEntryMatch(channels, params, parentParams) {
+	return resolveChannelEntryMatchWithFallback({
+		entries: channels,
+		keys: buildDiscordChannelKeys(params),
+		parentKeys: parentParams ? buildDiscordChannelKeys(parentParams) : void 0,
+		wildcardKey: "*"
+	});
+}
+function hasConfiguredDiscordChannels(channels) {
+	return Boolean(channels && Object.keys(channels).length > 0);
+}
+function resolveDiscordChannelConfigEntry(entry) {
+	return {
+		allowed: entry.enabled !== false,
+		requireMention: entry.requireMention,
+		ignoreOtherMentions: entry.ignoreOtherMentions,
+		skills: entry.skills,
+		enabled: entry.enabled,
+		users: entry.users,
+		roles: entry.roles,
+		systemPrompt: entry.systemPrompt,
+		includeThreadStarter: entry.includeThreadStarter,
+		autoThread: entry.autoThread,
+		autoThreadName: entry.autoThreadName,
+		autoArchiveDuration: entry.autoArchiveDuration
+	};
+}
+function resolveDiscordChannelConfig(params) {
+	const { guildInfo, channelId, channelName, channelSlug } = params;
+	const channels = guildInfo?.channels;
+	if (!hasConfiguredDiscordChannels(channels)) return null;
+	return resolveChannelMatchConfig(resolveDiscordChannelEntryMatch(channels, {
+		id: channelId,
+		name: channelName,
+		slug: channelSlug
+	}), resolveDiscordChannelConfigEntry) ?? { allowed: false };
+}
+function resolveDiscordChannelConfigWithFallback(params) {
+	const { guildInfo, channelId, channelName, channelSlug, parentId, parentName, parentSlug, scope } = params;
+	const channels = guildInfo?.channels;
+	if (!hasConfiguredDiscordChannels(channels)) return null;
+	const resolvedParentSlug = parentSlug ?? (parentName ? normalizeDiscordSlug(parentName) : "");
+	return resolveChannelMatchConfig(resolveDiscordChannelEntryMatch(channels, {
+		id: channelId,
+		name: channelName,
+		slug: channelSlug,
+		allowNameMatch: scope !== "thread"
+	}, parentId || parentName || parentSlug ? {
+		id: parentId ?? "",
+		name: parentName,
+		slug: resolvedParentSlug
+	} : void 0), resolveDiscordChannelConfigEntry) ?? { allowed: false };
+}
+function resolveDiscordShouldRequireMention(params) {
+	if (!params.isGuildMessage) return false;
+	if (params.isAutoThreadOwnedByBot ?? isDiscordAutoThreadOwnedByBot(params)) return false;
+	return params.channelConfig?.requireMention ?? params.guildInfo?.requireMention ?? true;
+}
+function isDiscordAutoThreadOwnedByBot(params) {
+	if (!params.isThread) return false;
+	if (!params.channelConfig?.autoThread) return false;
+	const botId = params.botId?.trim();
+	const threadOwnerId = params.threadOwnerId?.trim();
+	return Boolean(botId && threadOwnerId && botId === threadOwnerId);
+}
+function isDiscordGroupAllowedByPolicy(params) {
+	if (params.groupPolicy === "allowlist" && !params.guildAllowlisted) return false;
+	if (params.groupPolicy === "disabled") return false;
+	return params.groupPolicy !== "allowlist" || !params.channelAllowlistConfigured || params.channelAllowed;
+}
+function resolveDiscordChannelPolicyCommandAuthorizer(params) {
+	const channelAllowlistConfigured = Boolean(params.guildInfo?.channels) && Object.keys(params.guildInfo?.channels ?? {}).length > 0;
+	return {
+		configured: params.groupPolicy === "allowlist" && (Boolean(params.guildInfo) || channelAllowlistConfigured),
+		allowed: isDiscordGroupAllowedByPolicy({
+			groupPolicy: params.groupPolicy,
+			guildAllowlisted: Boolean(params.guildInfo),
+			channelAllowlistConfigured,
+			channelAllowed: params.channelConfig?.allowed !== false
+		})
+	};
+}
+function resolveGroupDmAllow(params) {
+	const { channels, channelId, channelName, channelSlug } = params;
+	if (!channels || channels.length === 0) return true;
+	const allowList = new Set(channels.map((entry) => normalizeDiscordSlug(entry)));
+	const candidates = [
+		normalizeDiscordSlug(channelId),
+		channelSlug,
+		channelName ? normalizeDiscordSlug(channelName) : ""
+	].filter(Boolean);
+	return allowList.has("*") || candidates.some((candidate) => allowList.has(candidate));
+}
+function shouldEmitDiscordReactionNotification(params) {
+	const mode = params.mode ?? "own";
+	if (mode === "off") return false;
+	const accessGuildInfo = params.guildInfo ?? (params.allowlist ? { users: params.allowlist } : null);
+	const { hasAccessRestrictions, memberAllowed } = resolveDiscordMemberAccessState({
+		channelConfig: params.channelConfig,
+		guildInfo: accessGuildInfo,
+		memberRoleIds: params.memberRoleIds ?? [],
+		sender: {
+			id: params.userId,
+			name: params.userName,
+			tag: params.userTag
+		},
+		allowNameMatching: params.allowNameMatching
+	});
+	if (mode === "allowlist") return hasAccessRestrictions && memberAllowed;
+	if (hasAccessRestrictions && !memberAllowed) return false;
+	if (mode === "all") return true;
+	if (mode === "own") return Boolean(params.botId && params.messageAuthorId === params.botId);
+	return false;
+}
+//#endregion
+export { resolveTimestampMs as S, resolveGroupDmAllow as _, normalizeDiscordSlug as a, formatDiscordUserTag as b, resolveDiscordChannelConfigWithFallback as c, resolveDiscordGuildEntry as d, resolveDiscordMemberAccessState as f, resolveDiscordShouldRequireMention as g, resolveDiscordOwnerAllowFrom as h, normalizeDiscordDisplaySlug as i, resolveDiscordChannelPolicyCommandAuthorizer as l, resolveDiscordOwnerAccess as m, isDiscordGroupAllowedByPolicy as n, resolveDiscordAllowListMatch as o, resolveDiscordMemberAllowed as p, normalizeDiscordAllowList as r, resolveDiscordChannelConfig as s, allowListMatches as t, resolveDiscordCommandAuthorized as u, shouldEmitDiscordReactionNotification as v, resolveDiscordSystemLocation as x, formatDiscordReactionEmoji as y };