@spacebar_ai/moldclaw-core 2026.3.43 → 2026.3.45

package/dist/resolve-route-DdX-HBVt.js

@@ -0,0 +1,538 @@
+import { l as shouldLogVerbose } from "./globals-DESrFYmC.js";
+import { m as resolveDefaultAgentId } from "./agent-scope-lZlwP1At.js";
+import { c as normalizeAgentId, f as sanitizeAgentId, i as buildAgentPeerSessionKey, n as DEFAULT_MAIN_KEY, r as buildAgentMainSessionKey } from "./session-key-UoG7Kfw5.js";
+import { n as normalizeAccountId, t as DEFAULT_ACCOUNT_ID } from "./account-id-BuyZMNja.js";
+import { t as logDebug } from "./logger-BGzLUitz.js";
+import { c as normalizeChatChannelId } from "./registry-C1pRrsQl.js";
+import { r as listRouteBindings } from "./bindings-EA8JT6o1.js";
+//#region src/channels/chat-type.ts
+function normalizeChatType(raw) {
+	const value = raw?.trim().toLowerCase();
+	if (!value) return;
+	if (value === "direct" || value === "dm") return "direct";
+	if (value === "group") return "group";
+	if (value === "channel") return "channel";
+}
+//#endregion
+//#region src/routing/bindings.ts
+function normalizeBindingChannelId(raw) {
+	const normalized = normalizeChatChannelId(raw);
+	if (normalized) return normalized;
+	return (raw ?? "").trim().toLowerCase() || null;
+}
+function listBindings(cfg) {
+	return listRouteBindings(cfg);
+}
+function resolveNormalizedBindingMatch(binding) {
+	if (!binding || typeof binding !== "object") return null;
+	const match = binding.match;
+	if (!match || typeof match !== "object") return null;
+	const channelId = normalizeBindingChannelId(match.channel);
+	if (!channelId) return null;
+	const accountId = typeof match.accountId === "string" ? match.accountId.trim() : "";
+	if (!accountId || accountId === "*") return null;
+	return {
+		agentId: normalizeAgentId(binding.agentId),
+		accountId: normalizeAccountId(accountId),
+		channelId
+	};
+}
+function listBoundAccountIds(cfg, channelId) {
+	const normalizedChannel = normalizeBindingChannelId(channelId);
+	if (!normalizedChannel) return [];
+	const ids = /* @__PURE__ */ new Set();
+	for (const binding of listBindings(cfg)) {
+		const resolved = resolveNormalizedBindingMatch(binding);
+		if (!resolved || resolved.channelId !== normalizedChannel) continue;
+		ids.add(resolved.accountId);
+	}
+	return Array.from(ids).toSorted((a, b) => a.localeCompare(b));
+}
+function resolveDefaultAgentBoundAccountId(cfg, channelId) {
+	const normalizedChannel = normalizeBindingChannelId(channelId);
+	if (!normalizedChannel) return null;
+	const defaultAgentId = normalizeAgentId(resolveDefaultAgentId(cfg));
+	for (const binding of listBindings(cfg)) {
+		const resolved = resolveNormalizedBindingMatch(binding);
+		if (!resolved || resolved.channelId !== normalizedChannel || resolved.agentId !== defaultAgentId) continue;
+		return resolved.accountId;
+	}
+	return null;
+}
+function buildChannelAccountBindings(cfg) {
+	const map = /* @__PURE__ */ new Map();
+	for (const binding of listBindings(cfg)) {
+		const resolved = resolveNormalizedBindingMatch(binding);
+		if (!resolved) continue;
+		const byAgent = map.get(resolved.channelId) ?? /* @__PURE__ */ new Map();
+		const list = byAgent.get(resolved.agentId) ?? [];
+		if (!list.includes(resolved.accountId)) list.push(resolved.accountId);
+		byAgent.set(resolved.agentId, list);
+		map.set(resolved.channelId, byAgent);
+	}
+	return map;
+}
+function resolvePreferredAccountId(params) {
+	if (params.boundAccounts.length > 0) return params.boundAccounts[0];
+	return params.defaultAccountId;
+}
+//#endregion
+//#region src/routing/resolve-route.ts
+function deriveLastRoutePolicy(params) {
+	return params.sessionKey === params.mainSessionKey ? "main" : "session";
+}
+function resolveInboundLastRouteSessionKey(params) {
+	return params.route.lastRoutePolicy === "main" ? params.route.mainSessionKey : params.sessionKey;
+}
+function normalizeToken(value) {
+	return (value ?? "").trim().toLowerCase();
+}
+function normalizeId(value) {
+	if (typeof value === "string") return value.trim();
+	if (typeof value === "number" || typeof value === "bigint") return String(value).trim();
+	return "";
+}
+function buildAgentSessionKey(params) {
+	const channel = normalizeToken(params.channel) || "unknown";
+	const peer = params.peer;
+	return buildAgentPeerSessionKey({
+		agentId: params.agentId,
+		mainKey: DEFAULT_MAIN_KEY,
+		channel,
+		accountId: params.accountId,
+		peerKind: peer?.kind ?? "direct",
+		peerId: peer ? normalizeId(peer.id) || "unknown" : null,
+		dmScope: params.dmScope,
+		identityLinks: params.identityLinks
+	});
+}
+function listAgents(cfg) {
+	const agents = cfg.agents?.list;
+	return Array.isArray(agents) ? agents : [];
+}
+const agentLookupCacheByCfg = /* @__PURE__ */ new WeakMap();
+function resolveAgentLookupCache(cfg) {
+	const agentsRef = cfg.agents;
+	const existing = agentLookupCacheByCfg.get(cfg);
+	if (existing && existing.agentsRef === agentsRef) return existing;
+	const byNormalizedId = /* @__PURE__ */ new Map();
+	for (const agent of listAgents(cfg)) {
+		const rawId = agent.id?.trim();
+		if (!rawId) continue;
+		byNormalizedId.set(normalizeAgentId(rawId), sanitizeAgentId(rawId));
+	}
+	const next = {
+		agentsRef,
+		byNormalizedId,
+		fallbackDefaultAgentId: sanitizeAgentId(resolveDefaultAgentId(cfg))
+	};
+	agentLookupCacheByCfg.set(cfg, next);
+	return next;
+}
+function pickFirstExistingAgentId(cfg, agentId) {
+	const lookup = resolveAgentLookupCache(cfg);
+	const trimmed = (agentId ?? "").trim();
+	if (!trimmed) return lookup.fallbackDefaultAgentId;
+	const normalized = normalizeAgentId(trimmed);
+	if (lookup.byNormalizedId.size === 0) return sanitizeAgentId(trimmed);
+	const resolved = lookup.byNormalizedId.get(normalized);
+	if (resolved) return resolved;
+	return lookup.fallbackDefaultAgentId;
+}
+const evaluatedBindingsCacheByCfg = /* @__PURE__ */ new WeakMap();
+const MAX_EVALUATED_BINDINGS_CACHE_KEYS = 2e3;
+const resolvedRouteCacheByCfg = /* @__PURE__ */ new WeakMap();
+const MAX_RESOLVED_ROUTE_CACHE_KEYS = 4e3;
+function resolveAccountPatternKey(accountPattern) {
+	if (!accountPattern.trim()) return DEFAULT_ACCOUNT_ID;
+	return normalizeAccountId(accountPattern);
+}
+function buildEvaluatedBindingsByChannel(cfg) {
+	const byChannel = /* @__PURE__ */ new Map();
+	let order = 0;
+	for (const binding of listBindings(cfg)) {
+		if (!binding || typeof binding !== "object") continue;
+		const channel = normalizeToken(binding.match?.channel);
+		if (!channel) continue;
+		const match = normalizeBindingMatch(binding.match);
+		const evaluated = {
+			binding,
+			match,
+			order
+		};
+		order += 1;
+		let bucket = byChannel.get(channel);
+		if (!bucket) {
+			bucket = {
+				byAccount: /* @__PURE__ */ new Map(),
+				byAnyAccount: []
+			};
+			byChannel.set(channel, bucket);
+		}
+		if (match.accountPattern === "*") {
+			bucket.byAnyAccount.push(evaluated);
+			continue;
+		}
+		const accountKey = resolveAccountPatternKey(match.accountPattern);
+		const existing = bucket.byAccount.get(accountKey);
+		if (existing) {
+			existing.push(evaluated);
+			continue;
+		}
+		bucket.byAccount.set(accountKey, [evaluated]);
+	}
+	return byChannel;
+}
+function mergeEvaluatedBindingsInSourceOrder(accountScoped, anyAccount) {
+	if (accountScoped.length === 0) return anyAccount;
+	if (anyAccount.length === 0) return accountScoped;
+	const merged = [];
+	let accountIdx = 0;
+	let anyIdx = 0;
+	while (accountIdx < accountScoped.length && anyIdx < anyAccount.length) {
+		const accountBinding = accountScoped[accountIdx];
+		const anyBinding = anyAccount[anyIdx];
+		if ((accountBinding?.order ?? Number.MAX_SAFE_INTEGER) <= (anyBinding?.order ?? Number.MAX_SAFE_INTEGER)) {
+			if (accountBinding) merged.push(accountBinding);
+			accountIdx += 1;
+			continue;
+		}
+		if (anyBinding) merged.push(anyBinding);
+		anyIdx += 1;
+	}
+	if (accountIdx < accountScoped.length) merged.push(...accountScoped.slice(accountIdx));
+	if (anyIdx < anyAccount.length) merged.push(...anyAccount.slice(anyIdx));
+	return merged;
+}
+function pushToIndexMap(map, key, binding) {
+	if (!key) return;
+	const existing = map.get(key);
+	if (existing) {
+		existing.push(binding);
+		return;
+	}
+	map.set(key, [binding]);
+}
+function peerLookupKeys(kind, id) {
+	if (kind === "group") return [`group:${id}`, `channel:${id}`];
+	if (kind === "channel") return [`channel:${id}`, `group:${id}`];
+	return [`${kind}:${id}`];
+}
+function collectPeerIndexedBindings(index, peer) {
+	if (!peer) return [];
+	const out = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const key of peerLookupKeys(peer.kind, peer.id)) {
+		const matches = index.byPeer.get(key);
+		if (!matches) continue;
+		for (const match of matches) {
+			if (seen.has(match)) continue;
+			seen.add(match);
+			out.push(match);
+		}
+	}
+	return out;
+}
+function buildEvaluatedBindingsIndex(bindings) {
+	const byPeer = /* @__PURE__ */ new Map();
+	const byGuildWithRoles = /* @__PURE__ */ new Map();
+	const byGuild = /* @__PURE__ */ new Map();
+	const byTeam = /* @__PURE__ */ new Map();
+	const byAccount = [];
+	const byChannel = [];
+	for (const binding of bindings) {
+		if (binding.match.peer.state === "valid") {
+			for (const key of peerLookupKeys(binding.match.peer.kind, binding.match.peer.id)) pushToIndexMap(byPeer, key, binding);
+			continue;
+		}
+		if (binding.match.guildId && binding.match.roles) {
+			pushToIndexMap(byGuildWithRoles, binding.match.guildId, binding);
+			continue;
+		}
+		if (binding.match.guildId && !binding.match.roles) {
+			pushToIndexMap(byGuild, binding.match.guildId, binding);
+			continue;
+		}
+		if (binding.match.teamId) {
+			pushToIndexMap(byTeam, binding.match.teamId, binding);
+			continue;
+		}
+		if (binding.match.accountPattern !== "*") {
+			byAccount.push(binding);
+			continue;
+		}
+		byChannel.push(binding);
+	}
+	return {
+		byPeer,
+		byGuildWithRoles,
+		byGuild,
+		byTeam,
+		byAccount,
+		byChannel
+	};
+}
+function getEvaluatedBindingsForChannelAccount(cfg, channel, accountId) {
+	const bindingsRef = cfg.bindings;
+	const existing = evaluatedBindingsCacheByCfg.get(cfg);
+	const cache = existing && existing.bindingsRef === bindingsRef ? existing : {
+		bindingsRef,
+		byChannel: buildEvaluatedBindingsByChannel(cfg),
+		byChannelAccount: /* @__PURE__ */ new Map(),
+		byChannelAccountIndex: /* @__PURE__ */ new Map()
+	};
+	if (cache !== existing) evaluatedBindingsCacheByCfg.set(cfg, cache);
+	const cacheKey = `${channel}\t${accountId}`;
+	const hit = cache.byChannelAccount.get(cacheKey);
+	if (hit) return hit;
+	const channelBindings = cache.byChannel.get(channel);
+	const evaluated = mergeEvaluatedBindingsInSourceOrder(channelBindings?.byAccount.get(accountId) ?? [], channelBindings?.byAnyAccount ?? []);
+	cache.byChannelAccount.set(cacheKey, evaluated);
+	cache.byChannelAccountIndex.set(cacheKey, buildEvaluatedBindingsIndex(evaluated));
+	if (cache.byChannelAccount.size > MAX_EVALUATED_BINDINGS_CACHE_KEYS) {
+		cache.byChannelAccount.clear();
+		cache.byChannelAccountIndex.clear();
+		cache.byChannelAccount.set(cacheKey, evaluated);
+		cache.byChannelAccountIndex.set(cacheKey, buildEvaluatedBindingsIndex(evaluated));
+	}
+	return evaluated;
+}
+function getEvaluatedBindingIndexForChannelAccount(cfg, channel, accountId) {
+	const bindings = getEvaluatedBindingsForChannelAccount(cfg, channel, accountId);
+	const existing = evaluatedBindingsCacheByCfg.get(cfg);
+	const cacheKey = `${channel}\t${accountId}`;
+	const indexed = existing?.byChannelAccountIndex.get(cacheKey);
+	if (indexed) return indexed;
+	const built = buildEvaluatedBindingsIndex(bindings);
+	existing?.byChannelAccountIndex.set(cacheKey, built);
+	return built;
+}
+function normalizePeerConstraint(peer) {
+	if (!peer) return { state: "none" };
+	const kind = normalizeChatType(peer.kind);
+	const id = normalizeId(peer.id);
+	if (!kind || !id) return { state: "invalid" };
+	return {
+		state: "valid",
+		kind,
+		id
+	};
+}
+function normalizeBindingMatch(match) {
+	const rawRoles = match?.roles;
+	return {
+		accountPattern: (match?.accountId ?? "").trim(),
+		peer: normalizePeerConstraint(match?.peer),
+		guildId: normalizeId(match?.guildId) || null,
+		teamId: normalizeId(match?.teamId) || null,
+		roles: Array.isArray(rawRoles) && rawRoles.length > 0 ? rawRoles : null
+	};
+}
+function resolveRouteCacheForConfig(cfg) {
+	const existing = resolvedRouteCacheByCfg.get(cfg);
+	if (existing && existing.bindingsRef === cfg.bindings && existing.agentsRef === cfg.agents && existing.sessionRef === cfg.session) return existing.byKey;
+	const byKey = /* @__PURE__ */ new Map();
+	resolvedRouteCacheByCfg.set(cfg, {
+		bindingsRef: cfg.bindings,
+		agentsRef: cfg.agents,
+		sessionRef: cfg.session,
+		byKey
+	});
+	return byKey;
+}
+function formatRouteCachePeer(peer) {
+	if (!peer || !peer.id) return "-";
+	return `${peer.kind}:${peer.id}`;
+}
+function formatRoleIdsCacheKey(roleIds) {
+	const count = roleIds.length;
+	if (count === 0) return "-";
+	if (count === 1) return roleIds[0] ?? "-";
+	if (count === 2) {
+		const first = roleIds[0] ?? "";
+		const second = roleIds[1] ?? "";
+		return first <= second ? `${first},${second}` : `${second},${first}`;
+	}
+	return roleIds.toSorted().join(",");
+}
+function buildResolvedRouteCacheKey(params) {
+	return `${params.channel}\t${params.accountId}\t${formatRouteCachePeer(params.peer)}\t${formatRouteCachePeer(params.parentPeer)}\t${params.guildId || "-"}\t${params.teamId || "-"}\t${formatRoleIdsCacheKey(params.memberRoleIds)}\t${params.dmScope}`;
+}
+function hasGuildConstraint(match) {
+	return Boolean(match.guildId);
+}
+function hasTeamConstraint(match) {
+	return Boolean(match.teamId);
+}
+function hasRolesConstraint(match) {
+	return Boolean(match.roles);
+}
+function peerKindMatches(bindingKind, scopeKind) {
+	if (bindingKind === scopeKind) return true;
+	const both = new Set([bindingKind, scopeKind]);
+	return both.has("group") && both.has("channel");
+}
+function matchesBindingScope(match, scope) {
+	if (match.peer.state === "invalid") return false;
+	if (match.peer.state === "valid") {
+		if (!scope.peer || !peerKindMatches(match.peer.kind, scope.peer.kind) || scope.peer.id !== match.peer.id) return false;
+	}
+	if (match.guildId && match.guildId !== scope.guildId) return false;
+	if (match.teamId && match.teamId !== scope.teamId) return false;
+	if (match.roles) {
+		for (const role of match.roles) if (scope.memberRoleIds.has(role)) return true;
+		return false;
+	}
+	return true;
+}
+function resolveAgentRoute(input) {
+	const channel = normalizeToken(input.channel);
+	const accountId = normalizeAccountId(input.accountId);
+	const peer = input.peer ? {
+		kind: normalizeChatType(input.peer.kind) ?? input.peer.kind,
+		id: normalizeId(input.peer.id)
+	} : null;
+	const guildId = normalizeId(input.guildId);
+	const teamId = normalizeId(input.teamId);
+	const memberRoleIds = input.memberRoleIds ?? [];
+	const memberRoleIdSet = new Set(memberRoleIds);
+	const dmScope = input.cfg.session?.dmScope ?? "main";
+	const identityLinks = input.cfg.session?.identityLinks;
+	const shouldLogDebug = shouldLogVerbose();
+	const parentPeer = input.parentPeer ? {
+		kind: normalizeChatType(input.parentPeer.kind) ?? input.parentPeer.kind,
+		id: normalizeId(input.parentPeer.id)
+	} : null;
+	const routeCache = !shouldLogDebug && !identityLinks ? resolveRouteCacheForConfig(input.cfg) : null;
+	const routeCacheKey = routeCache ? buildResolvedRouteCacheKey({
+		channel,
+		accountId,
+		peer,
+		parentPeer,
+		guildId,
+		teamId,
+		memberRoleIds,
+		dmScope
+	}) : "";
+	if (routeCache && routeCacheKey) {
+		const cachedRoute = routeCache.get(routeCacheKey);
+		if (cachedRoute) return { ...cachedRoute };
+	}
+	const bindings = getEvaluatedBindingsForChannelAccount(input.cfg, channel, accountId);
+	const bindingsIndex = getEvaluatedBindingIndexForChannelAccount(input.cfg, channel, accountId);
+	const choose = (agentId, matchedBy) => {
+		const resolvedAgentId = pickFirstExistingAgentId(input.cfg, agentId);
+		const sessionKey = buildAgentSessionKey({
+			agentId: resolvedAgentId,
+			channel,
+			accountId,
+			peer,
+			dmScope,
+			identityLinks
+		}).toLowerCase();
+		const mainSessionKey = buildAgentMainSessionKey({
+			agentId: resolvedAgentId,
+			mainKey: DEFAULT_MAIN_KEY
+		}).toLowerCase();
+		const route = {
+			agentId: resolvedAgentId,
+			channel,
+			accountId,
+			sessionKey,
+			mainSessionKey,
+			lastRoutePolicy: deriveLastRoutePolicy({
+				sessionKey,
+				mainSessionKey
+			}),
+			matchedBy
+		};
+		if (routeCache && routeCacheKey) {
+			routeCache.set(routeCacheKey, route);
+			if (routeCache.size > MAX_RESOLVED_ROUTE_CACHE_KEYS) {
+				routeCache.clear();
+				routeCache.set(routeCacheKey, route);
+			}
+		}
+		return route;
+	};
+	const formatPeer = (value) => value?.kind && value?.id ? `${value.kind}:${value.id}` : "none";
+	const formatNormalizedPeer = (value) => {
+		if (value.state === "none") return "none";
+		if (value.state === "invalid") return "invalid";
+		return `${value.kind}:${value.id}`;
+	};
+	if (shouldLogDebug) {
+		logDebug(`[routing] resolveAgentRoute: channel=${channel} accountId=${accountId} peer=${formatPeer(peer)} guildId=${guildId || "none"} teamId=${teamId || "none"} bindings=${bindings.length}`);
+		for (const entry of bindings) logDebug(`[routing] binding: agentId=${entry.binding.agentId} accountPattern=${entry.match.accountPattern || "default"} peer=${formatNormalizedPeer(entry.match.peer)} guildId=${entry.match.guildId ?? "none"} teamId=${entry.match.teamId ?? "none"} roles=${entry.match.roles?.length ?? 0}`);
+	}
+	const baseScope = {
+		guildId,
+		teamId,
+		memberRoleIds: memberRoleIdSet
+	};
+	const tiers = [
+		{
+			matchedBy: "binding.peer",
+			enabled: Boolean(peer),
+			scopePeer: peer,
+			candidates: collectPeerIndexedBindings(bindingsIndex, peer),
+			predicate: (candidate) => candidate.match.peer.state === "valid"
+		},
+		{
+			matchedBy: "binding.peer.parent",
+			enabled: Boolean(parentPeer && parentPeer.id),
+			scopePeer: parentPeer && parentPeer.id ? parentPeer : null,
+			candidates: collectPeerIndexedBindings(bindingsIndex, parentPeer),
+			predicate: (candidate) => candidate.match.peer.state === "valid"
+		},
+		{
+			matchedBy: "binding.guild+roles",
+			enabled: Boolean(guildId && memberRoleIds.length > 0),
+			scopePeer: peer,
+			candidates: guildId ? bindingsIndex.byGuildWithRoles.get(guildId) ?? [] : [],
+			predicate: (candidate) => hasGuildConstraint(candidate.match) && hasRolesConstraint(candidate.match)
+		},
+		{
+			matchedBy: "binding.guild",
+			enabled: Boolean(guildId),
+			scopePeer: peer,
+			candidates: guildId ? bindingsIndex.byGuild.get(guildId) ?? [] : [],
+			predicate: (candidate) => hasGuildConstraint(candidate.match) && !hasRolesConstraint(candidate.match)
+		},
+		{
+			matchedBy: "binding.team",
+			enabled: Boolean(teamId),
+			scopePeer: peer,
+			candidates: teamId ? bindingsIndex.byTeam.get(teamId) ?? [] : [],
+			predicate: (candidate) => hasTeamConstraint(candidate.match)
+		},
+		{
+			matchedBy: "binding.account",
+			enabled: true,
+			scopePeer: peer,
+			candidates: bindingsIndex.byAccount,
+			predicate: (candidate) => candidate.match.accountPattern !== "*"
+		},
+		{
+			matchedBy: "binding.channel",
+			enabled: true,
+			scopePeer: peer,
+			candidates: bindingsIndex.byChannel,
+			predicate: (candidate) => candidate.match.accountPattern === "*"
+		}
+	];
+	for (const tier of tiers) {
+		if (!tier.enabled) continue;
+		const matched = tier.candidates.find((candidate) => tier.predicate(candidate) && matchesBindingScope(candidate.match, {
+			...baseScope,
+			peer: tier.scopePeer
+		}));
+		if (matched) {
+			if (shouldLogDebug) logDebug(`[routing] match: matchedBy=${tier.matchedBy} agentId=${matched.binding.agentId}`);
+			return choose(matched.binding.agentId, tier.matchedBy);
+		}
+	}
+	return choose(resolveDefaultAgentId(input.cfg), "default");
+}
+//#endregion
+export { resolveInboundLastRouteSessionKey as a, resolveDefaultAgentBoundAccountId as c, resolveAgentRoute as i, resolvePreferredAccountId as l, deriveLastRoutePolicy as n, buildChannelAccountBindings as o, pickFirstExistingAgentId as r, listBoundAccountIds as s, buildAgentSessionKey as t, normalizeChatType as u };

package/dist/resolve-users-Bc6nRqpb.js

@@ -0,0 +1,143 @@
+import { $S as normalizeDiscordToken, _t as fetchDiscord, nt as normalizeDiscordSlug } from "./auth-profiles-C-Ul-Qkn.js";
+//#region extensions/discord/src/guilds.ts
+async function listGuilds(token, fetcher) {
+	return (await fetchDiscord("/users/@me/guilds", token, fetcher)).filter((guild) => typeof guild.id === "string" && typeof guild.name === "string").map((guild) => ({
+		id: guild.id,
+		name: guild.name,
+		slug: normalizeDiscordSlug(guild.name)
+	}));
+}
+//#endregion
+//#region extensions/discord/src/resolve-allowlist-common.ts
+function resolveDiscordAllowlistToken(token) {
+	return normalizeDiscordToken(token, "channels.discord.token");
+}
+function buildDiscordUnresolvedResults(entries, buildResult) {
+	return entries.map((input) => buildResult(input));
+}
+function findDiscordGuildByName(guilds, input) {
+	const slug = normalizeDiscordSlug(input);
+	if (!slug) return;
+	return guilds.find((guild) => guild.slug === slug);
+}
+function filterDiscordGuilds(guilds, params) {
+	if (params.guildId) return guilds.filter((guild) => guild.id === params.guildId);
+	if (params.guildName) {
+		const match = findDiscordGuildByName(guilds, params.guildName);
+		return match ? [match] : [];
+	}
+	return guilds;
+}
+//#endregion
+//#region extensions/discord/src/resolve-users.ts
+function parseDiscordUserInput(raw) {
+	const trimmed = raw.trim();
+	if (!trimmed) return {};
+	const mention = trimmed.match(/^<@!?(\d+)>$/);
+	if (mention) return { userId: mention[1] };
+	const prefixed = trimmed.match(/^(?:user:|discord:)?(\d+)$/i);
+	if (prefixed) return { userId: prefixed[1] };
+	const split = trimmed.includes("/") ? trimmed.split("/") : trimmed.split("#");
+	if (split.length >= 2) {
+		const guild = split[0]?.trim();
+		const user = split.slice(1).join("#").trim();
+		if (guild && /^\d+$/.test(guild)) return {
+			guildId: guild,
+			userName: user
+		};
+		return {
+			guildName: guild,
+			userName: user
+		};
+	}
+	return { userName: trimmed.replace(/^@/, "") };
+}
+function scoreDiscordMember(member, query) {
+	const q = query.toLowerCase();
+	const user = member.user;
+	const candidates = [
+		user.username,
+		user.global_name,
+		member.nick ?? void 0
+	].map((value) => value?.toLowerCase()).filter(Boolean);
+	let score = 0;
+	if (candidates.some((value) => value === q)) score += 3;
+	if (candidates.some((value) => value?.includes(q))) score += 1;
+	if (!user.bot) score += 1;
+	return score;
+}
+async function resolveDiscordUserAllowlist(params) {
+	const token = resolveDiscordAllowlistToken(params.token);
+	if (!token) return buildDiscordUnresolvedResults(params.entries, (input) => ({
+		input,
+		resolved: false
+	}));
+	const fetcher = params.fetcher ?? fetch;
+	let guilds = null;
+	const getGuilds = async () => {
+		if (!guilds) guilds = await listGuilds(token, fetcher);
+		return guilds;
+	};
+	const results = [];
+	for (const input of params.entries) {
+		const parsed = parseDiscordUserInput(input);
+		if (parsed.userId) {
+			results.push({
+				input,
+				resolved: true,
+				id: parsed.userId
+			});
+			continue;
+		}
+		const query = parsed.userName?.trim();
+		if (!query) {
+			results.push({
+				input,
+				resolved: false
+			});
+			continue;
+		}
+		const guildList = filterDiscordGuilds(await getGuilds(), {
+			guildId: parsed.guildId,
+			guildName: parsed.guildName?.trim()
+		});
+		let best = null;
+		let matches = 0;
+		for (const guild of guildList) {
+			const paramsObj = new URLSearchParams({
+				query,
+				limit: "25"
+			});
+			const members = await fetchDiscord(`/guilds/${guild.id}/members/search?${paramsObj.toString()}`, token, fetcher);
+			for (const member of members) {
+				const score = scoreDiscordMember(member, query);
+				if (score === 0) continue;
+				matches += 1;
+				if (!best || score > best.score) best = {
+					member,
+					guild,
+					score
+				};
+			}
+		}
+		if (best) {
+			const user = best.member.user;
+			const name = best.member.nick?.trim() || user.global_name?.trim() || user.username?.trim() || void 0;
+			results.push({
+				input,
+				resolved: true,
+				id: user.id,
+				name,
+				guildId: best.guild.id,
+				guildName: best.guild.name,
+				note: matches > 1 ? "multiple matches; chose best" : void 0
+			});
+		} else results.push({
+			input,
+			resolved: false
+		});
+	}
+	return results;
+}
+//#endregion
+export { listGuilds as a, resolveDiscordAllowlistToken as i, buildDiscordUnresolvedResults as n, filterDiscordGuilds as r, resolveDiscordUserAllowlist as t };