@gaodefa/daocore 2026.5.71 → 2026.5.72

package/dist/channel-runtime-q-dxKXrY.js

@@ -0,0 +1,408 @@
+import { a as normalizeLowercaseStringOrEmpty, c as normalizeOptionalString } from "./string-coerce-DyL154ka.js";
+import { s as normalizeStringEntries } from "./string-normalization-DiPHgdft.js";
+import { r as deliverFormattedTextWithAttachments } from "./reply-payload-DMPQsrQC.js";
+import { c as defineStableChannelIngressIdentity, n as createChannelIngressResolver, t as channelIngressRoutes } from "./runtime-W39pAdFK.js";
+import { a as warnMissingProviderGroupPolicyFallbackOnce, n as resolveAllowlistProviderRuntimeGroupPolicy, r as resolveDefaultGroupPolicy, t as GROUP_POLICY_BLOCKED_LABEL } from "./runtime-group-policy-CmZDlIwd.js";
+import "./string-coerce-runtime-DcopKqDR.js";
+import { n as isDangerousNameMatchingEnabled } from "./dangerous-name-matching-jjAiM0PK.js";
+import { r as resolveInboundRouteEnvelopeBuilderWithRuntime } from "./inbound-envelope-DF4N8x5q.js";
+import { m as resolveLoggerBackedRuntime } from "./extension-shared-D6I0yOLZ.js";
+import { n as logInboundDrop } from "./logging-Dr3f0mtP.js";
+import "./channel-inbound-uMq3GVE_.js";
+import "./channel-ingress-runtime-BZvnfysR.js";
+import { n as createChannelPairingController } from "./channel-pairing-BQeyBt0a.js";
+import { a as isChannelTarget, d as makeIrcMessageId, h as resolveIrcAccount, i as buildIrcAllowlistCandidates, l as buildIrcConnectOptions, n as resolveIrcRequireMention, r as sendMessageIrc, s as normalizeIrcAllowEntry, t as resolveIrcGroupMatch, u as connectIrcClient } from "./policy-Cn3795eI.js";
+import { t as getIrcRuntime } from "./runtime-CkVr7OX5.js";
+//#region extensions/irc/src/inbound.ts
+const CHANNEL_ID = "irc";
+const IRC_NICK_KIND = "plugin:irc-nick";
+const ircIngressIdentity = defineStableChannelIngressIdentity({
+	key: "irc-id",
+	normalizeEntry: normalizeIrcStableEntry,
+	normalizeSubject: normalizeLowercaseStringOrEmpty,
+	sensitivity: "pii",
+	aliases: [...["irc-id-nick-user", "irc-id-nick-host"].map((key) => ({
+		key,
+		kind: "stable-id",
+		normalizeEntry: () => null,
+		normalizeSubject: normalizeLowercaseStringOrEmpty,
+		sensitivity: "pii"
+	})), {
+		key: "irc-nick",
+		kind: IRC_NICK_KIND,
+		normalizeEntry: normalizeIrcNickEntry,
+		normalizeSubject: normalizeLowercaseStringOrEmpty,
+		dangerous: true,
+		sensitivity: "pii"
+	}],
+	isWildcardEntry: (entry) => normalizeIrcAllowEntry(entry) === "*",
+	resolveEntryId: ({ entryIndex, fieldKey }) => `irc-entry-${entryIndex + 1}:${fieldKey === "irc-nick" ? "nick" : "id"}`
+});
+const escapeIrcRegexLiteral = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function isBareNick(value) {
+	return !value.includes("!") && !value.includes("@");
+}
+function normalizeIrcStableEntry(value) {
+	const normalized = normalizeIrcAllowEntry(value);
+	if (!normalized || normalized === "*" || isBareNick(normalized)) return null;
+	return normalized;
+}
+function normalizeIrcNickEntry(value) {
+	const normalized = normalizeIrcAllowEntry(value);
+	if (!normalized || normalized === "*" || !isBareNick(normalized)) return null;
+	return normalized;
+}
+function hasEntries(entries) {
+	return normalizeStringEntries(entries).some((entry) => normalizeIrcAllowEntry(entry));
+}
+function createIrcIngressSubject(message) {
+	const stableCandidates = buildIrcAllowlistCandidates(message, { allowNameMatching: true }).filter((candidate) => !isBareNick(candidate));
+	const nick = normalizeLowercaseStringOrEmpty(message.senderNick);
+	return {
+		stableId: stableCandidates[stableCandidates.length - 1] ?? nick,
+		aliases: {
+			"irc-id-nick-user": stableCandidates.find((candidate) => candidate.includes("!") && !candidate.includes("@")),
+			"irc-id-nick-host": stableCandidates.find((candidate) => !candidate.includes("!") && candidate.includes("@")),
+			"irc-nick": nick
+		}
+	};
+}
+function routeDescriptorsForIrcGroup(params) {
+	if (!params.isGroup) return [];
+	return channelIngressRoutes(params.groupPolicy === "allowlist" && {
+		id: "irc:channel",
+		allowed: params.hasConfiguredGroups && params.groupAllowed,
+		precedence: 0,
+		matchId: "irc-channel",
+		blockReason: "channel_not_allowlisted"
+	}, !params.groupEnabled && {
+		id: "irc:channel-enabled",
+		enabled: false,
+		precedence: 10,
+		blockReason: "channel_disabled"
+	}, hasEntries(params.routeGroupAllowFrom) && {
+		id: "irc:channel-sender",
+		precedence: 20,
+		senderPolicy: "replace",
+		senderAllowFrom: params.routeGroupAllowFrom
+	});
+}
+async function deliverIrcReply(params) {
+	await deliverFormattedTextWithAttachments({
+		payload: params.payload,
+		send: async ({ text, replyToId }) => {
+			if (params.sendReply) await params.sendReply(params.target, text, replyToId);
+			else await sendMessageIrc(params.target, text, {
+				cfg: params.cfg,
+				accountId: params.accountId,
+				replyTo: replyToId
+			});
+			params.statusSink?.({ lastOutboundAt: Date.now() });
+		}
+	});
+}
+async function handleIrcInbound(params) {
+	const { message, account, config, runtime, connectedNick, statusSink } = params;
+	const core = getIrcRuntime();
+	const pairing = createChannelPairingController({
+		core,
+		channel: CHANNEL_ID,
+		accountId: account.accountId
+	});
+	const rawBody = message.text?.trim() ?? "";
+	if (!rawBody) return;
+	statusSink?.({ lastInboundAt: message.timestamp });
+	const senderDisplay = message.senderHost ? `${message.senderNick}!${message.senderUser ?? "?"}@${message.senderHost}` : message.senderNick;
+	const allowNameMatching = isDangerousNameMatchingEnabled(account.config);
+	const dmPolicy = account.config.dmPolicy ?? "pairing";
+	const defaultGroupPolicy = resolveDefaultGroupPolicy(config);
+	const { groupPolicy, providerMissingFallbackApplied } = resolveAllowlistProviderRuntimeGroupPolicy({
+		providerConfigPresent: config.channels?.irc !== void 0,
+		groupPolicy: account.config.groupPolicy,
+		defaultGroupPolicy
+	});
+	warnMissingProviderGroupPolicyFallbackOnce({
+		providerMissingFallbackApplied,
+		providerKey: "irc",
+		accountId: account.accountId,
+		blockedLabel: GROUP_POLICY_BLOCKED_LABEL.channel,
+		log: (message) => runtime.log?.(message)
+	});
+	const groupMatch = resolveIrcGroupMatch({
+		groups: account.config.groups,
+		target: message.target
+	});
+	const allowTextCommands = core.channel.commands.shouldHandleTextCommands({
+		cfg: config,
+		surface: CHANNEL_ID
+	});
+	const hasControlCommand = core.channel.text.hasControlCommand(rawBody, config);
+	const mentionRegexes = core.channel.mentions.buildMentionRegexes(config);
+	const mentionNick = connectedNick?.trim() || account.nick;
+	const explicitMentionRegex = mentionNick ? new RegExp(`\\b${escapeIrcRegexLiteral(mentionNick)}\\b[:,]?`, "i") : null;
+	const wasMentioned = core.channel.mentions.matchesMentionPatterns(rawBody, mentionRegexes) || (explicitMentionRegex ? explicitMentionRegex.test(rawBody) : false);
+	const requireMention = message.isGroup ? resolveIrcRequireMention({
+		groupConfig: groupMatch.groupConfig,
+		wildcardConfig: groupMatch.wildcardConfig
+	}) : false;
+	const routeGroupAllowFrom = normalizeStringEntries(groupMatch.groupConfig?.allowFrom?.length ? groupMatch.groupConfig.allowFrom : groupMatch.wildcardConfig?.allowFrom);
+	const accessGroupPolicy = groupPolicy === "open" && (hasEntries(account.config.groupAllowFrom) || hasEntries(routeGroupAllowFrom)) ? "allowlist" : groupPolicy;
+	const access = await createChannelIngressResolver({
+		channelId: CHANNEL_ID,
+		accountId: account.accountId,
+		identity: ircIngressIdentity,
+		cfg: config,
+		readStoreAllowFrom: async () => await pairing.readAllowFromStore()
+	}).message({
+		subject: createIrcIngressSubject(message),
+		conversation: {
+			kind: message.isGroup ? "group" : "direct",
+			id: message.target
+		},
+		route: routeDescriptorsForIrcGroup({
+			isGroup: message.isGroup,
+			groupPolicy,
+			groupAllowed: groupMatch.allowed,
+			hasConfiguredGroups: groupMatch.hasConfiguredGroups,
+			groupEnabled: groupMatch.groupConfig?.enabled !== false && groupMatch.wildcardConfig?.enabled !== false,
+			routeGroupAllowFrom
+		}),
+		mentionFacts: message.isGroup ? {
+			canDetectMention: true,
+			wasMentioned,
+			hasAnyMention: wasMentioned
+		} : void 0,
+		dmPolicy,
+		groupPolicy: accessGroupPolicy,
+		policy: {
+			groupAllowFromFallbackToAllowFrom: false,
+			mutableIdentifierMatching: allowNameMatching ? "enabled" : "disabled",
+			activation: {
+				requireMention: message.isGroup && requireMention,
+				allowTextCommands
+			}
+		},
+		allowFrom: account.config.allowFrom,
+		groupAllowFrom: account.config.groupAllowFrom,
+		command: {
+			allowTextCommands,
+			hasControlCommand
+		}
+	});
+	const commandAuthorized = access.commandAccess.authorized;
+	if (access.ingress.admission === "pairing-required") {
+		await pairing.issueChallenge({
+			senderId: normalizeLowercaseStringOrEmpty(senderDisplay),
+			senderIdLine: `Your IRC id: ${senderDisplay}`,
+			meta: { name: message.senderNick || void 0 },
+			sendPairingReply: async (text) => {
+				await deliverIrcReply({
+					payload: { text },
+					cfg: config,
+					target: message.senderNick,
+					accountId: account.accountId,
+					sendReply: params.sendReply,
+					statusSink
+				});
+			},
+			onReplyError: (err) => {
+				runtime.error?.(`irc: pairing reply failed for ${senderDisplay}: ${String(err)}`);
+			}
+		});
+		runtime.log?.(`irc: drop DM sender ${senderDisplay} (dmPolicy=${dmPolicy})`);
+		return;
+	}
+	if (access.ingress.admission === "skip") {
+		runtime.log?.(`irc: drop channel ${message.target} (missing-mention)`);
+		return;
+	}
+	if (access.ingress.admission !== "dispatch") {
+		if (message.isGroup && access.ingress.decisiveGateId === "command" && access.commandAccess.shouldBlockControlCommand) {
+			logInboundDrop({
+				log: (line) => runtime.log?.(line),
+				channel: CHANNEL_ID,
+				reason: "control command (unauthorized)",
+				target: senderDisplay
+			});
+			return;
+		}
+		if (message.isGroup) if (access.routeAccess.reason === "channel_not_allowlisted") runtime.log?.(`irc: drop channel ${message.target} (not allowlisted)`);
+		else if (access.routeAccess.reason === "channel_disabled") runtime.log?.(`irc: drop channel ${message.target} (disabled)`);
+		else runtime.log?.(`irc: drop group sender ${senderDisplay} (policy=${groupPolicy})`);
+		else runtime.log?.(`irc: drop DM sender ${senderDisplay} (dmPolicy=${dmPolicy})`);
+		return;
+	}
+	const peerId = message.isGroup ? message.target : message.senderNick;
+	const { route, buildEnvelope } = resolveInboundRouteEnvelopeBuilderWithRuntime({
+		cfg: config,
+		channel: CHANNEL_ID,
+		accountId: account.accountId,
+		peer: {
+			kind: message.isGroup ? "group" : "direct",
+			id: peerId
+		},
+		runtime: core.channel,
+		sessionStore: config.session?.store
+	});
+	const fromLabel = message.isGroup ? message.target : senderDisplay;
+	const { storePath, body } = buildEnvelope({
+		channel: "IRC",
+		from: fromLabel,
+		timestamp: message.timestamp,
+		body: rawBody
+	});
+	const groupSystemPrompt = normalizeOptionalString(groupMatch.groupConfig?.systemPrompt);
+	const ctxPayload = core.channel.reply.finalizeInboundContext({
+		Body: body,
+		RawBody: rawBody,
+		CommandBody: rawBody,
+		From: message.isGroup ? `irc:channel:${message.target}` : `irc:${senderDisplay}`,
+		To: `irc:${peerId}`,
+		SessionKey: route.sessionKey,
+		AccountId: route.accountId,
+		ChatType: message.isGroup ? "group" : "direct",
+		ConversationLabel: fromLabel,
+		SenderName: message.senderNick || void 0,
+		SenderId: senderDisplay,
+		GroupSubject: message.isGroup ? message.target : void 0,
+		GroupSystemPrompt: message.isGroup ? groupSystemPrompt : void 0,
+		Provider: CHANNEL_ID,
+		Surface: CHANNEL_ID,
+		WasMentioned: message.isGroup ? wasMentioned : void 0,
+		MessageSid: message.messageId,
+		Timestamp: message.timestamp,
+		OriginatingChannel: CHANNEL_ID,
+		OriginatingTo: `irc:${peerId}`,
+		CommandAuthorized: commandAuthorized
+	});
+	await core.channel.turn.runAssembled({
+		cfg: config,
+		channel: CHANNEL_ID,
+		accountId: account.accountId,
+		agentId: route.agentId,
+		routeSessionKey: route.sessionKey,
+		storePath,
+		ctxPayload,
+		recordInboundSession: core.channel.session.recordInboundSession,
+		dispatchReplyWithBufferedBlockDispatcher: core.channel.reply.dispatchReplyWithBufferedBlockDispatcher,
+		delivery: {
+			deliver: async (payload) => {
+				await deliverIrcReply({
+					payload,
+					cfg: config,
+					target: peerId,
+					accountId: account.accountId,
+					sendReply: params.sendReply,
+					statusSink
+				});
+			},
+			onError: (err, info) => {
+				runtime.error?.(`irc ${info.kind} reply failed: ${String(err)}`);
+			}
+		},
+		replyPipeline: {},
+		replyOptions: {
+			skillFilter: groupMatch.groupConfig?.skills,
+			disableBlockStreaming: typeof account.config.blockStreaming === "boolean" ? !account.config.blockStreaming : void 0
+		},
+		record: { onRecordError: (err) => {
+			runtime.error?.(`irc: failed updating session meta: ${String(err)}`);
+		} }
+	});
+}
+//#endregion
+//#region extensions/irc/src/monitor.ts
+function resolveIrcInboundTarget(params) {
+	const rawTarget = params.target;
+	if (isChannelTarget(rawTarget)) return {
+		isGroup: true,
+		target: rawTarget,
+		rawTarget
+	};
+	return {
+		isGroup: false,
+		target: params.senderNick.trim() || rawTarget,
+		rawTarget
+	};
+}
+async function monitorIrcProvider(opts) {
+	const core = getIrcRuntime();
+	const cfg = opts.config ?? core.config.current();
+	const account = resolveIrcAccount({
+		cfg,
+		accountId: opts.accountId
+	});
+	const runtime = resolveLoggerBackedRuntime(opts.runtime, core.logging.getChildLogger());
+	if (!account.configured) throw new Error(`IRC is not configured for account "${account.accountId}" (need host and nick in channels.irc).`);
+	const logger = core.logging.getChildLogger({
+		channel: "irc",
+		accountId: account.accountId
+	});
+	let client = null;
+	client = await connectIrcClient(buildIrcConnectOptions(account, {
+		channels: account.config.channels,
+		abortSignal: opts.abortSignal,
+		onLine: (line) => {
+			if (core.logging.shouldLogVerbose()) logger.debug?.(`[${account.accountId}] << ${line}`);
+		},
+		onNotice: (text, target) => {
+			if (core.logging.shouldLogVerbose()) logger.debug?.(`[${account.accountId}] notice ${target ?? ""}: ${text}`);
+		},
+		onError: (error) => {
+			logger.error(`[${account.accountId}] IRC error: ${error.message}`);
+		},
+		onPrivmsg: async (event) => {
+			if (!client) return;
+			if (normalizeLowercaseStringOrEmpty(event.senderNick) === normalizeLowercaseStringOrEmpty(client.nick)) return;
+			const inboundTarget = resolveIrcInboundTarget({
+				target: event.target,
+				senderNick: event.senderNick
+			});
+			const message = {
+				messageId: makeIrcMessageId(),
+				target: inboundTarget.target,
+				rawTarget: inboundTarget.rawTarget,
+				senderNick: event.senderNick,
+				senderUser: event.senderUser,
+				senderHost: event.senderHost,
+				text: event.text,
+				timestamp: Date.now(),
+				isGroup: inboundTarget.isGroup
+			};
+			core.channel.activity.record({
+				channel: "irc",
+				accountId: account.accountId,
+				direction: "inbound",
+				at: message.timestamp
+			});
+			if (opts.onMessage) {
+				await opts.onMessage(message, client);
+				return;
+			}
+			await handleIrcInbound({
+				message,
+				account,
+				config: cfg,
+				runtime,
+				connectedNick: client.nick,
+				sendReply: async (target, text) => {
+					client?.sendPrivmsg(target, text);
+					opts.statusSink?.({ lastOutboundAt: Date.now() });
+					core.channel.activity.record({
+						channel: "irc",
+						accountId: account.accountId,
+						direction: "outbound"
+					});
+				},
+				statusSink: opts.statusSink
+			});
+		}
+	}));
+	logger.info(`[${account.accountId}] connected to ${account.host}:${account.port}${account.tls ? " (tls)" : ""} as ${client.nick}`);
+	return { stop: () => {
+		client?.quit("shutdown");
+		client = null;
+	} };
+}
+//#endregion
+export { monitorIrcProvider, sendMessageIrc };

package/dist/channel.runtime--HOyAuAy.js

@@ -0,0 +1,254 @@
+import { c as normalizeOptionalString } from "./string-coerce-DyL154ka.js";
+import { i as formatErrorMessage } from "./errors-D_oyTIw2.js";
+import { p as resolvePayloadMediaUrls, w as createReplyToFanout } from "./reply-payload-DMPQsrQC.js";
+import { f as renderMessagePresentationFallbackText } from "./payload-BDV15CYA.js";
+import { n as resolveOutboundSendDep } from "./send-deps-B-rmeTVl.js";
+import "./error-runtime--zM-GsR-.js";
+import "./string-coerce-runtime-DcopKqDR.js";
+import "./outbound-runtime-BWFKdtGY.js";
+import { t as chunkTextForOutbound } from "./text-chunking-ObhJDe8L.js";
+import { a as sendMessageMatrix, l as sendTypingMatrix, o as sendPollMatrix } from "./send-CQTcckeM.js";
+import { t as isBunRuntime } from "./runtime-BefyhPWv.js";
+import { n as resolveMatrixAuth } from "./config-C1dtmXuT.js";
+import "./client-XHdBH-Lw.js";
+import { n as listMatrixDirectoryPeersLive, t as listMatrixDirectoryGroupsLive } from "./directory-live-DLot_-Z0.js";
+import "./runtime-api-B6bOPJ4H.js";
+import { t as resolveMatrixTargets } from "./resolve-targets-BAoMcmkx.js";
+//#region extensions/matrix/src/matrix/probe.ts
+let matrixProbeRuntimeDepsPromise;
+async function loadMatrixProbeRuntimeDeps() {
+	matrixProbeRuntimeDepsPromise ??= import("./probe.runtime-C2zppX6C.js").then((runtimeModule) => ({ createMatrixClient: runtimeModule.createMatrixClient }));
+	return await matrixProbeRuntimeDepsPromise;
+}
+async function probeMatrix(params) {
+	const started = Date.now();
+	const result = {
+		ok: false,
+		status: null,
+		error: null,
+		elapsedMs: 0
+	};
+	if (isBunRuntime()) return {
+		...result,
+		error: "Matrix probe requires Node (bun runtime not supported)",
+		elapsedMs: Date.now() - started
+	};
+	if (!params.homeserver?.trim()) return {
+		...result,
+		error: "missing homeserver",
+		elapsedMs: Date.now() - started
+	};
+	if (!params.accessToken?.trim()) return {
+		...result,
+		error: "missing access token",
+		elapsedMs: Date.now() - started
+	};
+	try {
+		const { createMatrixClient } = await loadMatrixProbeRuntimeDeps();
+		const inputUserId = normalizeOptionalString(params.userId);
+		const userId = await (await createMatrixClient({
+			homeserver: params.homeserver,
+			userId: inputUserId,
+			accessToken: params.accessToken,
+			deviceId: params.deviceId,
+			persistStorage: false,
+			localTimeoutMs: params.timeoutMs,
+			accountId: params.accountId,
+			allowPrivateNetwork: params.allowPrivateNetwork,
+			ssrfPolicy: params.ssrfPolicy,
+			dispatcherPolicy: params.dispatcherPolicy
+		})).getUserId();
+		result.ok = true;
+		result.userId = userId ?? null;
+		result.elapsedMs = Date.now() - started;
+		return result;
+	} catch (err) {
+		return {
+			...result,
+			status: typeof err === "object" && err && "statusCode" in err ? Number(err.statusCode) : result.status,
+			error: formatErrorMessage(err),
+			elapsedMs: Date.now() - started
+		};
+	}
+}
+//#endregion
+//#region extensions/matrix/src/outbound.ts
+const MATRIX_DAOCORE_PRESENTATION_KEY = "com.daocore.presentation";
+const MATRIX_DAOCORE_PRESENTATION_TYPE = "message.presentation";
+const MATRIX_EMPTY_PRESENTATION_FALLBACK_TEXT = "---";
+function toRecord(value) {
+	return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function resolveMatrixChannelData(payload) {
+	const raw = toRecord(payload.channelData)?.matrix;
+	return toRecord(raw) ?? {};
+}
+function buildMatrixPresentationContent(presentation) {
+	return {
+		...presentation,
+		version: 1,
+		type: MATRIX_DAOCORE_PRESENTATION_TYPE
+	};
+}
+function resolveMatrixPresentationContent(payload) {
+	const presentation = toRecord(toRecord(resolveMatrixChannelData(payload).extraContent)?.[MATRIX_DAOCORE_PRESENTATION_KEY]);
+	if (!presentation || presentation.version !== 1 || presentation.type !== MATRIX_DAOCORE_PRESENTATION_TYPE) return;
+	return presentation;
+}
+function renderMatrixPresentationPayload(params) {
+	const matrixData = resolveMatrixChannelData(params.payload);
+	const fallbackText = renderMessagePresentationFallbackText({
+		text: params.payload.text,
+		presentation: params.presentation,
+		emptyFallback: MATRIX_EMPTY_PRESENTATION_FALLBACK_TEXT
+	});
+	return {
+		...params.payload,
+		text: fallbackText,
+		channelData: {
+			...params.payload.channelData,
+			matrix: {
+				...matrixData,
+				extraContent: { [MATRIX_DAOCORE_PRESENTATION_KEY]: buildMatrixPresentationContent(params.presentation) }
+			}
+		}
+	};
+}
+function resolveMatrixPayloadText(payload) {
+	const text = payload.text ?? "";
+	if (text.trim() || !resolveMatrixPresentationContent(payload)) return text;
+	return MATRIX_EMPTY_PRESENTATION_FALLBACK_TEXT;
+}
+function resolveMatrixExtraContent(payload) {
+	const presentation = resolveMatrixPresentationContent(payload);
+	return presentation ? { [MATRIX_DAOCORE_PRESENTATION_KEY]: presentation } : void 0;
+}
+//#endregion
+//#region extensions/matrix/src/channel.runtime.ts
+const matrixChannelRuntime = {
+	listMatrixDirectoryGroupsLive,
+	listMatrixDirectoryPeersLive,
+	matrixOutbound: {
+		deliveryMode: "direct",
+		chunker: chunkTextForOutbound,
+		chunkerMode: "markdown",
+		textChunkLimit: 4e3,
+		presentationCapabilities: {
+			supported: true,
+			buttons: true,
+			selects: true,
+			context: true,
+			divider: true,
+			limits: { text: {
+				markdownDialect: "markdown",
+				supportsEdit: true
+			} }
+		},
+		renderPresentation: ({ payload, presentation }) => renderMatrixPresentationPayload({
+			payload,
+			presentation
+		}),
+		sendPayload: async ({ cfg, to, payload, mediaLocalRoots, mediaReadFile, mediaAccess, deps, replyToId, replyToIdSource, replyToMode, threadId, accountId, audioAsVoice }) => {
+			const send = resolveOutboundSendDep(deps, "matrix") ?? sendMessageMatrix;
+			const resolvedThreadId = threadId !== void 0 && threadId !== null ? String(threadId) : void 0;
+			const resolveReplyToId = createReplyToFanout({
+				...replyToId != null ? { replyToId } : {},
+				...replyToIdSource !== void 0 ? { replyToIdSource } : {},
+				...replyToMode !== void 0 ? { replyToMode } : {}
+			});
+			const urls = resolvePayloadMediaUrls(payload);
+			const payloadText = resolveMatrixPayloadText(payload);
+			if (urls.length > 0) {
+				let lastResult;
+				for (let i = 0; i < urls.length; i++) {
+					const isFirst = i === 0;
+					lastResult = await send(to, isFirst ? payloadText : "", {
+						cfg,
+						mediaUrl: urls[i],
+						mediaAccess,
+						mediaLocalRoots,
+						mediaReadFile,
+						replyToId: resolveReplyToId(),
+						threadId: resolvedThreadId,
+						accountId: accountId ?? void 0,
+						audioAsVoice: payload.audioAsVoice ?? audioAsVoice,
+						extraContent: isFirst ? resolveMatrixExtraContent(payload) : void 0
+					});
+				}
+				return {
+					channel: "matrix",
+					messageId: lastResult.messageId,
+					roomId: lastResult.roomId
+				};
+			}
+			const result = await send(to, payloadText, {
+				cfg,
+				mediaUrl: payload.mediaUrl,
+				mediaAccess,
+				mediaLocalRoots,
+				mediaReadFile,
+				replyToId: resolveReplyToId(),
+				threadId: resolvedThreadId,
+				accountId: accountId ?? void 0,
+				audioAsVoice: payload.audioAsVoice ?? audioAsVoice,
+				extraContent: resolveMatrixExtraContent(payload)
+			});
+			return {
+				channel: "matrix",
+				messageId: result.messageId,
+				roomId: result.roomId
+			};
+		},
+		sendText: async ({ cfg, to, text, deps, replyToId, threadId, accountId, audioAsVoice }) => {
+			const result = await (resolveOutboundSendDep(deps, "matrix") ?? sendMessageMatrix)(to, text, {
+				cfg,
+				replyToId: replyToId ?? void 0,
+				threadId: threadId !== void 0 && threadId !== null ? String(threadId) : void 0,
+				accountId: accountId ?? void 0,
+				audioAsVoice
+			});
+			return {
+				channel: "matrix",
+				messageId: result.messageId,
+				roomId: result.roomId
+			};
+		},
+		sendMedia: async ({ cfg, to, text, mediaUrl, mediaLocalRoots, mediaReadFile, deps, replyToId, threadId, accountId, audioAsVoice }) => {
+			const result = await (resolveOutboundSendDep(deps, "matrix") ?? sendMessageMatrix)(to, text, {
+				cfg,
+				mediaUrl,
+				mediaLocalRoots,
+				mediaReadFile,
+				replyToId: replyToId ?? void 0,
+				threadId: threadId !== void 0 && threadId !== null ? String(threadId) : void 0,
+				accountId: accountId ?? void 0,
+				audioAsVoice
+			});
+			return {
+				channel: "matrix",
+				messageId: result.messageId,
+				roomId: result.roomId
+			};
+		},
+		sendPoll: async ({ cfg, to, poll, threadId, accountId }) => {
+			const result = await sendPollMatrix(to, poll, {
+				cfg,
+				threadId: threadId !== void 0 && threadId !== null ? threadId : void 0,
+				accountId: accountId ?? void 0
+			});
+			return {
+				channel: "matrix",
+				messageId: result.eventId,
+				roomId: result.roomId,
+				pollId: result.eventId
+			};
+		}
+	},
+	probeMatrix,
+	resolveMatrixAuth,
+	resolveMatrixTargets,
+	sendMessageMatrix,
+	sendTypingMatrix
+};
+//#endregion
+export { matrixChannelRuntime };

package/dist/channel.runtime-BOihoJhd.js

@@ -0,0 +1,4 @@
+import { x as pushMessageLine } from "./markdown-to-line-C1aYJ2q1.js";
+import { t as monitorLineProvider } from "./monitor-C7JcIhS9.js";
+import { t as probeLineBot } from "./probe-O4w1DV-N.js";
+export { monitorLineProvider, probeLineBot, pushMessageLine };