@vibe-lark/larkpal 0.1.84 → 0.1.86

package/dist/google-vertex-BsVLJrrC.mjs

@@ -0,0 +1,358 @@
+import { r as calculateCost, t as AssistantMessageEventStream } from "./event-stream-xaQWmyas.mjs";
+import { a as sanitizeSurrogates, i as clampReasoning, r as buildBaseOptions } from "./transform-messages-DbhIzTxq.mjs";
+import { c as GoogleGenAI, i as mapStopReason, l as ThinkingLevel, n as convertTools, o as mapToolChoice, r as isThinkingPart, s as retainThoughtSignature, t as convertMessages } from "./google-shared-BsWgwEk1.mjs";
+//#region node_modules/.pnpm/@mariozechner+pi-ai@0.69.0_@modelcontextprotocol+sdk@1.29.0_zod@4.3.6__ws@8.21.0_zod@4.3.6/node_modules/@mariozechner/pi-ai/dist/providers/google-vertex.js
+const API_VERSION = "v1";
+const GCP_VERTEX_CREDENTIALS_MARKER = "gcp-vertex-credentials";
+const THINKING_LEVEL_MAP = {
+	THINKING_LEVEL_UNSPECIFIED: ThinkingLevel.THINKING_LEVEL_UNSPECIFIED,
+	MINIMAL: ThinkingLevel.MINIMAL,
+	LOW: ThinkingLevel.LOW,
+	MEDIUM: ThinkingLevel.MEDIUM,
+	HIGH: ThinkingLevel.HIGH
+};
+let toolCallCounter = 0;
+const streamGoogleVertex = (model, context, options) => {
+	const stream = new AssistantMessageEventStream();
+	(async () => {
+		const output = {
+			role: "assistant",
+			content: [],
+			api: "google-vertex",
+			provider: model.provider,
+			model: model.id,
+			usage: {
+				input: 0,
+				output: 0,
+				cacheRead: 0,
+				cacheWrite: 0,
+				totalTokens: 0,
+				cost: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+					total: 0
+				}
+			},
+			stopReason: "stop",
+			timestamp: Date.now()
+		};
+		try {
+			const apiKey = resolveApiKey(options);
+			const client = apiKey ? createClientWithApiKey(model, apiKey, options?.headers) : createClient(model, resolveProject(options), resolveLocation(options), options?.headers);
+			let params = buildParams(model, context, options);
+			const nextParams = await options?.onPayload?.(params, model);
+			if (nextParams !== void 0) params = nextParams;
+			const googleStream = await client.models.generateContentStream(params);
+			stream.push({
+				type: "start",
+				partial: output
+			});
+			let currentBlock = null;
+			const blocks = output.content;
+			const blockIndex = () => blocks.length - 1;
+			for await (const chunk of googleStream) {
+				output.responseId ||= chunk.responseId;
+				const candidate = chunk.candidates?.[0];
+				if (candidate?.content?.parts) for (const part of candidate.content.parts) {
+					if (part.text !== void 0) {
+						const isThinking = isThinkingPart(part);
+						if (!currentBlock || isThinking && currentBlock.type !== "thinking" || !isThinking && currentBlock.type !== "text") {
+							if (currentBlock) if (currentBlock.type === "text") stream.push({
+								type: "text_end",
+								contentIndex: blocks.length - 1,
+								content: currentBlock.text,
+								partial: output
+							});
+							else stream.push({
+								type: "thinking_end",
+								contentIndex: blockIndex(),
+								content: currentBlock.thinking,
+								partial: output
+							});
+							if (isThinking) {
+								currentBlock = {
+									type: "thinking",
+									thinking: "",
+									thinkingSignature: void 0
+								};
+								output.content.push(currentBlock);
+								stream.push({
+									type: "thinking_start",
+									contentIndex: blockIndex(),
+									partial: output
+								});
+							} else {
+								currentBlock = {
+									type: "text",
+									text: ""
+								};
+								output.content.push(currentBlock);
+								stream.push({
+									type: "text_start",
+									contentIndex: blockIndex(),
+									partial: output
+								});
+							}
+						}
+						if (currentBlock.type === "thinking") {
+							currentBlock.thinking += part.text;
+							currentBlock.thinkingSignature = retainThoughtSignature(currentBlock.thinkingSignature, part.thoughtSignature);
+							stream.push({
+								type: "thinking_delta",
+								contentIndex: blockIndex(),
+								delta: part.text,
+								partial: output
+							});
+						} else {
+							currentBlock.text += part.text;
+							currentBlock.textSignature = retainThoughtSignature(currentBlock.textSignature, part.thoughtSignature);
+							stream.push({
+								type: "text_delta",
+								contentIndex: blockIndex(),
+								delta: part.text,
+								partial: output
+							});
+						}
+					}
+					if (part.functionCall) {
+						if (currentBlock) {
+							if (currentBlock.type === "text") stream.push({
+								type: "text_end",
+								contentIndex: blockIndex(),
+								content: currentBlock.text,
+								partial: output
+							});
+							else stream.push({
+								type: "thinking_end",
+								contentIndex: blockIndex(),
+								content: currentBlock.thinking,
+								partial: output
+							});
+							currentBlock = null;
+						}
+						const providedId = part.functionCall.id;
+						const toolCall = {
+							type: "toolCall",
+							id: !providedId || output.content.some((b) => b.type === "toolCall" && b.id === providedId) ? `${part.functionCall.name}_${Date.now()}_${++toolCallCounter}` : providedId,
+							name: part.functionCall.name || "",
+							arguments: part.functionCall.args ?? {},
+							...part.thoughtSignature && { thoughtSignature: part.thoughtSignature }
+						};
+						output.content.push(toolCall);
+						stream.push({
+							type: "toolcall_start",
+							contentIndex: blockIndex(),
+							partial: output
+						});
+						stream.push({
+							type: "toolcall_delta",
+							contentIndex: blockIndex(),
+							delta: JSON.stringify(toolCall.arguments),
+							partial: output
+						});
+						stream.push({
+							type: "toolcall_end",
+							contentIndex: blockIndex(),
+							toolCall,
+							partial: output
+						});
+					}
+				}
+				if (candidate?.finishReason) {
+					output.stopReason = mapStopReason(candidate.finishReason);
+					if (output.content.some((b) => b.type === "toolCall")) output.stopReason = "toolUse";
+				}
+				if (chunk.usageMetadata) {
+					output.usage = {
+						input: (chunk.usageMetadata.promptTokenCount || 0) - (chunk.usageMetadata.cachedContentTokenCount || 0),
+						output: (chunk.usageMetadata.candidatesTokenCount || 0) + (chunk.usageMetadata.thoughtsTokenCount || 0),
+						cacheRead: chunk.usageMetadata.cachedContentTokenCount || 0,
+						cacheWrite: 0,
+						totalTokens: chunk.usageMetadata.totalTokenCount || 0,
+						cost: {
+							input: 0,
+							output: 0,
+							cacheRead: 0,
+							cacheWrite: 0,
+							total: 0
+						}
+					};
+					calculateCost(model, output.usage);
+				}
+			}
+			if (currentBlock) if (currentBlock.type === "text") stream.push({
+				type: "text_end",
+				contentIndex: blockIndex(),
+				content: currentBlock.text,
+				partial: output
+			});
+			else stream.push({
+				type: "thinking_end",
+				contentIndex: blockIndex(),
+				content: currentBlock.thinking,
+				partial: output
+			});
+			if (options?.signal?.aborted) throw new Error("Request was aborted");
+			if (output.stopReason === "aborted" || output.stopReason === "error") throw new Error("An unknown error occurred");
+			stream.push({
+				type: "done",
+				reason: output.stopReason,
+				message: output
+			});
+			stream.end();
+		} catch (error) {
+			for (const block of output.content) if ("index" in block) delete block.index;
+			output.stopReason = options?.signal?.aborted ? "aborted" : "error";
+			output.errorMessage = error instanceof Error ? error.message : JSON.stringify(error);
+			stream.push({
+				type: "error",
+				reason: output.stopReason,
+				error: output
+			});
+			stream.end();
+		}
+	})();
+	return stream;
+};
+const streamSimpleGoogleVertex = (model, context, options) => {
+	const base = buildBaseOptions(model, options, void 0);
+	if (!options?.reasoning) return streamGoogleVertex(model, context, {
+		...base,
+		thinking: { enabled: false }
+	});
+	const effort = clampReasoning(options.reasoning);
+	const geminiModel = model;
+	if (isGemini3ProModel(geminiModel) || isGemini3FlashModel(geminiModel)) return streamGoogleVertex(model, context, {
+		...base,
+		thinking: {
+			enabled: true,
+			level: getGemini3ThinkingLevel(effort, geminiModel)
+		}
+	});
+	return streamGoogleVertex(model, context, {
+		...base,
+		thinking: {
+			enabled: true,
+			budgetTokens: getGoogleBudget(geminiModel, effort, options.thinkingBudgets)
+		}
+	});
+};
+function createClient(model, project, location, optionsHeaders) {
+	const httpOptions = {};
+	if (model.headers || optionsHeaders) httpOptions.headers = {
+		...model.headers,
+		...optionsHeaders
+	};
+	return new GoogleGenAI({
+		vertexai: true,
+		project,
+		location,
+		apiVersion: API_VERSION,
+		httpOptions: Object.values(httpOptions).some(Boolean) ? httpOptions : void 0
+	});
+}
+function createClientWithApiKey(model, apiKey, optionsHeaders) {
+	const httpOptions = {};
+	if (model.headers || optionsHeaders) httpOptions.headers = {
+		...model.headers,
+		...optionsHeaders
+	};
+	return new GoogleGenAI({
+		vertexai: true,
+		apiKey,
+		apiVersion: API_VERSION,
+		httpOptions: Object.values(httpOptions).some(Boolean) ? httpOptions : void 0
+	});
+}
+function resolveApiKey(options) {
+	const apiKey = options?.apiKey?.trim() || process.env.GOOGLE_CLOUD_API_KEY?.trim();
+	if (!apiKey || apiKey === GCP_VERTEX_CREDENTIALS_MARKER || isPlaceholderApiKey(apiKey)) return;
+	return apiKey;
+}
+function isPlaceholderApiKey(apiKey) {
+	return /^<[^>]+>$/.test(apiKey);
+}
+function resolveProject(options) {
+	const project = options?.project || process.env.GOOGLE_CLOUD_PROJECT || process.env.GCLOUD_PROJECT;
+	if (!project) throw new Error("Vertex AI requires a project ID. Set GOOGLE_CLOUD_PROJECT/GCLOUD_PROJECT or pass project in options.");
+	return project;
+}
+function resolveLocation(options) {
+	const location = options?.location || process.env.GOOGLE_CLOUD_LOCATION;
+	if (!location) throw new Error("Vertex AI requires a location. Set GOOGLE_CLOUD_LOCATION or pass location in options.");
+	return location;
+}
+function buildParams(model, context, options = {}) {
+	const contents = convertMessages(model, context);
+	const generationConfig = {};
+	if (options.temperature !== void 0) generationConfig.temperature = options.temperature;
+	if (options.maxTokens !== void 0) generationConfig.maxOutputTokens = options.maxTokens;
+	const config = {
+		...Object.keys(generationConfig).length > 0 && generationConfig,
+		...context.systemPrompt && { systemInstruction: sanitizeSurrogates(context.systemPrompt) },
+		...context.tools && context.tools.length > 0 && { tools: convertTools(context.tools) }
+	};
+	if (context.tools && context.tools.length > 0 && options.toolChoice) config.toolConfig = { functionCallingConfig: { mode: mapToolChoice(options.toolChoice) } };
+	else config.toolConfig = void 0;
+	if (options.thinking?.enabled && model.reasoning) {
+		const thinkingConfig = { includeThoughts: true };
+		if (options.thinking.level !== void 0) thinkingConfig.thinkingLevel = THINKING_LEVEL_MAP[options.thinking.level];
+		else if (options.thinking.budgetTokens !== void 0) thinkingConfig.thinkingBudget = options.thinking.budgetTokens;
+		config.thinkingConfig = thinkingConfig;
+	} else if (model.reasoning && options.thinking && !options.thinking.enabled) config.thinkingConfig = getDisabledThinkingConfig(model);
+	if (options.signal) {
+		if (options.signal.aborted) throw new Error("Request aborted");
+		config.abortSignal = options.signal;
+	}
+	return {
+		model: model.id,
+		contents,
+		config
+	};
+}
+function isGemini3ProModel(model) {
+	return /gemini-3(?:\.\d+)?-pro/.test(model.id.toLowerCase());
+}
+function isGemini3FlashModel(model) {
+	return /gemini-3(?:\.\d+)?-flash/.test(model.id.toLowerCase());
+}
+function getDisabledThinkingConfig(model) {
+	const geminiModel = model;
+	if (isGemini3ProModel(geminiModel)) return { thinkingLevel: ThinkingLevel.LOW };
+	if (isGemini3FlashModel(geminiModel)) return { thinkingLevel: ThinkingLevel.MINIMAL };
+	return { thinkingBudget: 0 };
+}
+function getGemini3ThinkingLevel(effort, model) {
+	if (isGemini3ProModel(model)) switch (effort) {
+		case "minimal":
+		case "low": return "LOW";
+		case "medium":
+		case "high": return "HIGH";
+	}
+	switch (effort) {
+		case "minimal": return "MINIMAL";
+		case "low": return "LOW";
+		case "medium": return "MEDIUM";
+		case "high": return "HIGH";
+	}
+}
+function getGoogleBudget(model, effort, customBudgets) {
+	if (customBudgets?.[effort] !== void 0) return customBudgets[effort];
+	if (model.id.includes("2.5-pro")) return {
+		minimal: 128,
+		low: 2048,
+		medium: 8192,
+		high: 32768
+	}[effort];
+	if (model.id.includes("2.5-flash")) return {
+		minimal: 128,
+		low: 2048,
+		medium: 8192,
+		high: 24576
+	}[effort];
+	return -1;
+}
+//#endregion
+export { streamGoogleVertex, streamSimpleGoogleVertex };

package/dist/hash-DAFtW_W7.mjs

@@ -0,0 +1,16 @@
+//#region node_modules/.pnpm/@mariozechner+pi-ai@0.69.0_@modelcontextprotocol+sdk@1.29.0_zod@4.3.6__ws@8.21.0_zod@4.3.6/node_modules/@mariozechner/pi-ai/dist/utils/hash.js
+/** Fast deterministic hash to shorten long strings */
+function shortHash(str) {
+	let h1 = 3735928559;
+	let h2 = 1103547991;
+	for (let i = 0; i < str.length; i++) {
+		const ch = str.charCodeAt(i);
+		h1 = Math.imul(h1 ^ ch, 2654435761);
+		h2 = Math.imul(h2 ^ ch, 1597334677);
+	}
+	h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507) ^ Math.imul(h2 ^ h2 >>> 13, 3266489909);
+	h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507) ^ Math.imul(h1 ^ h1 >>> 13, 3266489909);
+	return (h2 >>> 0).toString(36) + (h1 >>> 0).toString(36);
+}
+//#endregion
+export { shortHash as t };

package/dist/headers-R3HdCbAE.mjs

@@ -0,0 +1,8 @@
+//#region node_modules/.pnpm/@mariozechner+pi-ai@0.69.0_@modelcontextprotocol+sdk@1.29.0_zod@4.3.6__ws@8.21.0_zod@4.3.6/node_modules/@mariozechner/pi-ai/dist/utils/headers.js
+function headersToRecord(headers) {
+	const result = {};
+	for (const [key, value] of headers.entries()) result[key] = value;
+	return result;
+}
+//#endregion
+export { headersToRecord as t };

package/dist/home-dir-C44RaPME-CBRS4HLP.mjs

@@ -0,0 +1,93 @@
+import path from "node:path";
+import os from "node:os";
+//#region node_modules/.pnpm/openclaw@2026.4.22_@napi-rs+canvas@0.1.99/node_modules/openclaw/dist/string-coerce-CjxCKZ6B.js
+function readStringValue(value) {
+	return typeof value === "string" ? value : void 0;
+}
+function normalizeNullableString(value) {
+	if (typeof value !== "string") return null;
+	const trimmed = value.trim();
+	return trimmed ? trimmed : null;
+}
+function normalizeOptionalString(value) {
+	return normalizeNullableString(value) ?? void 0;
+}
+function normalizeStringifiedOptionalString(value) {
+	if (typeof value === "string") return normalizeOptionalString(value);
+	if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") return normalizeOptionalString(String(value));
+}
+function normalizeOptionalLowercaseString(value) {
+	return normalizeOptionalString(value)?.toLowerCase();
+}
+function normalizeLowercaseStringOrEmpty(value) {
+	return normalizeOptionalLowercaseString(value) ?? "";
+}
+function normalizeOptionalThreadValue(value) {
+	if (typeof value === "number") return Number.isFinite(value) ? Math.trunc(value) : void 0;
+	return normalizeOptionalString(value);
+}
+function hasNonEmptyString(value) {
+	return normalizeOptionalString(value) !== void 0;
+}
+//#endregion
+//#region node_modules/.pnpm/openclaw@2026.4.22_@napi-rs+canvas@0.1.99/node_modules/openclaw/dist/home-dir-C44RaPME.js
+function normalize(value) {
+	const trimmed = normalizeOptionalString(value);
+	if (!trimmed) return;
+	if (trimmed === "undefined" || trimmed === "null") return;
+	return trimmed;
+}
+function resolveEffectiveHomeDir(env = process.env, homedir = os.homedir) {
+	const raw = resolveRawHomeDir(env, homedir);
+	return raw ? path.resolve(raw) : void 0;
+}
+function resolveRawHomeDir(env, homedir) {
+	const explicitHome = normalize(env.OPENCLAW_HOME);
+	if (explicitHome) {
+		if (explicitHome === "~" || explicitHome.startsWith("~/") || explicitHome.startsWith("~\\")) {
+			const fallbackHome = resolveRawOsHomeDir(env, homedir);
+			if (fallbackHome) return explicitHome.replace(/^~(?=$|[\\/])/, fallbackHome);
+			return;
+		}
+		return explicitHome;
+	}
+	return resolveRawOsHomeDir(env, homedir);
+}
+function resolveRawOsHomeDir(env, homedir) {
+	const envHome = normalize(env.HOME);
+	if (envHome) return envHome;
+	const userProfile = normalize(env.USERPROFILE);
+	if (userProfile) return userProfile;
+	return normalizeSafe(homedir);
+}
+function normalizeSafe(homedir) {
+	try {
+		return normalize(homedir());
+	} catch {
+		return;
+	}
+}
+function resolveRequiredHomeDir(env = process.env, homedir = os.homedir) {
+	return resolveEffectiveHomeDir(env, homedir) ?? path.resolve(process.cwd());
+}
+function expandHomePrefix(input, opts) {
+	if (!input.startsWith("~")) return input;
+	const home = normalize(opts?.home) ?? resolveEffectiveHomeDir(opts?.env ?? process.env, opts?.homedir ?? os.homedir);
+	if (!home) return input;
+	return input.replace(/^~(?=$|[\\/])/, home);
+}
+function resolveHomeRelativePath(input, opts) {
+	const trimmed = input.trim();
+	if (!trimmed) return trimmed;
+	if (trimmed.startsWith("~")) {
+		const expanded = expandHomePrefix(trimmed, {
+			home: resolveRequiredHomeDir(opts?.env ?? process.env, opts?.homedir ?? os.homedir),
+			env: opts?.env,
+			homedir: opts?.homedir
+		});
+		return path.resolve(expanded);
+	}
+	return path.resolve(trimmed);
+}
+//#endregion
+export { hasNonEmptyString as a, normalizeOptionalString as c, readStringValue as d, resolveRequiredHomeDir as i, normalizeOptionalThreadValue as l, resolveEffectiveHomeDir as n, normalizeLowercaseStringOrEmpty as o, resolveHomeRelativePath as r, normalizeOptionalLowercaseString as s, expandHomePrefix as t, normalizeStringifiedOptionalString as u };

package/dist/ids-BPsM98Uu-CwuxvUai.mjs

@@ -0,0 +1,77 @@
+import { s as normalizeOptionalLowercaseString } from "./home-dir-C44RaPME-CBRS4HLP.mjs";
+import { n as resolveOpenClawPackageRootSync, t as resolveBundledPluginsDir } from "./bundled-dir-U738ay4K-DXK0q_TV.mjs";
+import fs from "node:fs";
+import path from "node:path";
+//#region node_modules/.pnpm/openclaw@2026.4.22_@napi-rs+canvas@0.1.99/node_modules/openclaw/dist/ids-BPsM98Uu.js
+const OFFICIAL_CHANNEL_CATALOG_RELATIVE_PATH = path.join("dist", "channel-catalog.json");
+function listPackageRoots() {
+	return [resolveOpenClawPackageRootSync({ cwd: process.cwd() }), resolveOpenClawPackageRootSync({ moduleUrl: import.meta.url })].filter((entry, index, all) => Boolean(entry) && all.indexOf(entry) === index);
+}
+function listBundledExtensionPackageJsonPaths(env = process.env) {
+	const extensionsRoot = resolveBundledPluginsDir(env);
+	if (!extensionsRoot) return [];
+	try {
+		return fs.readdirSync(extensionsRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => path.join(extensionsRoot, entry.name, "package.json")).filter((entry) => fs.existsSync(entry));
+	} catch {
+		return [];
+	}
+}
+function readBundledExtensionCatalogEntriesSync() {
+	const entries = [];
+	for (const packageJsonPath of listBundledExtensionPackageJsonPaths()) try {
+		const payload = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+		entries.push(payload);
+	} catch {
+		continue;
+	}
+	return entries;
+}
+function readOfficialCatalogFileSync() {
+	for (const packageRoot of listPackageRoots()) {
+		const candidate = path.join(packageRoot, OFFICIAL_CHANNEL_CATALOG_RELATIVE_PATH);
+		if (!fs.existsSync(candidate)) continue;
+		try {
+			const payload = JSON.parse(fs.readFileSync(candidate, "utf8"));
+			return Array.isArray(payload.entries) ? payload.entries : [];
+		} catch {
+			continue;
+		}
+	}
+	return [];
+}
+function toBundledChannelEntry(entry) {
+	const channel = entry.openclaw?.channel;
+	const id = normalizeOptionalLowercaseString(channel?.id);
+	if (!id || !channel) return null;
+	return {
+		id,
+		channel,
+		aliases: Array.isArray(channel.aliases) ? channel.aliases.map((alias) => normalizeOptionalLowercaseString(alias)).filter((alias) => Boolean(alias)) : [],
+		order: typeof channel.order === "number" && Number.isFinite(channel.order) ? channel.order : Number.MAX_SAFE_INTEGER
+	};
+}
+function listBundledChannelCatalogEntries() {
+	const bundledEntries = readBundledExtensionCatalogEntriesSync().map((entry) => toBundledChannelEntry(entry)).filter((entry) => Boolean(entry));
+	if (bundledEntries.length > 0) return bundledEntries;
+	return readOfficialCatalogFileSync().map((entry) => toBundledChannelEntry(entry)).filter((entry) => Boolean(entry));
+}
+function listBundledChatChannelEntries() {
+	return listBundledChannelCatalogEntries().map((entry) => ({
+		id: normalizeOptionalLowercaseString(entry.id) ?? entry.id,
+		aliases: entry.aliases,
+		order: entry.order
+	})).toSorted((left, right) => left.order - right.order || left.id.localeCompare(right.id, "en", { sensitivity: "base" }));
+}
+const BUNDLED_CHAT_CHANNEL_ENTRIES = Object.freeze(listBundledChatChannelEntries());
+const CHAT_CHANNEL_ID_SET = new Set(BUNDLED_CHAT_CHANNEL_ENTRIES.map((entry) => entry.id));
+const CHAT_CHANNEL_ORDER = Object.freeze(BUNDLED_CHAT_CHANNEL_ENTRIES.map((entry) => entry.id));
+const CHANNEL_IDS = CHAT_CHANNEL_ORDER;
+const CHAT_CHANNEL_ALIASES = Object.freeze(Object.fromEntries(BUNDLED_CHAT_CHANNEL_ENTRIES.flatMap((entry) => entry.aliases.map((alias) => [alias, entry.id]))));
+function normalizeChatChannelId(raw) {
+	const normalized = normalizeOptionalLowercaseString(raw);
+	if (!normalized) return null;
+	const resolved = CHAT_CHANNEL_ALIASES[normalized] ?? normalized;
+	return CHAT_CHANNEL_ID_SET.has(resolved) ? resolved : null;
+}
+//#endregion
+export { normalizeChatChannelId as i, CHAT_CHANNEL_ORDER as n, listBundledChannelCatalogEntries as r, CHANNEL_IDS as t };