@spacebar_ai/moldclaw-core 2026.3.41 → 2026.3.44

package/dist/resolve-route-CSHDsa_m.js

@@ -1,538 +0,0 @@
-import { l as shouldLogVerbose } from "./globals-DESrFYmC.js";
-import { m as resolveDefaultAgentId } from "./agent-scope-C-YmLnnb.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-BG6HaSR5.js

@@ -1,143 +0,0 @@
-import { $S as normalizeDiscordToken, _t as fetchDiscord, nt as normalizeDiscordSlug } from "./auth-profiles-1kPLbBwI.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 };