silentlake 2026.3.24

package/dist/resolve-route-vEY3ONZ2.js

@@ -0,0 +1,466 @@
+import { l as shouldLogVerbose } from "./globals-41sdSaKv.js";
+import { c as normalizeAgentId, f as sanitizeAgentId, i as buildAgentPeerSessionKey, n as DEFAULT_MAIN_KEY, r as buildAgentMainSessionKey } from "./session-key-gFFk3uv9.js";
+import { n as normalizeAccountId, t as DEFAULT_ACCOUNT_ID } from "./account-id-ZCrgXl7Z.js";
+import { t as logDebug } from "./logger-Cqy7-Maj.js";
+import { m as resolveDefaultAgentId } from "./agent-scope-DPP4Z_UU.js";
+import { t as normalizeChatType } from "./chat-type-C-n03mQY.js";
+import { n as listBindings } from "./bindings-kjwuC11Q.js";
+//#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, resolveAgentRoute as i, deriveLastRoutePolicy as n, pickFirstExistingAgentId as r, buildAgentSessionKey as t };

package/dist/resolve-utils-CbqJY2bs.js

@@ -0,0 +1,102 @@
+import { t as summarizeStringEntries } from "./string-sample-BOLqzr4Y.js";
+import { d as mapAllowFromEntries } from "./channel-config-helpers-CieQWILI.js";
+//#region src/channels/allowlists/resolve-utils.ts
+function dedupeAllowlistEntries(entries) {
+	const seen = /* @__PURE__ */ new Set();
+	const deduped = [];
+	for (const entry of entries) {
+		const normalized = entry.trim();
+		if (!normalized) continue;
+		const key = normalized.toLowerCase();
+		if (seen.has(key)) continue;
+		seen.add(key);
+		deduped.push(normalized);
+	}
+	return deduped;
+}
+function mergeAllowlist(params) {
+	return dedupeAllowlistEntries([...mapAllowFromEntries(params.existing), ...params.additions]);
+}
+function buildAllowlistResolutionSummary(resolvedUsers, opts) {
+	const resolvedMap = new Map(resolvedUsers.map((entry) => [entry.input, entry]));
+	const resolvedOk = (entry) => Boolean(entry.resolved && entry.id);
+	const formatResolved = opts?.formatResolved ?? ((entry) => `${entry.input}→${entry.id}`);
+	const formatUnresolved = opts?.formatUnresolved ?? ((entry) => entry.input);
+	const mapping = resolvedUsers.filter(resolvedOk).map(formatResolved);
+	const additions = resolvedUsers.filter(resolvedOk).map((entry) => entry.id).filter((entry) => Boolean(entry));
+	return {
+		resolvedMap,
+		mapping,
+		unresolved: resolvedUsers.filter((entry) => !resolvedOk(entry)).map(formatUnresolved),
+		additions
+	};
+}
+function resolveAllowlistIdAdditions(params) {
+	const additions = [];
+	for (const entry of params.existing) {
+		const trimmed = String(entry).trim();
+		const resolved = params.resolvedMap.get(trimmed);
+		if (resolved?.resolved && resolved.id) additions.push(resolved.id);
+	}
+	return additions;
+}
+function canonicalizeAllowlistWithResolvedIds(params) {
+	const canonicalized = [];
+	for (const entry of params.existing ?? []) {
+		const trimmed = String(entry).trim();
+		if (!trimmed) continue;
+		if (trimmed === "*") {
+			canonicalized.push(trimmed);
+			continue;
+		}
+		const resolved = params.resolvedMap.get(trimmed);
+		canonicalized.push(resolved?.resolved && resolved.id ? resolved.id : trimmed);
+	}
+	return dedupeAllowlistEntries(canonicalized);
+}
+function patchAllowlistUsersInConfigEntries(params) {
+	const nextEntries = { ...params.entries };
+	for (const [entryKey, entryConfig] of Object.entries(params.entries)) {
+		if (!entryConfig || typeof entryConfig !== "object") continue;
+		const users = entryConfig.users;
+		if (!Array.isArray(users) || users.length === 0) continue;
+		const resolvedUsers = params.strategy === "canonicalize" ? canonicalizeAllowlistWithResolvedIds({
+			existing: users,
+			resolvedMap: params.resolvedMap
+		}) : mergeAllowlist({
+			existing: users,
+			additions: resolveAllowlistIdAdditions({
+				existing: users,
+				resolvedMap: params.resolvedMap
+			})
+		});
+		nextEntries[entryKey] = {
+			...entryConfig,
+			users: resolvedUsers
+		};
+	}
+	return nextEntries;
+}
+function addAllowlistUserEntriesFromConfigEntry(target, entry) {
+	if (!entry || typeof entry !== "object") return;
+	const users = entry.users;
+	if (!Array.isArray(users)) return;
+	for (const value of users) {
+		const trimmed = String(value).trim();
+		if (trimmed && trimmed !== "*") target.add(trimmed);
+	}
+}
+function summarizeMapping(label, mapping, unresolved, runtime) {
+	const lines = [];
+	if (mapping.length > 0) lines.push(`${label} resolved: ${summarizeStringEntries({
+		entries: mapping,
+		limit: 6
+	})}`);
+	if (unresolved.length > 0) lines.push(`${label} unresolved: ${summarizeStringEntries({
+		entries: unresolved,
+		limit: 6
+	})}`);
+	if (lines.length > 0) runtime.log?.(lines.join("\n"));
+}
+//#endregion
+export { patchAllowlistUsersInConfigEntries as a, mergeAllowlist as i, buildAllowlistResolutionSummary as n, summarizeMapping as o, canonicalizeAllowlistWithResolvedIds as r, addAllowlistUserEntriesFromConfigEntry as t };