@captain-app/openclaw 2026.2.4

package/dist/plugin-sdk/deliver-Cl8uowiO.js

@@ -0,0 +1,2557 @@
+import { t as __exportAll } from "./rolldown-runtime-Cbj13DAv.js";
+import { F as shouldLogVerbose, N as logVerbose, Z as getActivePluginRegistry, w as resolveUserPath } from "./exec-Cm9b2r9Q.js";
+import { t as loadConfig } from "./config-Cm1M7tgH.js";
+import { A as normalizeAccountId$1 } from "./agent-scope-DdwUKIOe.js";
+import { Ct as optimizeImageToPng, Et as extensionForMime, Ft as appendAssistantMessageToSessionTranscript, In as getChannelDock, It as resolveMirroredTranscriptText, Nt as maxBytesForKind, Pt as mediaKindFromMime, St as hasAlphaChannel, Tt as detectMime, _t as resolvePinnedHostnameWithPolicy, bn as normalizeChannelId, bt as convertHeicToJpeg, ft as saveMediaBuffer, gt as resolvePinnedHostname, ht as createPinnedDispatcher, i as isMessagingToolDuplicate, mt as closeDispatcher, sn as INTERNAL_MESSAGE_CHANNEL, vn as getChannelPlugin, vr as resolveSignalAccount, wt as resizeToJpeg } from "./pi-embedded-helpers-5jNqW_dE.js";
+import path from "node:path";
+import fs from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { randomUUID } from "node:crypto";
+import MarkdownIt from "markdown-it";
+
+//#region src/auto-reply/tokens.ts
+const HEARTBEAT_TOKEN = "HEARTBEAT_OK";
+const SILENT_REPLY_TOKEN = "NO_REPLY";
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function isSilentReplyText(text, token = SILENT_REPLY_TOKEN) {
+	if (!text) return false;
+	const escaped = escapeRegExp(token);
+	if (new RegExp(`^\\s*${escaped}(?=$|\\W)`).test(text)) return true;
+	return new RegExp(`\\b${escaped}\\b\\W*$`).test(text);
+}
+
+//#endregion
+//#region src/channels/plugins/media-limits.ts
+const MB$1 = 1024 * 1024;
+function resolveChannelMediaMaxBytes(params) {
+	const accountId = normalizeAccountId$1(params.accountId);
+	const channelLimit = params.resolveChannelLimitMb({
+		cfg: params.cfg,
+		accountId
+	});
+	if (channelLimit) return channelLimit * MB$1;
+	if (params.cfg.agents?.defaults?.mediaMaxMb) return params.cfg.agents.defaults.mediaMaxMb * MB$1;
+}
+
+//#endregion
+//#region src/infra/net/fetch-guard.ts
+const DEFAULT_MAX_REDIRECTS = 3;
+function isRedirectStatus(status) {
+	return status === 301 || status === 302 || status === 303 || status === 307 || status === 308;
+}
+function buildAbortSignal(params) {
+	const { timeoutMs, signal } = params;
+	if (!timeoutMs && !signal) return {
+		signal: void 0,
+		cleanup: () => {}
+	};
+	if (!timeoutMs) return {
+		signal,
+		cleanup: () => {}
+	};
+	const controller = new AbortController();
+	const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+	const onAbort = () => controller.abort();
+	if (signal) if (signal.aborted) controller.abort();
+	else signal.addEventListener("abort", onAbort, { once: true });
+	const cleanup = () => {
+		clearTimeout(timeoutId);
+		if (signal) signal.removeEventListener("abort", onAbort);
+	};
+	return {
+		signal: controller.signal,
+		cleanup
+	};
+}
+async function fetchWithSsrFGuard(params) {
+	const fetcher = params.fetchImpl ?? globalThis.fetch;
+	if (!fetcher) throw new Error("fetch is not available");
+	const maxRedirects = typeof params.maxRedirects === "number" && Number.isFinite(params.maxRedirects) ? Math.max(0, Math.floor(params.maxRedirects)) : DEFAULT_MAX_REDIRECTS;
+	const { signal, cleanup } = buildAbortSignal({
+		timeoutMs: params.timeoutMs,
+		signal: params.signal
+	});
+	let released = false;
+	const release = async (dispatcher) => {
+		if (released) return;
+		released = true;
+		cleanup();
+		await closeDispatcher(dispatcher ?? void 0);
+	};
+	const visited = /* @__PURE__ */ new Set();
+	let currentUrl = params.url;
+	let redirectCount = 0;
+	while (true) {
+		let parsedUrl;
+		try {
+			parsedUrl = new URL(currentUrl);
+		} catch {
+			await release();
+			throw new Error("Invalid URL: must be http or https");
+		}
+		if (!["http:", "https:"].includes(parsedUrl.protocol)) {
+			await release();
+			throw new Error("Invalid URL: must be http or https");
+		}
+		let dispatcher = null;
+		try {
+			const pinned = Boolean(params.policy?.allowPrivateNetwork || params.policy?.allowedHostnames?.length) ? await resolvePinnedHostnameWithPolicy(parsedUrl.hostname, {
+				lookupFn: params.lookupFn,
+				policy: params.policy
+			}) : await resolvePinnedHostname(parsedUrl.hostname, params.lookupFn);
+			if (params.pinDns !== false) dispatcher = createPinnedDispatcher(pinned);
+			const init = {
+				...params.init ? { ...params.init } : {},
+				redirect: "manual",
+				...dispatcher ? { dispatcher } : {},
+				...signal ? { signal } : {}
+			};
+			const response = await fetcher(parsedUrl.toString(), init);
+			if (isRedirectStatus(response.status)) {
+				const location = response.headers.get("location");
+				if (!location) {
+					await release(dispatcher);
+					throw new Error(`Redirect missing location header (${response.status})`);
+				}
+				redirectCount += 1;
+				if (redirectCount > maxRedirects) {
+					await release(dispatcher);
+					throw new Error(`Too many redirects (limit: ${maxRedirects})`);
+				}
+				const nextUrl = new URL(location, parsedUrl).toString();
+				if (visited.has(nextUrl)) {
+					await release(dispatcher);
+					throw new Error("Redirect loop detected");
+				}
+				visited.add(nextUrl);
+				response.body?.cancel();
+				await closeDispatcher(dispatcher);
+				currentUrl = nextUrl;
+				continue;
+			}
+			return {
+				response,
+				finalUrl: currentUrl,
+				release: async () => release(dispatcher)
+			};
+		} catch (err) {
+			await release(dispatcher);
+			throw err;
+		}
+	}
+}
+
+//#endregion
+//#region src/media/fetch.ts
+var MediaFetchError = class extends Error {
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+		this.name = "MediaFetchError";
+	}
+};
+function stripQuotes(value) {
+	return value.replace(/^["']|["']$/g, "");
+}
+function parseContentDispositionFileName(header) {
+	if (!header) return;
+	const starMatch = /filename\*\s*=\s*([^;]+)/i.exec(header);
+	if (starMatch?.[1]) {
+		const cleaned = stripQuotes(starMatch[1].trim());
+		const encoded = cleaned.split("''").slice(1).join("''") || cleaned;
+		try {
+			return path.basename(decodeURIComponent(encoded));
+		} catch {
+			return path.basename(encoded);
+		}
+	}
+	const match = /filename\s*=\s*([^;]+)/i.exec(header);
+	if (match?.[1]) return path.basename(stripQuotes(match[1].trim()));
+}
+async function readErrorBodySnippet(res, maxChars = 200) {
+	try {
+		const text = await res.text();
+		if (!text) return;
+		const collapsed = text.replace(/\s+/g, " ").trim();
+		if (!collapsed) return;
+		if (collapsed.length <= maxChars) return collapsed;
+		return `${collapsed.slice(0, maxChars)}…`;
+	} catch {
+		return;
+	}
+}
+async function fetchRemoteMedia(options) {
+	const { url, fetchImpl, filePathHint, maxBytes, maxRedirects, ssrfPolicy, lookupFn } = options;
+	let res;
+	let finalUrl = url;
+	let release = null;
+	try {
+		const result = await fetchWithSsrFGuard({
+			url,
+			fetchImpl,
+			maxRedirects,
+			policy: ssrfPolicy,
+			lookupFn
+		});
+		res = result.response;
+		finalUrl = result.finalUrl;
+		release = result.release;
+	} catch (err) {
+		throw new MediaFetchError("fetch_failed", `Failed to fetch media from ${url}: ${String(err)}`);
+	}
+	try {
+		if (!res.ok) {
+			const statusText = res.statusText ? ` ${res.statusText}` : "";
+			const redirected = finalUrl !== url ? ` (redirected to ${finalUrl})` : "";
+			let detail = `HTTP ${res.status}${statusText}`;
+			if (!res.body) detail = `HTTP ${res.status}${statusText}; empty response body`;
+			else {
+				const snippet = await readErrorBodySnippet(res);
+				if (snippet) detail += `; body: ${snippet}`;
+			}
+			throw new MediaFetchError("http_error", `Failed to fetch media from ${url}${redirected}: ${detail}`);
+		}
+		const contentLength = res.headers.get("content-length");
+		if (maxBytes && contentLength) {
+			const length = Number(contentLength);
+			if (Number.isFinite(length) && length > maxBytes) throw new MediaFetchError("max_bytes", `Failed to fetch media from ${url}: content length ${length} exceeds maxBytes ${maxBytes}`);
+		}
+		const buffer = maxBytes ? await readResponseWithLimit(res, maxBytes) : Buffer.from(await res.arrayBuffer());
+		let fileNameFromUrl;
+		try {
+			const parsed = new URL(finalUrl);
+			fileNameFromUrl = path.basename(parsed.pathname) || void 0;
+		} catch {}
+		const headerFileName = parseContentDispositionFileName(res.headers.get("content-disposition"));
+		let fileName = headerFileName || fileNameFromUrl || (filePathHint ? path.basename(filePathHint) : void 0);
+		const filePathForMime = headerFileName && path.extname(headerFileName) ? headerFileName : filePathHint ?? finalUrl;
+		const contentType = await detectMime({
+			buffer,
+			headerMime: res.headers.get("content-type"),
+			filePath: filePathForMime
+		});
+		if (fileName && !path.extname(fileName) && contentType) {
+			const ext = extensionForMime(contentType);
+			if (ext) fileName = `${fileName}${ext}`;
+		}
+		return {
+			buffer,
+			contentType: contentType ?? void 0,
+			fileName
+		};
+	} finally {
+		if (release) await release();
+	}
+}
+async function readResponseWithLimit(res, maxBytes) {
+	const body = res.body;
+	if (!body || typeof body.getReader !== "function") {
+		const fallback = Buffer.from(await res.arrayBuffer());
+		if (fallback.length > maxBytes) throw new MediaFetchError("max_bytes", `Failed to fetch media from ${res.url || "response"}: payload exceeds maxBytes ${maxBytes}`);
+		return fallback;
+	}
+	const reader = body.getReader();
+	const chunks = [];
+	let total = 0;
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			if (value?.length) {
+				total += value.length;
+				if (total > maxBytes) {
+					try {
+						await reader.cancel();
+					} catch {}
+					throw new MediaFetchError("max_bytes", `Failed to fetch media from ${res.url || "response"}: payload exceeds maxBytes ${maxBytes}`);
+				}
+				chunks.push(value);
+			}
+		}
+	} finally {
+		try {
+			reader.releaseLock();
+		} catch {}
+	}
+	return Buffer.concat(chunks.map((chunk) => Buffer.from(chunk)), total);
+}
+
+//#endregion
+//#region src/web/media.ts
+const HEIC_MIME_RE = /^image\/hei[cf]$/i;
+const HEIC_EXT_RE = /\.(heic|heif)$/i;
+const MB = 1024 * 1024;
+function formatMb(bytes, digits = 2) {
+	return (bytes / MB).toFixed(digits);
+}
+function formatCapLimit(label, cap, size) {
+	return `${label} exceeds ${formatMb(cap, 0)}MB limit (got ${formatMb(size)}MB)`;
+}
+function formatCapReduce(label, cap, size) {
+	return `${label} could not be reduced below ${formatMb(cap, 0)}MB (got ${formatMb(size)}MB)`;
+}
+function isHeicSource(opts) {
+	if (opts.contentType && HEIC_MIME_RE.test(opts.contentType.trim())) return true;
+	if (opts.fileName && HEIC_EXT_RE.test(opts.fileName.trim())) return true;
+	return false;
+}
+function toJpegFileName(fileName) {
+	if (!fileName) return;
+	const trimmed = fileName.trim();
+	if (!trimmed) return fileName;
+	const parsed = path.parse(trimmed);
+	if (!parsed.ext || HEIC_EXT_RE.test(parsed.ext)) return path.format({
+		dir: parsed.dir,
+		name: parsed.name || trimmed,
+		ext: ".jpg"
+	});
+	return path.format({
+		dir: parsed.dir,
+		name: parsed.name,
+		ext: ".jpg"
+	});
+}
+function logOptimizedImage(params) {
+	if (!shouldLogVerbose()) return;
+	if (params.optimized.optimizedSize >= params.originalSize) return;
+	if (params.optimized.format === "png") {
+		logVerbose(`Optimized PNG (preserving alpha) from ${formatMb(params.originalSize)}MB to ${formatMb(params.optimized.optimizedSize)}MB (side≤${params.optimized.resizeSide}px)`);
+		return;
+	}
+	logVerbose(`Optimized media from ${formatMb(params.originalSize)}MB to ${formatMb(params.optimized.optimizedSize)}MB (side≤${params.optimized.resizeSide}px, q=${params.optimized.quality})`);
+}
+async function optimizeImageWithFallback(params) {
+	const { buffer, cap, meta } = params;
+	if ((meta?.contentType === "image/png" || meta?.fileName?.toLowerCase().endsWith(".png")) && await hasAlphaChannel(buffer)) {
+		const optimized = await optimizeImageToPng(buffer, cap);
+		if (optimized.buffer.length <= cap) return {
+			...optimized,
+			format: "png"
+		};
+		if (shouldLogVerbose()) logVerbose(`PNG with alpha still exceeds ${formatMb(cap, 0)}MB after optimization; falling back to JPEG`);
+	}
+	return {
+		...await optimizeImageToJpeg(buffer, cap, meta),
+		format: "jpeg"
+	};
+}
+async function loadWebMediaInternal(mediaUrl, options = {}) {
+	const { maxBytes, optimizeImages = true, ssrfPolicy } = options;
+	if (mediaUrl.startsWith("file://")) try {
+		mediaUrl = fileURLToPath(mediaUrl);
+	} catch {
+		throw new Error(`Invalid file:// URL: ${mediaUrl}`);
+	}
+	const optimizeAndClampImage = async (buffer, cap, meta) => {
+		const originalSize = buffer.length;
+		const optimized = await optimizeImageWithFallback({
+			buffer,
+			cap,
+			meta
+		});
+		logOptimizedImage({
+			originalSize,
+			optimized
+		});
+		if (optimized.buffer.length > cap) throw new Error(formatCapReduce("Media", cap, optimized.buffer.length));
+		const contentType = optimized.format === "png" ? "image/png" : "image/jpeg";
+		const fileName = optimized.format === "jpeg" && meta && isHeicSource(meta) ? toJpegFileName(meta.fileName) : meta?.fileName;
+		return {
+			buffer: optimized.buffer,
+			contentType,
+			kind: "image",
+			fileName
+		};
+	};
+	const clampAndFinalize = async (params) => {
+		const cap = maxBytes !== void 0 ? maxBytes : maxBytesForKind(params.kind);
+		if (params.kind === "image") {
+			const isGif = params.contentType === "image/gif";
+			if (isGif || !optimizeImages) {
+				if (params.buffer.length > cap) throw new Error(formatCapLimit(isGif ? "GIF" : "Media", cap, params.buffer.length));
+				return {
+					buffer: params.buffer,
+					contentType: params.contentType,
+					kind: params.kind,
+					fileName: params.fileName
+				};
+			}
+			return { ...await optimizeAndClampImage(params.buffer, cap, {
+				contentType: params.contentType,
+				fileName: params.fileName
+			}) };
+		}
+		if (params.buffer.length > cap) throw new Error(formatCapLimit("Media", cap, params.buffer.length));
+		return {
+			buffer: params.buffer,
+			contentType: params.contentType ?? void 0,
+			kind: params.kind,
+			fileName: params.fileName
+		};
+	};
+	if (/^https?:\/\//i.test(mediaUrl)) {
+		const defaultFetchCap = maxBytesForKind("unknown");
+		const { buffer, contentType, fileName } = await fetchRemoteMedia({
+			url: mediaUrl,
+			maxBytes: maxBytes === void 0 ? defaultFetchCap : optimizeImages ? Math.max(maxBytes, defaultFetchCap) : maxBytes,
+			ssrfPolicy
+		});
+		return await clampAndFinalize({
+			buffer,
+			contentType,
+			kind: mediaKindFromMime(contentType),
+			fileName
+		});
+	}
+	if (mediaUrl.startsWith("~")) mediaUrl = resolveUserPath(mediaUrl);
+	const data = await fs.readFile(mediaUrl);
+	const mime = await detectMime({
+		buffer: data,
+		filePath: mediaUrl
+	});
+	const kind = mediaKindFromMime(mime);
+	let fileName = path.basename(mediaUrl) || void 0;
+	if (fileName && !path.extname(fileName) && mime) {
+		const ext = extensionForMime(mime);
+		if (ext) fileName = `${fileName}${ext}`;
+	}
+	return await clampAndFinalize({
+		buffer: data,
+		contentType: mime,
+		kind,
+		fileName
+	});
+}
+async function loadWebMedia(mediaUrl, maxBytes, options) {
+	return await loadWebMediaInternal(mediaUrl, {
+		maxBytes,
+		optimizeImages: true,
+		ssrfPolicy: options?.ssrfPolicy
+	});
+}
+async function loadWebMediaRaw(mediaUrl, maxBytes, options) {
+	return await loadWebMediaInternal(mediaUrl, {
+		maxBytes,
+		optimizeImages: false,
+		ssrfPolicy: options?.ssrfPolicy
+	});
+}
+async function optimizeImageToJpeg(buffer, maxBytes, opts = {}) {
+	let source = buffer;
+	if (isHeicSource(opts)) try {
+		source = await convertHeicToJpeg(buffer);
+	} catch (err) {
+		throw new Error(`HEIC image conversion failed: ${String(err)}`, { cause: err });
+	}
+	const sides = [
+		2048,
+		1536,
+		1280,
+		1024,
+		800
+	];
+	const qualities = [
+		80,
+		70,
+		60,
+		50,
+		40
+	];
+	let smallest = null;
+	for (const side of sides) for (const quality of qualities) try {
+		const out = await resizeToJpeg({
+			buffer: source,
+			maxSide: side,
+			quality,
+			withoutEnlargement: true
+		});
+		const size = out.length;
+		if (!smallest || size < smallest.size) smallest = {
+			buffer: out,
+			size,
+			resizeSide: side,
+			quality
+		};
+		if (size <= maxBytes) return {
+			buffer: out,
+			optimizedSize: size,
+			resizeSide: side,
+			quality
+		};
+	} catch {}
+	if (smallest) return {
+		buffer: smallest.buffer,
+		optimizedSize: smallest.size,
+		resizeSide: smallest.resizeSide,
+		quality: smallest.quality
+	};
+	throw new Error("Failed to optimize image");
+}
+
+//#endregion
+//#region src/markdown/fences.ts
+function parseFenceSpans(buffer) {
+	const spans = [];
+	let open;
+	let offset = 0;
+	while (offset <= buffer.length) {
+		const nextNewline = buffer.indexOf("\n", offset);
+		const lineEnd = nextNewline === -1 ? buffer.length : nextNewline;
+		const line = buffer.slice(offset, lineEnd);
+		const match = line.match(/^( {0,3})(`{3,}|~{3,})(.*)$/);
+		if (match) {
+			const indent = match[1];
+			const marker = match[2];
+			const markerChar = marker[0];
+			const markerLen = marker.length;
+			if (!open) open = {
+				start: offset,
+				markerChar,
+				markerLen,
+				openLine: line,
+				marker,
+				indent
+			};
+			else if (open.markerChar === markerChar && markerLen >= open.markerLen) {
+				const end = lineEnd;
+				spans.push({
+					start: open.start,
+					end,
+					openLine: open.openLine,
+					marker: open.marker,
+					indent: open.indent
+				});
+				open = void 0;
+			}
+		}
+		if (nextNewline === -1) break;
+		offset = nextNewline + 1;
+	}
+	if (open) spans.push({
+		start: open.start,
+		end: buffer.length,
+		openLine: open.openLine,
+		marker: open.marker,
+		indent: open.indent
+	});
+	return spans;
+}
+function findFenceSpanAt(spans, index) {
+	return spans.find((span) => index > span.start && index < span.end);
+}
+function isSafeFenceBreak(spans, index) {
+	return !findFenceSpanAt(spans, index);
+}
+
+//#endregion
+//#region src/auto-reply/chunk.ts
+const DEFAULT_CHUNK_LIMIT = 4e3;
+const DEFAULT_CHUNK_MODE = "length";
+function resolveChunkLimitForProvider(cfgSection, accountId) {
+	if (!cfgSection) return;
+	const normalizedAccountId = normalizeAccountId$1(accountId);
+	const accounts = cfgSection.accounts;
+	if (accounts && typeof accounts === "object") {
+		const direct = accounts[normalizedAccountId];
+		if (typeof direct?.textChunkLimit === "number") return direct.textChunkLimit;
+		const matchKey = Object.keys(accounts).find((key) => key.toLowerCase() === normalizedAccountId.toLowerCase());
+		const match = matchKey ? accounts[matchKey] : void 0;
+		if (typeof match?.textChunkLimit === "number") return match.textChunkLimit;
+	}
+	return cfgSection.textChunkLimit;
+}
+function resolveTextChunkLimit(cfg, provider, accountId, opts) {
+	const fallback = typeof opts?.fallbackLimit === "number" && opts.fallbackLimit > 0 ? opts.fallbackLimit : DEFAULT_CHUNK_LIMIT;
+	const providerOverride = (() => {
+		if (!provider || provider === INTERNAL_MESSAGE_CHANNEL) return;
+		return resolveChunkLimitForProvider((cfg?.channels)?.[provider] ?? cfg?.[provider], accountId);
+	})();
+	if (typeof providerOverride === "number" && providerOverride > 0) return providerOverride;
+	return fallback;
+}
+function resolveChunkModeForProvider(cfgSection, accountId) {
+	if (!cfgSection) return;
+	const normalizedAccountId = normalizeAccountId$1(accountId);
+	const accounts = cfgSection.accounts;
+	if (accounts && typeof accounts === "object") {
+		const direct = accounts[normalizedAccountId];
+		if (direct?.chunkMode) return direct.chunkMode;
+		const matchKey = Object.keys(accounts).find((key) => key.toLowerCase() === normalizedAccountId.toLowerCase());
+		const match = matchKey ? accounts[matchKey] : void 0;
+		if (match?.chunkMode) return match.chunkMode;
+	}
+	return cfgSection.chunkMode;
+}
+function resolveChunkMode(cfg, provider, accountId) {
+	if (!provider || provider === INTERNAL_MESSAGE_CHANNEL) return DEFAULT_CHUNK_MODE;
+	return resolveChunkModeForProvider((cfg?.channels)?.[provider] ?? cfg?.[provider], accountId) ?? DEFAULT_CHUNK_MODE;
+}
+/**
+* Split text on newlines, trimming line whitespace.
+* Blank lines are folded into the next non-empty line as leading "\n" prefixes.
+* Long lines can be split by length (default) or kept intact via splitLongLines:false.
+*/
+function chunkByNewline(text, maxLineLength, opts) {
+	if (!text) return [];
+	if (maxLineLength <= 0) return text.trim() ? [text] : [];
+	const splitLongLines = opts?.splitLongLines !== false;
+	const trimLines = opts?.trimLines !== false;
+	const lines = splitByNewline(text, opts?.isSafeBreak);
+	const chunks = [];
+	let pendingBlankLines = 0;
+	for (const line of lines) {
+		const trimmed = line.trim();
+		if (!trimmed) {
+			pendingBlankLines += 1;
+			continue;
+		}
+		const maxPrefix = Math.max(0, maxLineLength - 1);
+		const cappedBlankLines = pendingBlankLines > 0 ? Math.min(pendingBlankLines, maxPrefix) : 0;
+		const prefix = cappedBlankLines > 0 ? "\n".repeat(cappedBlankLines) : "";
+		pendingBlankLines = 0;
+		const lineValue = trimLines ? trimmed : line;
+		if (!splitLongLines || lineValue.length + prefix.length <= maxLineLength) {
+			chunks.push(prefix + lineValue);
+			continue;
+		}
+		const firstLimit = Math.max(1, maxLineLength - prefix.length);
+		const first = lineValue.slice(0, firstLimit);
+		chunks.push(prefix + first);
+		const remaining = lineValue.slice(firstLimit);
+		if (remaining) chunks.push(...chunkText(remaining, maxLineLength));
+	}
+	if (pendingBlankLines > 0 && chunks.length > 0) chunks[chunks.length - 1] += "\n".repeat(pendingBlankLines);
+	return chunks;
+}
+/**
+* Split text into chunks on paragraph boundaries (blank lines), preserving lists and
+* single-newline line wraps inside paragraphs.
+*
+* - Only breaks at paragraph separators ("\n\n" or more, allowing whitespace on blank lines)
+* - Packs multiple paragraphs into a single chunk up to `limit`
+* - Falls back to length-based splitting when a single paragraph exceeds `limit`
+*   (unless `splitLongParagraphs` is disabled)
+*/
+function chunkByParagraph(text, limit, opts) {
+	if (!text) return [];
+	if (limit <= 0) return [text];
+	const splitLongParagraphs = opts?.splitLongParagraphs !== false;
+	const normalized = text.replace(/\r\n?/g, "\n");
+	if (!/\n[\t ]*\n+/.test(normalized)) {
+		if (normalized.length <= limit) return [normalized];
+		if (!splitLongParagraphs) return [normalized];
+		return chunkText(normalized, limit);
+	}
+	const spans = parseFenceSpans(normalized);
+	const parts = [];
+	const re = /\n[\t ]*\n+/g;
+	let lastIndex = 0;
+	for (const match of normalized.matchAll(re)) {
+		const idx = match.index ?? 0;
+		if (!isSafeFenceBreak(spans, idx)) continue;
+		parts.push(normalized.slice(lastIndex, idx));
+		lastIndex = idx + match[0].length;
+	}
+	parts.push(normalized.slice(lastIndex));
+	const chunks = [];
+	for (const part of parts) {
+		const paragraph = part.replace(/\s+$/g, "");
+		if (!paragraph.trim()) continue;
+		if (paragraph.length <= limit) chunks.push(paragraph);
+		else if (!splitLongParagraphs) chunks.push(paragraph);
+		else chunks.push(...chunkText(paragraph, limit));
+	}
+	return chunks;
+}
+/**
+* Unified chunking function that dispatches based on mode.
+*/
+function chunkTextWithMode(text, limit, mode) {
+	if (mode === "newline") return chunkByParagraph(text, limit);
+	return chunkText(text, limit);
+}
+function chunkMarkdownTextWithMode(text, limit, mode) {
+	if (mode === "newline") {
+		const paragraphChunks = chunkByParagraph(text, limit, { splitLongParagraphs: false });
+		const out = [];
+		for (const chunk of paragraphChunks) {
+			const nested = chunkMarkdownText(chunk, limit);
+			if (!nested.length && chunk) out.push(chunk);
+			else out.push(...nested);
+		}
+		return out;
+	}
+	return chunkMarkdownText(text, limit);
+}
+function splitByNewline(text, isSafeBreak = () => true) {
+	const lines = [];
+	let start = 0;
+	for (let i = 0; i < text.length; i++) if (text[i] === "\n" && isSafeBreak(i)) {
+		lines.push(text.slice(start, i));
+		start = i + 1;
+	}
+	lines.push(text.slice(start));
+	return lines;
+}
+function chunkText(text, limit) {
+	if (!text) return [];
+	if (limit <= 0) return [text];
+	if (text.length <= limit) return [text];
+	const chunks = [];
+	let remaining = text;
+	while (remaining.length > limit) {
+		const { lastNewline, lastWhitespace } = scanParenAwareBreakpoints(remaining.slice(0, limit));
+		let breakIdx = lastNewline > 0 ? lastNewline : lastWhitespace;
+		if (breakIdx <= 0) breakIdx = limit;
+		const chunk = remaining.slice(0, breakIdx).trimEnd();
+		if (chunk.length > 0) chunks.push(chunk);
+		const brokeOnSeparator = breakIdx < remaining.length && /\s/.test(remaining[breakIdx]);
+		const nextStart = Math.min(remaining.length, breakIdx + (brokeOnSeparator ? 1 : 0));
+		remaining = remaining.slice(nextStart).trimStart();
+	}
+	if (remaining.length) chunks.push(remaining);
+	return chunks;
+}
+function chunkMarkdownText(text, limit) {
+	if (!text) return [];
+	if (limit <= 0) return [text];
+	if (text.length <= limit) return [text];
+	const chunks = [];
+	let remaining = text;
+	while (remaining.length > limit) {
+		const spans = parseFenceSpans(remaining);
+		const softBreak = pickSafeBreakIndex(remaining.slice(0, limit), spans);
+		let breakIdx = softBreak > 0 ? softBreak : limit;
+		const initialFence = isSafeFenceBreak(spans, breakIdx) ? void 0 : findFenceSpanAt(spans, breakIdx);
+		let fenceToSplit = initialFence;
+		if (initialFence) {
+			const closeLine = `${initialFence.indent}${initialFence.marker}`;
+			const maxIdxIfNeedNewline = limit - (closeLine.length + 1);
+			if (maxIdxIfNeedNewline <= 0) {
+				fenceToSplit = void 0;
+				breakIdx = limit;
+			} else {
+				const minProgressIdx = Math.min(remaining.length, initialFence.start + initialFence.openLine.length + 2);
+				const maxIdxIfAlreadyNewline = limit - closeLine.length;
+				let pickedNewline = false;
+				let lastNewline = remaining.lastIndexOf("\n", Math.max(0, maxIdxIfAlreadyNewline - 1));
+				while (lastNewline !== -1) {
+					const candidateBreak = lastNewline + 1;
+					if (candidateBreak < minProgressIdx) break;
+					const candidateFence = findFenceSpanAt(spans, candidateBreak);
+					if (candidateFence && candidateFence.start === initialFence.start) {
+						breakIdx = Math.max(1, candidateBreak);
+						pickedNewline = true;
+						break;
+					}
+					lastNewline = remaining.lastIndexOf("\n", lastNewline - 1);
+				}
+				if (!pickedNewline) if (minProgressIdx > maxIdxIfAlreadyNewline) {
+					fenceToSplit = void 0;
+					breakIdx = limit;
+				} else breakIdx = Math.max(minProgressIdx, maxIdxIfNeedNewline);
+			}
+			const fenceAtBreak = findFenceSpanAt(spans, breakIdx);
+			fenceToSplit = fenceAtBreak && fenceAtBreak.start === initialFence.start ? fenceAtBreak : void 0;
+		}
+		let rawChunk = remaining.slice(0, breakIdx);
+		if (!rawChunk) break;
+		const brokeOnSeparator = breakIdx < remaining.length && /\s/.test(remaining[breakIdx]);
+		const nextStart = Math.min(remaining.length, breakIdx + (brokeOnSeparator ? 1 : 0));
+		let next = remaining.slice(nextStart);
+		if (fenceToSplit) {
+			const closeLine = `${fenceToSplit.indent}${fenceToSplit.marker}`;
+			rawChunk = rawChunk.endsWith("\n") ? `${rawChunk}${closeLine}` : `${rawChunk}\n${closeLine}`;
+			next = `${fenceToSplit.openLine}\n${next}`;
+		} else next = stripLeadingNewlines(next);
+		chunks.push(rawChunk);
+		remaining = next;
+	}
+	if (remaining.length) chunks.push(remaining);
+	return chunks;
+}
+function stripLeadingNewlines(value) {
+	let i = 0;
+	while (i < value.length && value[i] === "\n") i++;
+	return i > 0 ? value.slice(i) : value;
+}
+function pickSafeBreakIndex(window, spans) {
+	const { lastNewline, lastWhitespace } = scanParenAwareBreakpoints(window, (index) => isSafeFenceBreak(spans, index));
+	if (lastNewline > 0) return lastNewline;
+	if (lastWhitespace > 0) return lastWhitespace;
+	return -1;
+}
+function scanParenAwareBreakpoints(window, isAllowed = () => true) {
+	let lastNewline = -1;
+	let lastWhitespace = -1;
+	let depth = 0;
+	for (let i = 0; i < window.length; i++) {
+		if (!isAllowed(i)) continue;
+		const char = window[i];
+		if (char === "(") {
+			depth += 1;
+			continue;
+		}
+		if (char === ")" && depth > 0) {
+			depth -= 1;
+			continue;
+		}
+		if (depth !== 0) continue;
+		if (char === "\n") lastNewline = i;
+		else if (/\s/.test(char)) lastWhitespace = i;
+	}
+	return {
+		lastNewline,
+		lastWhitespace
+	};
+}
+
+//#endregion
+//#region src/infra/fetch.ts
+function withDuplex(init, input) {
+	const hasInitBody = init?.body != null;
+	const hasRequestBody = !hasInitBody && typeof Request !== "undefined" && input instanceof Request && input.body != null;
+	if (!hasInitBody && !hasRequestBody) return init;
+	if (init && "duplex" in init) return init;
+	return init ? {
+		...init,
+		duplex: "half"
+	} : { duplex: "half" };
+}
+function wrapFetchWithAbortSignal(fetchImpl) {
+	const wrapped = ((input, init) => {
+		const patchedInit = withDuplex(init, input);
+		const signal = patchedInit?.signal;
+		if (!signal) return fetchImpl(input, patchedInit);
+		if (typeof AbortSignal !== "undefined" && signal instanceof AbortSignal) return fetchImpl(input, patchedInit);
+		if (typeof AbortController === "undefined") return fetchImpl(input, patchedInit);
+		if (typeof signal.addEventListener !== "function") return fetchImpl(input, patchedInit);
+		const controller = new AbortController();
+		const onAbort = () => controller.abort();
+		if (signal.aborted) controller.abort();
+		else signal.addEventListener("abort", onAbort, { once: true });
+		const response = fetchImpl(input, {
+			...patchedInit,
+			signal: controller.signal
+		});
+		if (typeof signal.removeEventListener === "function") response.finally(() => {
+			signal.removeEventListener("abort", onAbort);
+		});
+		return response;
+	});
+	const fetchWithPreconnect = fetchImpl;
+	wrapped.preconnect = typeof fetchWithPreconnect.preconnect === "function" ? fetchWithPreconnect.preconnect.bind(fetchWithPreconnect) : () => {};
+	return Object.assign(wrapped, fetchImpl);
+}
+function resolveFetch(fetchImpl) {
+	const resolved = fetchImpl ?? globalThis.fetch;
+	if (!resolved) return;
+	return wrapFetchWithAbortSignal(resolved);
+}
+
+//#endregion
+//#region src/config/markdown-tables.ts
+const DEFAULT_TABLE_MODES = new Map([["signal", "bullets"], ["whatsapp", "bullets"]]);
+const isMarkdownTableMode = (value) => value === "off" || value === "bullets" || value === "code";
+function resolveMarkdownModeFromSection(section, accountId) {
+	if (!section) return;
+	const normalizedAccountId = normalizeAccountId$1(accountId);
+	const accounts = section.accounts;
+	if (accounts && typeof accounts === "object") {
+		const directMode = accounts[normalizedAccountId]?.markdown?.tables;
+		if (isMarkdownTableMode(directMode)) return directMode;
+		const matchKey = Object.keys(accounts).find((key) => key.toLowerCase() === normalizedAccountId.toLowerCase());
+		const matchMode = (matchKey ? accounts[matchKey] : void 0)?.markdown?.tables;
+		if (isMarkdownTableMode(matchMode)) return matchMode;
+	}
+	const sectionMode = section.markdown?.tables;
+	return isMarkdownTableMode(sectionMode) ? sectionMode : void 0;
+}
+function resolveMarkdownTableMode(params) {
+	const channel = normalizeChannelId(params.channel);
+	const defaultMode = channel ? DEFAULT_TABLE_MODES.get(channel) ?? "code" : "code";
+	if (!channel || !params.cfg) return defaultMode;
+	return resolveMarkdownModeFromSection(params.cfg.channels?.[channel] ?? params.cfg?.[channel], params.accountId) ?? defaultMode;
+}
+
+//#endregion
+//#region src/markdown/ir.ts
+function createMarkdownIt(options) {
+	const md = new MarkdownIt({
+		html: false,
+		linkify: options.linkify ?? true,
+		breaks: false,
+		typographer: false
+	});
+	md.enable("strikethrough");
+	if (options.tableMode && options.tableMode !== "off") md.enable("table");
+	else md.disable("table");
+	if (options.autolink === false) md.disable("autolink");
+	return md;
+}
+function getAttr(token, name) {
+	if (token.attrGet) return token.attrGet(name);
+	if (token.attrs) {
+		for (const [key, value] of token.attrs) if (key === name) return value;
+	}
+	return null;
+}
+function createTextToken(base, content) {
+	return {
+		...base,
+		type: "text",
+		content,
+		children: void 0
+	};
+}
+function applySpoilerTokens(tokens) {
+	for (const token of tokens) if (token.children && token.children.length > 0) token.children = injectSpoilersIntoInline(token.children);
+}
+function injectSpoilersIntoInline(tokens) {
+	const result = [];
+	const state = { spoilerOpen: false };
+	for (const token of tokens) {
+		if (token.type !== "text") {
+			result.push(token);
+			continue;
+		}
+		const content = token.content ?? "";
+		if (!content.includes("||")) {
+			result.push(token);
+			continue;
+		}
+		let index = 0;
+		while (index < content.length) {
+			const next = content.indexOf("||", index);
+			if (next === -1) {
+				if (index < content.length) result.push(createTextToken(token, content.slice(index)));
+				break;
+			}
+			if (next > index) result.push(createTextToken(token, content.slice(index, next)));
+			state.spoilerOpen = !state.spoilerOpen;
+			result.push({ type: state.spoilerOpen ? "spoiler_open" : "spoiler_close" });
+			index = next + 2;
+		}
+	}
+	return result;
+}
+function initRenderTarget() {
+	return {
+		text: "",
+		styles: [],
+		openStyles: [],
+		links: [],
+		linkStack: []
+	};
+}
+function resolveRenderTarget(state) {
+	return state.table?.currentCell ?? state;
+}
+function appendText(state, value) {
+	if (!value) return;
+	const target = resolveRenderTarget(state);
+	target.text += value;
+}
+function openStyle(state, style) {
+	const target = resolveRenderTarget(state);
+	target.openStyles.push({
+		style,
+		start: target.text.length
+	});
+}
+function closeStyle(state, style) {
+	const target = resolveRenderTarget(state);
+	for (let i = target.openStyles.length - 1; i >= 0; i -= 1) if (target.openStyles[i]?.style === style) {
+		const start = target.openStyles[i].start;
+		target.openStyles.splice(i, 1);
+		const end = target.text.length;
+		if (end > start) target.styles.push({
+			start,
+			end,
+			style
+		});
+		return;
+	}
+}
+function appendParagraphSeparator(state) {
+	if (state.env.listStack.length > 0) return;
+	if (state.table) return;
+	state.text += "\n\n";
+}
+function appendListPrefix(state) {
+	const stack = state.env.listStack;
+	const top = stack[stack.length - 1];
+	if (!top) return;
+	top.index += 1;
+	const indent = "  ".repeat(Math.max(0, stack.length - 1));
+	const prefix = top.type === "ordered" ? `${top.index}. ` : "• ";
+	state.text += `${indent}${prefix}`;
+}
+function renderInlineCode(state, content) {
+	if (!content) return;
+	const target = resolveRenderTarget(state);
+	const start = target.text.length;
+	target.text += content;
+	target.styles.push({
+		start,
+		end: start + content.length,
+		style: "code"
+	});
+}
+function renderCodeBlock(state, content) {
+	let code = content ?? "";
+	if (!code.endsWith("\n")) code = `${code}\n`;
+	const target = resolveRenderTarget(state);
+	const start = target.text.length;
+	target.text += code;
+	target.styles.push({
+		start,
+		end: start + code.length,
+		style: "code_block"
+	});
+	if (state.env.listStack.length === 0) target.text += "\n";
+}
+function handleLinkClose(state) {
+	const target = resolveRenderTarget(state);
+	const link = target.linkStack.pop();
+	if (!link?.href) return;
+	const href = link.href.trim();
+	if (!href) return;
+	const start = link.labelStart;
+	const end = target.text.length;
+	if (end <= start) {
+		target.links.push({
+			start,
+			end,
+			href
+		});
+		return;
+	}
+	target.links.push({
+		start,
+		end,
+		href
+	});
+}
+function initTableState() {
+	return {
+		headers: [],
+		rows: [],
+		currentRow: [],
+		currentCell: null,
+		inHeader: false
+	};
+}
+function finishTableCell(cell) {
+	closeRemainingStyles(cell);
+	return {
+		text: cell.text,
+		styles: cell.styles,
+		links: cell.links
+	};
+}
+function trimCell(cell) {
+	const text = cell.text;
+	let start = 0;
+	let end = text.length;
+	while (start < end && /\s/.test(text[start] ?? "")) start += 1;
+	while (end > start && /\s/.test(text[end - 1] ?? "")) end -= 1;
+	if (start === 0 && end === text.length) return cell;
+	const trimmedText = text.slice(start, end);
+	const trimmedLength = trimmedText.length;
+	const trimmedStyles = [];
+	for (const span of cell.styles) {
+		const sliceStart = Math.max(0, span.start - start);
+		const sliceEnd = Math.min(trimmedLength, span.end - start);
+		if (sliceEnd > sliceStart) trimmedStyles.push({
+			start: sliceStart,
+			end: sliceEnd,
+			style: span.style
+		});
+	}
+	const trimmedLinks = [];
+	for (const span of cell.links) {
+		const sliceStart = Math.max(0, span.start - start);
+		const sliceEnd = Math.min(trimmedLength, span.end - start);
+		if (sliceEnd > sliceStart) trimmedLinks.push({
+			start: sliceStart,
+			end: sliceEnd,
+			href: span.href
+		});
+	}
+	return {
+		text: trimmedText,
+		styles: trimmedStyles,
+		links: trimmedLinks
+	};
+}
+function appendCell(state, cell) {
+	if (!cell.text) return;
+	const start = state.text.length;
+	state.text += cell.text;
+	for (const span of cell.styles) state.styles.push({
+		start: start + span.start,
+		end: start + span.end,
+		style: span.style
+	});
+	for (const link of cell.links) state.links.push({
+		start: start + link.start,
+		end: start + link.end,
+		href: link.href
+	});
+}
+function renderTableAsBullets(state) {
+	if (!state.table) return;
+	const headers = state.table.headers.map(trimCell);
+	const rows = state.table.rows.map((row) => row.map(trimCell));
+	if (headers.length === 0 && rows.length === 0) return;
+	if (headers.length > 1 && rows.length > 0) for (const row of rows) {
+		if (row.length === 0) continue;
+		const rowLabel = row[0];
+		if (rowLabel?.text) {
+			const labelStart = state.text.length;
+			appendCell(state, rowLabel);
+			const labelEnd = state.text.length;
+			if (labelEnd > labelStart) state.styles.push({
+				start: labelStart,
+				end: labelEnd,
+				style: "bold"
+			});
+			state.text += "\n";
+		}
+		for (let i = 1; i < row.length; i++) {
+			const header = headers[i];
+			const value = row[i];
+			if (!value?.text) continue;
+			state.text += "• ";
+			if (header?.text) {
+				appendCell(state, header);
+				state.text += ": ";
+			} else state.text += `Column ${i}: `;
+			appendCell(state, value);
+			state.text += "\n";
+		}
+		state.text += "\n";
+	}
+	else for (const row of rows) {
+		for (let i = 0; i < row.length; i++) {
+			const header = headers[i];
+			const value = row[i];
+			if (!value?.text) continue;
+			state.text += "• ";
+			if (header?.text) {
+				appendCell(state, header);
+				state.text += ": ";
+			}
+			appendCell(state, value);
+			state.text += "\n";
+		}
+		state.text += "\n";
+	}
+}
+function renderTableAsCode(state) {
+	if (!state.table) return;
+	const headers = state.table.headers.map(trimCell);
+	const rows = state.table.rows.map((row) => row.map(trimCell));
+	const columnCount = Math.max(headers.length, ...rows.map((row) => row.length));
+	if (columnCount === 0) return;
+	const widths = Array.from({ length: columnCount }, () => 0);
+	const updateWidths = (cells) => {
+		for (let i = 0; i < columnCount; i += 1) {
+			const width = cells[i]?.text.length ?? 0;
+			if (widths[i] < width) widths[i] = width;
+		}
+	};
+	updateWidths(headers);
+	for (const row of rows) updateWidths(row);
+	const codeStart = state.text.length;
+	const appendRow = (cells) => {
+		state.text += "|";
+		for (let i = 0; i < columnCount; i += 1) {
+			state.text += " ";
+			const cell = cells[i];
+			if (cell) appendCell(state, cell);
+			const pad = widths[i] - (cell?.text.length ?? 0);
+			if (pad > 0) state.text += " ".repeat(pad);
+			state.text += " |";
+		}
+		state.text += "\n";
+	};
+	const appendDivider = () => {
+		state.text += "|";
+		for (let i = 0; i < columnCount; i += 1) {
+			const dashCount = Math.max(3, widths[i]);
+			state.text += ` ${"-".repeat(dashCount)} |`;
+		}
+		state.text += "\n";
+	};
+	appendRow(headers);
+	appendDivider();
+	for (const row of rows) appendRow(row);
+	const codeEnd = state.text.length;
+	if (codeEnd > codeStart) state.styles.push({
+		start: codeStart,
+		end: codeEnd,
+		style: "code_block"
+	});
+	if (state.env.listStack.length === 0) state.text += "\n";
+}
+function renderTokens(tokens, state) {
+	for (const token of tokens) switch (token.type) {
+		case "inline":
+			if (token.children) renderTokens(token.children, state);
+			break;
+		case "text":
+			appendText(state, token.content ?? "");
+			break;
+		case "em_open":
+			openStyle(state, "italic");
+			break;
+		case "em_close":
+			closeStyle(state, "italic");
+			break;
+		case "strong_open":
+			openStyle(state, "bold");
+			break;
+		case "strong_close":
+			closeStyle(state, "bold");
+			break;
+		case "s_open":
+			openStyle(state, "strikethrough");
+			break;
+		case "s_close":
+			closeStyle(state, "strikethrough");
+			break;
+		case "code_inline":
+			renderInlineCode(state, token.content ?? "");
+			break;
+		case "spoiler_open":
+			if (state.enableSpoilers) openStyle(state, "spoiler");
+			break;
+		case "spoiler_close":
+			if (state.enableSpoilers) closeStyle(state, "spoiler");
+			break;
+		case "link_open": {
+			const href = getAttr(token, "href") ?? "";
+			const target = resolveRenderTarget(state);
+			target.linkStack.push({
+				href,
+				labelStart: target.text.length
+			});
+			break;
+		}
+		case "link_close":
+			handleLinkClose(state);
+			break;
+		case "image":
+			appendText(state, token.content ?? "");
+			break;
+		case "softbreak":
+		case "hardbreak":
+			appendText(state, "\n");
+			break;
+		case "paragraph_close":
+			appendParagraphSeparator(state);
+			break;
+		case "heading_open":
+			if (state.headingStyle === "bold") openStyle(state, "bold");
+			break;
+		case "heading_close":
+			if (state.headingStyle === "bold") closeStyle(state, "bold");
+			appendParagraphSeparator(state);
+			break;
+		case "blockquote_open":
+			if (state.blockquotePrefix) state.text += state.blockquotePrefix;
+			break;
+		case "blockquote_close":
+			state.text += "\n";
+			break;
+		case "bullet_list_open":
+			state.env.listStack.push({
+				type: "bullet",
+				index: 0
+			});
+			break;
+		case "bullet_list_close":
+			state.env.listStack.pop();
+			break;
+		case "ordered_list_open": {
+			const start = Number(getAttr(token, "start") ?? "1");
+			state.env.listStack.push({
+				type: "ordered",
+				index: start - 1
+			});
+			break;
+		}
+		case "ordered_list_close":
+			state.env.listStack.pop();
+			break;
+		case "list_item_open":
+			appendListPrefix(state);
+			break;
+		case "list_item_close":
+			state.text += "\n";
+			break;
+		case "code_block":
+		case "fence":
+			renderCodeBlock(state, token.content ?? "");
+			break;
+		case "html_block":
+		case "html_inline":
+			appendText(state, token.content ?? "");
+			break;
+		case "table_open":
+			if (state.tableMode !== "off") {
+				state.table = initTableState();
+				state.hasTables = true;
+			}
+			break;
+		case "table_close":
+			if (state.table) {
+				if (state.tableMode === "bullets") renderTableAsBullets(state);
+				else if (state.tableMode === "code") renderTableAsCode(state);
+			}
+			state.table = null;
+			break;
+		case "thead_open":
+			if (state.table) state.table.inHeader = true;
+			break;
+		case "thead_close":
+			if (state.table) state.table.inHeader = false;
+			break;
+		case "tbody_open":
+		case "tbody_close": break;
+		case "tr_open":
+			if (state.table) state.table.currentRow = [];
+			break;
+		case "tr_close":
+			if (state.table) {
+				if (state.table.inHeader) state.table.headers = state.table.currentRow;
+				else state.table.rows.push(state.table.currentRow);
+				state.table.currentRow = [];
+			}
+			break;
+		case "th_open":
+		case "td_open":
+			if (state.table) state.table.currentCell = initRenderTarget();
+			break;
+		case "th_close":
+		case "td_close":
+			if (state.table?.currentCell) {
+				state.table.currentRow.push(finishTableCell(state.table.currentCell));
+				state.table.currentCell = null;
+			}
+			break;
+		case "hr":
+			state.text += "\n";
+			break;
+		default:
+			if (token.children) renderTokens(token.children, state);
+			break;
+	}
+}
+function closeRemainingStyles(target) {
+	for (let i = target.openStyles.length - 1; i >= 0; i -= 1) {
+		const open = target.openStyles[i];
+		const end = target.text.length;
+		if (end > open.start) target.styles.push({
+			start: open.start,
+			end,
+			style: open.style
+		});
+	}
+	target.openStyles = [];
+}
+function clampStyleSpans(spans, maxLength) {
+	const clamped = [];
+	for (const span of spans) {
+		const start = Math.max(0, Math.min(span.start, maxLength));
+		const end = Math.max(start, Math.min(span.end, maxLength));
+		if (end > start) clamped.push({
+			start,
+			end,
+			style: span.style
+		});
+	}
+	return clamped;
+}
+function clampLinkSpans(spans, maxLength) {
+	const clamped = [];
+	for (const span of spans) {
+		const start = Math.max(0, Math.min(span.start, maxLength));
+		const end = Math.max(start, Math.min(span.end, maxLength));
+		if (end > start) clamped.push({
+			start,
+			end,
+			href: span.href
+		});
+	}
+	return clamped;
+}
+function mergeStyleSpans(spans) {
+	const sorted = [...spans].toSorted((a, b) => {
+		if (a.start !== b.start) return a.start - b.start;
+		if (a.end !== b.end) return a.end - b.end;
+		return a.style.localeCompare(b.style);
+	});
+	const merged = [];
+	for (const span of sorted) {
+		const prev = merged[merged.length - 1];
+		if (prev && prev.style === span.style && span.start <= prev.end) {
+			prev.end = Math.max(prev.end, span.end);
+			continue;
+		}
+		merged.push({ ...span });
+	}
+	return merged;
+}
+function sliceStyleSpans(spans, start, end) {
+	if (spans.length === 0) return [];
+	const sliced = [];
+	for (const span of spans) {
+		const sliceStart = Math.max(span.start, start);
+		const sliceEnd = Math.min(span.end, end);
+		if (sliceEnd > sliceStart) sliced.push({
+			start: sliceStart - start,
+			end: sliceEnd - start,
+			style: span.style
+		});
+	}
+	return mergeStyleSpans(sliced);
+}
+function sliceLinkSpans(spans, start, end) {
+	if (spans.length === 0) return [];
+	const sliced = [];
+	for (const span of spans) {
+		const sliceStart = Math.max(span.start, start);
+		const sliceEnd = Math.min(span.end, end);
+		if (sliceEnd > sliceStart) sliced.push({
+			start: sliceStart - start,
+			end: sliceEnd - start,
+			href: span.href
+		});
+	}
+	return sliced;
+}
+function markdownToIR(markdown, options = {}) {
+	return markdownToIRWithMeta(markdown, options).ir;
+}
+function markdownToIRWithMeta(markdown, options = {}) {
+	const env = { listStack: [] };
+	const tokens = createMarkdownIt(options).parse(markdown ?? "", env);
+	if (options.enableSpoilers) applySpoilerTokens(tokens);
+	const tableMode = options.tableMode ?? "off";
+	const state = {
+		text: "",
+		styles: [],
+		openStyles: [],
+		links: [],
+		linkStack: [],
+		env,
+		headingStyle: options.headingStyle ?? "none",
+		blockquotePrefix: options.blockquotePrefix ?? "",
+		enableSpoilers: options.enableSpoilers ?? false,
+		tableMode,
+		table: null,
+		hasTables: false
+	};
+	renderTokens(tokens, state);
+	closeRemainingStyles(state);
+	const trimmedLength = state.text.trimEnd().length;
+	let codeBlockEnd = 0;
+	for (const span of state.styles) {
+		if (span.style !== "code_block") continue;
+		if (span.end > codeBlockEnd) codeBlockEnd = span.end;
+	}
+	const finalLength = Math.max(trimmedLength, codeBlockEnd);
+	return {
+		ir: {
+			text: finalLength === state.text.length ? state.text : state.text.slice(0, finalLength),
+			styles: mergeStyleSpans(clampStyleSpans(state.styles, finalLength)),
+			links: clampLinkSpans(state.links, finalLength)
+		},
+		hasTables: state.hasTables
+	};
+}
+function chunkMarkdownIR(ir, limit) {
+	if (!ir.text) return [];
+	if (limit <= 0 || ir.text.length <= limit) return [ir];
+	const chunks = chunkText(ir.text, limit);
+	const results = [];
+	let cursor = 0;
+	chunks.forEach((chunk, index) => {
+		if (!chunk) return;
+		if (index > 0) while (cursor < ir.text.length && /\s/.test(ir.text[cursor] ?? "")) cursor += 1;
+		const start = cursor;
+		const end = Math.min(ir.text.length, start + chunk.length);
+		results.push({
+			text: chunk,
+			styles: sliceStyleSpans(ir.styles, start, end),
+			links: sliceLinkSpans(ir.links, start, end)
+		});
+		cursor = end;
+	});
+	return results;
+}
+
+//#endregion
+//#region src/signal/client.ts
+const DEFAULT_TIMEOUT_MS = 1e4;
+function normalizeBaseUrl(url) {
+	const trimmed = url.trim();
+	if (!trimmed) throw new Error("Signal base URL is required");
+	if (/^https?:\/\//i.test(trimmed)) return trimmed.replace(/\/+$/, "");
+	return `http://${trimmed}`.replace(/\/+$/, "");
+}
+async function fetchWithTimeout(url, init, timeoutMs) {
+	const fetchImpl = resolveFetch();
+	if (!fetchImpl) throw new Error("fetch is not available");
+	const controller = new AbortController();
+	const timer = setTimeout(() => controller.abort(), timeoutMs);
+	try {
+		return await fetchImpl(url, {
+			...init,
+			signal: controller.signal
+		});
+	} finally {
+		clearTimeout(timer);
+	}
+}
+async function signalRpcRequest(method, params, opts) {
+	const baseUrl = normalizeBaseUrl(opts.baseUrl);
+	const id = randomUUID();
+	const body = JSON.stringify({
+		jsonrpc: "2.0",
+		method,
+		params,
+		id
+	});
+	const res = await fetchWithTimeout(`${baseUrl}/api/v1/rpc`, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body
+	}, opts.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+	if (res.status === 201) return;
+	const text = await res.text();
+	if (!text) throw new Error(`Signal RPC empty response (status ${res.status})`);
+	const parsed = JSON.parse(text);
+	if (parsed.error) {
+		const code = parsed.error.code ?? "unknown";
+		const msg = parsed.error.message ?? "Signal RPC error";
+		throw new Error(`Signal RPC ${code}: ${msg}`);
+	}
+	return parsed.result;
+}
+async function signalCheck(baseUrl, timeoutMs = DEFAULT_TIMEOUT_MS) {
+	const normalized = normalizeBaseUrl(baseUrl);
+	try {
+		const res = await fetchWithTimeout(`${normalized}/api/v1/check`, { method: "GET" }, timeoutMs);
+		if (!res.ok) return {
+			ok: false,
+			status: res.status,
+			error: `HTTP ${res.status}`
+		};
+		return {
+			ok: true,
+			status: res.status,
+			error: null
+		};
+	} catch (err) {
+		return {
+			ok: false,
+			status: null,
+			error: err instanceof Error ? err.message : String(err)
+		};
+	}
+}
+async function streamSignalEvents(params) {
+	const baseUrl = normalizeBaseUrl(params.baseUrl);
+	const url = new URL(`${baseUrl}/api/v1/events`);
+	if (params.account) url.searchParams.set("account", params.account);
+	const fetchImpl = resolveFetch();
+	if (!fetchImpl) throw new Error("fetch is not available");
+	const res = await fetchImpl(url, {
+		method: "GET",
+		headers: { Accept: "text/event-stream" },
+		signal: params.abortSignal
+	});
+	if (!res.ok || !res.body) throw new Error(`Signal SSE failed (${res.status} ${res.statusText || "error"})`);
+	const reader = res.body.getReader();
+	const decoder = new TextDecoder();
+	let buffer = "";
+	let currentEvent = {};
+	const flushEvent = () => {
+		if (!currentEvent.data && !currentEvent.event && !currentEvent.id) return;
+		params.onEvent({
+			event: currentEvent.event,
+			data: currentEvent.data,
+			id: currentEvent.id
+		});
+		currentEvent = {};
+	};
+	while (true) {
+		const { value, done } = await reader.read();
+		if (done) break;
+		buffer += decoder.decode(value, { stream: true });
+		let lineEnd = buffer.indexOf("\n");
+		while (lineEnd !== -1) {
+			let line = buffer.slice(0, lineEnd);
+			buffer = buffer.slice(lineEnd + 1);
+			if (line.endsWith("\r")) line = line.slice(0, -1);
+			if (line === "") {
+				flushEvent();
+				lineEnd = buffer.indexOf("\n");
+				continue;
+			}
+			if (line.startsWith(":")) {
+				lineEnd = buffer.indexOf("\n");
+				continue;
+			}
+			const [rawField, ...rest] = line.split(":");
+			const field = rawField.trim();
+			const rawValue = rest.join(":");
+			const value = rawValue.startsWith(" ") ? rawValue.slice(1) : rawValue;
+			if (field === "event") currentEvent.event = value;
+			else if (field === "data") currentEvent.data = currentEvent.data ? `${currentEvent.data}\n${value}` : value;
+			else if (field === "id") currentEvent.id = value;
+			lineEnd = buffer.indexOf("\n");
+		}
+	}
+	flushEvent();
+}
+
+//#endregion
+//#region src/signal/format.ts
+function mapStyle(style) {
+	switch (style) {
+		case "bold": return "BOLD";
+		case "italic": return "ITALIC";
+		case "strikethrough": return "STRIKETHROUGH";
+		case "code":
+		case "code_block": return "MONOSPACE";
+		case "spoiler": return "SPOILER";
+		default: return null;
+	}
+}
+function mergeStyles(styles) {
+	const sorted = [...styles].toSorted((a, b) => {
+		if (a.start !== b.start) return a.start - b.start;
+		if (a.length !== b.length) return a.length - b.length;
+		return a.style.localeCompare(b.style);
+	});
+	const merged = [];
+	for (const style of sorted) {
+		const prev = merged[merged.length - 1];
+		if (prev && prev.style === style.style && style.start <= prev.start + prev.length) {
+			const prevEnd = prev.start + prev.length;
+			prev.length = Math.max(prevEnd, style.start + style.length) - prev.start;
+			continue;
+		}
+		merged.push({ ...style });
+	}
+	return merged;
+}
+function clampStyles(styles, maxLength) {
+	const clamped = [];
+	for (const style of styles) {
+		const start = Math.max(0, Math.min(style.start, maxLength));
+		const length = Math.min(style.start + style.length, maxLength) - start;
+		if (length > 0) clamped.push({
+			start,
+			length,
+			style: style.style
+		});
+	}
+	return clamped;
+}
+function applyInsertionsToStyles(spans, insertions) {
+	if (insertions.length === 0) return spans;
+	const sortedInsertions = [...insertions].toSorted((a, b) => a.pos - b.pos);
+	let updated = spans;
+	for (const insertion of sortedInsertions) {
+		const next = [];
+		for (const span of updated) {
+			if (span.end <= insertion.pos) {
+				next.push(span);
+				continue;
+			}
+			if (span.start >= insertion.pos) {
+				next.push({
+					start: span.start + insertion.length,
+					end: span.end + insertion.length,
+					style: span.style
+				});
+				continue;
+			}
+			if (span.start < insertion.pos && span.end > insertion.pos) {
+				if (insertion.pos > span.start) next.push({
+					start: span.start,
+					end: insertion.pos,
+					style: span.style
+				});
+				const shiftedStart = insertion.pos + insertion.length;
+				const shiftedEnd = span.end + insertion.length;
+				if (shiftedEnd > shiftedStart) next.push({
+					start: shiftedStart,
+					end: shiftedEnd,
+					style: span.style
+				});
+			}
+		}
+		updated = next;
+	}
+	return updated;
+}
+function renderSignalText(ir) {
+	const text = ir.text ?? "";
+	if (!text) return {
+		text: "",
+		styles: []
+	};
+	const sortedLinks = [...ir.links].toSorted((a, b) => a.start - b.start);
+	let out = "";
+	let cursor = 0;
+	const insertions = [];
+	for (const link of sortedLinks) {
+		if (link.start < cursor) continue;
+		out += text.slice(cursor, link.end);
+		const href = link.href.trim();
+		const trimmedLabel = text.slice(link.start, link.end).trim();
+		const comparableHref = href.startsWith("mailto:") ? href.slice(7) : href;
+		if (href) {
+			if (!trimmedLabel) {
+				out += href;
+				insertions.push({
+					pos: link.end,
+					length: href.length
+				});
+			} else if (trimmedLabel !== href && trimmedLabel !== comparableHref) {
+				const addition = ` (${href})`;
+				out += addition;
+				insertions.push({
+					pos: link.end,
+					length: addition.length
+				});
+			}
+		}
+		cursor = link.end;
+	}
+	out += text.slice(cursor);
+	const adjusted = applyInsertionsToStyles(ir.styles.map((span) => {
+		const mapped = mapStyle(span.style);
+		if (!mapped) return null;
+		return {
+			start: span.start,
+			end: span.end,
+			style: mapped
+		};
+	}).filter((span) => span !== null), insertions);
+	const trimmedText = out.trimEnd();
+	const trimmedLength = trimmedText.length;
+	return {
+		text: trimmedText,
+		styles: mergeStyles(clampStyles(adjusted.map((span) => ({
+			start: span.start,
+			length: span.end - span.start,
+			style: span.style
+		})), trimmedLength))
+	};
+}
+function markdownToSignalText(markdown, options = {}) {
+	return renderSignalText(markdownToIR(markdown ?? "", {
+		linkify: true,
+		enableSpoilers: true,
+		headingStyle: "none",
+		blockquotePrefix: "",
+		tableMode: options.tableMode
+	}));
+}
+function markdownToSignalTextChunks(markdown, limit, options = {}) {
+	return chunkMarkdownIR(markdownToIR(markdown ?? "", {
+		linkify: true,
+		enableSpoilers: true,
+		headingStyle: "none",
+		blockquotePrefix: "",
+		tableMode: options.tableMode
+	}), limit).map((chunk) => renderSignalText(chunk));
+}
+
+//#endregion
+//#region src/signal/send.ts
+function parseTarget(raw) {
+	let value = raw.trim();
+	if (!value) throw new Error("Signal recipient is required");
+	if (value.toLowerCase().startsWith("signal:")) value = value.slice(7).trim();
+	const normalized = value.toLowerCase();
+	if (normalized.startsWith("group:")) return {
+		type: "group",
+		groupId: value.slice(6).trim()
+	};
+	if (normalized.startsWith("username:")) return {
+		type: "username",
+		username: value.slice(9).trim()
+	};
+	if (normalized.startsWith("u:")) return {
+		type: "username",
+		username: value.trim()
+	};
+	return {
+		type: "recipient",
+		recipient: value
+	};
+}
+function buildTargetParams(target, allow) {
+	if (target.type === "recipient") {
+		if (!allow.recipient) return null;
+		return { recipient: [target.recipient] };
+	}
+	if (target.type === "group") {
+		if (!allow.group) return null;
+		return { groupId: target.groupId };
+	}
+	if (target.type === "username") {
+		if (!allow.username) return null;
+		return { username: [target.username] };
+	}
+	return null;
+}
+function resolveSignalRpcContext(opts, accountInfo) {
+	const hasBaseUrl = Boolean(opts.baseUrl?.trim());
+	const hasAccount = Boolean(opts.account?.trim());
+	const resolvedAccount = accountInfo || (!hasBaseUrl || !hasAccount ? resolveSignalAccount({
+		cfg: loadConfig(),
+		accountId: opts.accountId
+	}) : void 0);
+	const baseUrl = opts.baseUrl?.trim() || resolvedAccount?.baseUrl;
+	if (!baseUrl) throw new Error("Signal base URL is required");
+	return {
+		baseUrl,
+		account: opts.account?.trim() || resolvedAccount?.config.account?.trim()
+	};
+}
+async function resolveAttachment(mediaUrl, maxBytes) {
+	const media = await loadWebMedia(mediaUrl, maxBytes);
+	const saved = await saveMediaBuffer(media.buffer, media.contentType ?? void 0, "outbound", maxBytes);
+	return {
+		path: saved.path,
+		contentType: saved.contentType
+	};
+}
+async function sendMessageSignal(to, text, opts = {}) {
+	const cfg = loadConfig();
+	const accountInfo = resolveSignalAccount({
+		cfg,
+		accountId: opts.accountId
+	});
+	const { baseUrl, account } = resolveSignalRpcContext(opts, accountInfo);
+	const target = parseTarget(to);
+	let message = text ?? "";
+	let messageFromPlaceholder = false;
+	let textStyles = [];
+	const textMode = opts.textMode ?? "markdown";
+	const maxBytes = (() => {
+		if (typeof opts.maxBytes === "number") return opts.maxBytes;
+		if (typeof accountInfo.config.mediaMaxMb === "number") return accountInfo.config.mediaMaxMb * 1024 * 1024;
+		if (typeof cfg.agents?.defaults?.mediaMaxMb === "number") return cfg.agents.defaults.mediaMaxMb * 1024 * 1024;
+		return 8 * 1024 * 1024;
+	})();
+	let attachments;
+	if (opts.mediaUrl?.trim()) {
+		const resolved = await resolveAttachment(opts.mediaUrl.trim(), maxBytes);
+		attachments = [resolved.path];
+		const kind = mediaKindFromMime(resolved.contentType ?? void 0);
+		if (!message && kind) {
+			message = kind === "image" ? "<media:image>" : `<media:${kind}>`;
+			messageFromPlaceholder = true;
+		}
+	}
+	if (message.trim() && !messageFromPlaceholder) if (textMode === "plain") textStyles = opts.textStyles ?? [];
+	else {
+		const tableMode = resolveMarkdownTableMode({
+			cfg,
+			channel: "signal",
+			accountId: accountInfo.accountId
+		});
+		const formatted = markdownToSignalText(message, { tableMode });
+		message = formatted.text;
+		textStyles = formatted.styles;
+	}
+	if (!message.trim() && (!attachments || attachments.length === 0)) throw new Error("Signal send requires text or media");
+	const params = { message };
+	if (textStyles.length > 0) params["text-style"] = textStyles.map((style) => `${style.start}:${style.length}:${style.style}`);
+	if (account) params.account = account;
+	if (attachments && attachments.length > 0) params.attachments = attachments;
+	const targetParams = buildTargetParams(target, {
+		recipient: true,
+		group: true,
+		username: true
+	});
+	if (!targetParams) throw new Error("Signal recipient is required");
+	Object.assign(params, targetParams);
+	const timestamp = (await signalRpcRequest("send", params, {
+		baseUrl,
+		timeoutMs: opts.timeoutMs
+	}))?.timestamp;
+	return {
+		messageId: timestamp ? String(timestamp) : "unknown",
+		timestamp
+	};
+}
+async function sendTypingSignal(to, opts = {}) {
+	const { baseUrl, account } = resolveSignalRpcContext(opts);
+	const targetParams = buildTargetParams(parseTarget(to), {
+		recipient: true,
+		group: true
+	});
+	if (!targetParams) return false;
+	const params = { ...targetParams };
+	if (account) params.account = account;
+	if (opts.stop) params.stop = true;
+	await signalRpcRequest("sendTyping", params, {
+		baseUrl,
+		timeoutMs: opts.timeoutMs
+	});
+	return true;
+}
+async function sendReadReceiptSignal(to, targetTimestamp, opts = {}) {
+	if (!Number.isFinite(targetTimestamp) || targetTimestamp <= 0) return false;
+	const { baseUrl, account } = resolveSignalRpcContext(opts);
+	const targetParams = buildTargetParams(parseTarget(to), { recipient: true });
+	if (!targetParams) return false;
+	const params = {
+		...targetParams,
+		targetTimestamp,
+		type: opts.type ?? "read"
+	};
+	if (account) params.account = account;
+	await signalRpcRequest("sendReceipt", params, {
+		baseUrl,
+		timeoutMs: opts.timeoutMs
+	});
+	return true;
+}
+
+//#endregion
+//#region src/utils/directive-tags.ts
+const AUDIO_TAG_RE = /\[\[\s*audio_as_voice\s*\]\]/gi;
+const REPLY_TAG_RE = /\[\[\s*(?:reply_to_current|reply_to\s*:\s*([^\]\n]+))\s*\]\]/gi;
+function normalizeDirectiveWhitespace(text) {
+	return text.replace(/[ \t]+/g, " ").replace(/[ \t]*\n[ \t]*/g, "\n").trim();
+}
+function parseInlineDirectives(text, options = {}) {
+	const { currentMessageId, stripAudioTag = true, stripReplyTags = true } = options;
+	if (!text) return {
+		text: "",
+		audioAsVoice: false,
+		replyToCurrent: false,
+		hasAudioTag: false,
+		hasReplyTag: false
+	};
+	let cleaned = text;
+	let audioAsVoice = false;
+	let hasAudioTag = false;
+	let hasReplyTag = false;
+	let sawCurrent = false;
+	let lastExplicitId;
+	cleaned = cleaned.replace(AUDIO_TAG_RE, (match) => {
+		audioAsVoice = true;
+		hasAudioTag = true;
+		return stripAudioTag ? " " : match;
+	});
+	cleaned = cleaned.replace(REPLY_TAG_RE, (match, idRaw) => {
+		hasReplyTag = true;
+		if (idRaw === void 0) sawCurrent = true;
+		else {
+			const id = idRaw.trim();
+			if (id) lastExplicitId = id;
+		}
+		return stripReplyTags ? " " : match;
+	});
+	cleaned = normalizeDirectiveWhitespace(cleaned);
+	const replyToId = lastExplicitId ?? (sawCurrent ? currentMessageId?.trim() || void 0 : void 0);
+	return {
+		text: cleaned,
+		audioAsVoice,
+		replyToId,
+		replyToExplicitId: lastExplicitId,
+		replyToCurrent: sawCurrent,
+		hasAudioTag,
+		hasReplyTag
+	};
+}
+
+//#endregion
+//#region src/media/audio-tags.ts
+/**
+* Extract audio mode tag from text.
+* Supports [[audio_as_voice]] to send audio as voice bubble instead of file.
+* Default is file (preserves backward compatibility).
+*/
+function parseAudioTag(text) {
+	const result = parseInlineDirectives(text, { stripReplyTags: false });
+	return {
+		text: result.text,
+		audioAsVoice: result.audioAsVoice,
+		hadTag: result.hasAudioTag
+	};
+}
+
+//#endregion
+//#region src/media/parse.ts
+const MEDIA_TOKEN_RE = /\bMEDIA:\s*`?([^\n]+)`?/gi;
+function normalizeMediaSource(src) {
+	return src.startsWith("file://") ? src.replace("file://", "") : src;
+}
+function cleanCandidate(raw) {
+	return raw.replace(/^[`"'[{(]+/, "").replace(/[`"'\\})\],]+$/, "");
+}
+function isValidMedia(candidate, opts) {
+	if (!candidate) return false;
+	if (candidate.length > 4096) return false;
+	if (!opts?.allowSpaces && /\s/.test(candidate)) return false;
+	if (/^https?:\/\//i.test(candidate)) return true;
+	return candidate.startsWith("./") && !candidate.includes("..");
+}
+function unwrapQuoted(value) {
+	const trimmed = value.trim();
+	if (trimmed.length < 2) return;
+	const first = trimmed[0];
+	if (first !== trimmed[trimmed.length - 1]) return;
+	if (first !== `"` && first !== "'" && first !== "`") return;
+	return trimmed.slice(1, -1).trim();
+}
+function isInsideFence(fenceSpans, offset) {
+	return fenceSpans.some((span) => offset >= span.start && offset < span.end);
+}
+function splitMediaFromOutput(raw) {
+	const trimmedRaw = raw.trimEnd();
+	if (!trimmedRaw.trim()) return { text: "" };
+	const media = [];
+	let foundMediaToken = false;
+	const fenceSpans = parseFenceSpans(trimmedRaw);
+	const lines = trimmedRaw.split("\n");
+	const keptLines = [];
+	let lineOffset = 0;
+	for (const line of lines) {
+		if (isInsideFence(fenceSpans, lineOffset)) {
+			keptLines.push(line);
+			lineOffset += line.length + 1;
+			continue;
+		}
+		if (!line.trimStart().startsWith("MEDIA:")) {
+			keptLines.push(line);
+			lineOffset += line.length + 1;
+			continue;
+		}
+		const matches = Array.from(line.matchAll(MEDIA_TOKEN_RE));
+		if (matches.length === 0) {
+			keptLines.push(line);
+			lineOffset += line.length + 1;
+			continue;
+		}
+		const pieces = [];
+		let cursor = 0;
+		for (const match of matches) {
+			const start = match.index ?? 0;
+			pieces.push(line.slice(cursor, start));
+			const payload = match[1];
+			const unwrapped = unwrapQuoted(payload);
+			const payloadValue = unwrapped ?? payload;
+			const parts = unwrapped ? [unwrapped] : payload.split(/\s+/).filter(Boolean);
+			const mediaStartIndex = media.length;
+			let validCount = 0;
+			const invalidParts = [];
+			let hasValidMedia = false;
+			for (const part of parts) {
+				const candidate = normalizeMediaSource(cleanCandidate(part));
+				if (isValidMedia(candidate, unwrapped ? { allowSpaces: true } : void 0)) {
+					media.push(candidate);
+					hasValidMedia = true;
+					foundMediaToken = true;
+					validCount += 1;
+				} else invalidParts.push(part);
+			}
+			const trimmedPayload = payloadValue.trim();
+			const looksLikeLocalPath = trimmedPayload.startsWith("/") || trimmedPayload.startsWith("./") || trimmedPayload.startsWith("../") || trimmedPayload.startsWith("~") || trimmedPayload.startsWith("file://");
+			if (!unwrapped && validCount === 1 && invalidParts.length > 0 && /\s/.test(payloadValue) && looksLikeLocalPath) {
+				const fallback = normalizeMediaSource(cleanCandidate(payloadValue));
+				if (isValidMedia(fallback, { allowSpaces: true })) {
+					media.splice(mediaStartIndex, media.length - mediaStartIndex, fallback);
+					hasValidMedia = true;
+					foundMediaToken = true;
+					validCount = 1;
+					invalidParts.length = 0;
+				}
+			}
+			if (!hasValidMedia) {
+				const fallback = normalizeMediaSource(cleanCandidate(payloadValue));
+				if (isValidMedia(fallback, { allowSpaces: true })) {
+					media.push(fallback);
+					hasValidMedia = true;
+					foundMediaToken = true;
+					invalidParts.length = 0;
+				}
+			}
+			if (hasValidMedia) {
+				if (invalidParts.length > 0) pieces.push(invalidParts.join(" "));
+			} else pieces.push(match[0]);
+			cursor = start + match[0].length;
+		}
+		pieces.push(line.slice(cursor));
+		const cleanedLine = pieces.join("").replace(/[ \t]{2,}/g, " ").trim();
+		if (cleanedLine) keptLines.push(cleanedLine);
+		lineOffset += line.length + 1;
+	}
+	let cleanedText = keptLines.join("\n").replace(/[ \t]+\n/g, "\n").replace(/[ \t]{2,}/g, " ").replace(/\n{2,}/g, "\n").trim();
+	const audioTagResult = parseAudioTag(cleanedText);
+	const hasAudioAsVoice = audioTagResult.audioAsVoice;
+	if (audioTagResult.hadTag) cleanedText = audioTagResult.text.replace(/\n{2,}/g, "\n").trim();
+	if (media.length === 0) {
+		const result = { text: foundMediaToken || hasAudioAsVoice ? cleanedText : trimmedRaw };
+		if (hasAudioAsVoice) result.audioAsVoice = true;
+		return result;
+	}
+	return {
+		text: cleanedText,
+		mediaUrls: media,
+		mediaUrl: media[0],
+		...hasAudioAsVoice ? { audioAsVoice: true } : {}
+	};
+}
+
+//#endregion
+//#region src/auto-reply/reply/reply-directives.ts
+function parseReplyDirectives(raw, options = {}) {
+	const split = splitMediaFromOutput(raw);
+	let text = split.text ?? "";
+	const replyParsed = parseInlineDirectives(text, {
+		currentMessageId: options.currentMessageId,
+		stripAudioTag: false,
+		stripReplyTags: true
+	});
+	if (replyParsed.hasReplyTag) text = replyParsed.text;
+	const silentToken = options.silentToken ?? SILENT_REPLY_TOKEN;
+	const isSilent = isSilentReplyText(text, silentToken);
+	if (isSilent) text = "";
+	return {
+		text,
+		mediaUrls: split.mediaUrls,
+		mediaUrl: split.mediaUrl,
+		replyToId: replyParsed.replyToId,
+		replyToCurrent: replyParsed.replyToCurrent,
+		replyToTag: replyParsed.hasReplyTag,
+		audioAsVoice: split.audioAsVoice,
+		isSilent
+	};
+}
+
+//#endregion
+//#region src/infra/outbound/target-normalization.ts
+function normalizeChannelTargetInput(raw) {
+	return raw.trim();
+}
+function normalizeTargetForProvider(provider, raw) {
+	if (!raw) return;
+	const providerId = normalizeChannelId(provider);
+	return ((providerId ? getChannelPlugin(providerId) : void 0)?.messaging?.normalizeTarget?.(raw) ?? (raw.trim().toLowerCase() || void 0)) || void 0;
+}
+function buildTargetResolverSignature(channel) {
+	const resolver = getChannelPlugin(channel)?.messaging?.targetResolver;
+	const hint = resolver?.hint ?? "";
+	const looksLike = resolver?.looksLikeId;
+	return hashSignature(`${hint}|${looksLike ? looksLike.toString() : ""}`);
+}
+function hashSignature(value) {
+	let hash = 5381;
+	for (let i = 0; i < value.length; i += 1) hash = (hash << 5) + hash ^ value.charCodeAt(i);
+	return (hash >>> 0).toString(36);
+}
+
+//#endregion
+//#region src/channels/plugins/outbound/load.ts
+const cache = /* @__PURE__ */ new Map();
+let lastRegistry = null;
+function ensureCacheForRegistry(registry) {
+	if (registry === lastRegistry) return;
+	cache.clear();
+	lastRegistry = registry;
+}
+async function loadChannelOutboundAdapter(id) {
+	const registry = getActivePluginRegistry();
+	ensureCacheForRegistry(registry);
+	const cached = cache.get(id);
+	if (cached) return cached;
+	const outbound = (registry?.channels.find((entry) => entry.plugin.id === id))?.plugin.outbound;
+	if (outbound) {
+		cache.set(id, outbound);
+		return outbound;
+	}
+}
+
+//#endregion
+//#region src/auto-reply/reply/reply-tags.ts
+function extractReplyToTag(text, currentMessageId) {
+	const result = parseInlineDirectives(text, {
+		currentMessageId,
+		stripAudioTag: false
+	});
+	return {
+		cleaned: result.text,
+		replyToId: result.replyToId,
+		replyToCurrent: result.replyToCurrent,
+		hasTag: result.hasReplyTag
+	};
+}
+
+//#endregion
+//#region src/auto-reply/reply/reply-threading.ts
+function resolveReplyToMode(cfg, channel, accountId, chatType) {
+	const provider = normalizeChannelId(channel);
+	if (!provider) return "all";
+	return getChannelDock(provider)?.threading?.resolveReplyToMode?.({
+		cfg,
+		accountId,
+		chatType
+	}) ?? "all";
+}
+function createReplyToModeFilter(mode, opts = {}) {
+	let hasThreaded = false;
+	return (payload) => {
+		if (!payload.replyToId) return payload;
+		if (mode === "off") {
+			if (opts.allowTagsWhenOff && payload.replyToTag) return payload;
+			return {
+				...payload,
+				replyToId: void 0
+			};
+		}
+		if (mode === "all") return payload;
+		if (hasThreaded) return {
+			...payload,
+			replyToId: void 0
+		};
+		hasThreaded = true;
+		return payload;
+	};
+}
+function createReplyToModeFilterForChannel(mode, channel) {
+	const provider = normalizeChannelId(channel);
+	return createReplyToModeFilter(mode, { allowTagsWhenOff: provider ? Boolean(getChannelDock(provider)?.threading?.allowTagsWhenOff) : false });
+}
+
+//#endregion
+//#region src/auto-reply/reply/reply-payloads.ts
+function applyReplyTagsToPayload(payload, currentMessageId) {
+	if (typeof payload.text !== "string") {
+		if (!payload.replyToCurrent || payload.replyToId) return payload;
+		return {
+			...payload,
+			replyToId: currentMessageId?.trim() || void 0
+		};
+	}
+	if (!payload.text.includes("[[")) {
+		if (!payload.replyToCurrent || payload.replyToId) return payload;
+		return {
+			...payload,
+			replyToId: currentMessageId?.trim() || void 0,
+			replyToTag: payload.replyToTag ?? true
+		};
+	}
+	const { cleaned, replyToId, replyToCurrent, hasTag } = extractReplyToTag(payload.text, currentMessageId);
+	return {
+		...payload,
+		text: cleaned ? cleaned : void 0,
+		replyToId: replyToId ?? payload.replyToId,
+		replyToTag: hasTag || payload.replyToTag,
+		replyToCurrent: replyToCurrent || payload.replyToCurrent
+	};
+}
+function isRenderablePayload(payload) {
+	return Boolean(payload.text || payload.mediaUrl || payload.mediaUrls && payload.mediaUrls.length > 0 || payload.audioAsVoice || payload.channelData);
+}
+function applyReplyThreading(params) {
+	const { payloads, replyToMode, replyToChannel, currentMessageId } = params;
+	const applyReplyToMode = createReplyToModeFilterForChannel(replyToMode, replyToChannel);
+	return payloads.map((payload) => applyReplyTagsToPayload(payload, currentMessageId)).filter(isRenderablePayload).map(applyReplyToMode);
+}
+function filterMessagingToolDuplicates(params) {
+	const { payloads, sentTexts } = params;
+	if (sentTexts.length === 0) return payloads;
+	return payloads.filter((payload) => !isMessagingToolDuplicate(payload.text ?? "", sentTexts));
+}
+function normalizeAccountId(value) {
+	const trimmed = value?.trim();
+	return trimmed ? trimmed.toLowerCase() : void 0;
+}
+function shouldSuppressMessagingToolReplies(params) {
+	const provider = params.messageProvider?.trim().toLowerCase();
+	if (!provider) return false;
+	const originTarget = normalizeTargetForProvider(provider, params.originatingTo);
+	if (!originTarget) return false;
+	const originAccount = normalizeAccountId(params.accountId);
+	const sentTargets = params.messagingToolSentTargets ?? [];
+	if (sentTargets.length === 0) return false;
+	return sentTargets.some((target) => {
+		if (!target?.provider) return false;
+		if (target.provider.trim().toLowerCase() !== provider) return false;
+		const targetKey = normalizeTargetForProvider(provider, target.to);
+		if (!targetKey) return false;
+		const targetAccount = normalizeAccountId(target.accountId);
+		if (originAccount && targetAccount && originAccount !== targetAccount) return false;
+		return targetKey === originTarget;
+	});
+}
+
+//#endregion
+//#region src/infra/outbound/payloads.ts
+function mergeMediaUrls(...lists) {
+	const seen = /* @__PURE__ */ new Set();
+	const merged = [];
+	for (const list of lists) {
+		if (!list) continue;
+		for (const entry of list) {
+			const trimmed = entry?.trim();
+			if (!trimmed) continue;
+			if (seen.has(trimmed)) continue;
+			seen.add(trimmed);
+			merged.push(trimmed);
+		}
+	}
+	return merged;
+}
+function normalizeReplyPayloadsForDelivery(payloads) {
+	return payloads.flatMap((payload) => {
+		const parsed = parseReplyDirectives(payload.text ?? "");
+		const explicitMediaUrls = payload.mediaUrls ?? parsed.mediaUrls;
+		const explicitMediaUrl = payload.mediaUrl ?? parsed.mediaUrl;
+		const mergedMedia = mergeMediaUrls(explicitMediaUrls, explicitMediaUrl ? [explicitMediaUrl] : void 0);
+		const resolvedMediaUrl = (explicitMediaUrls?.length ?? 0) > 1 ? void 0 : explicitMediaUrl;
+		const next = {
+			...payload,
+			text: parsed.text ?? "",
+			mediaUrls: mergedMedia.length ? mergedMedia : void 0,
+			mediaUrl: resolvedMediaUrl,
+			replyToId: payload.replyToId ?? parsed.replyToId,
+			replyToTag: payload.replyToTag || parsed.replyToTag,
+			replyToCurrent: payload.replyToCurrent || parsed.replyToCurrent,
+			audioAsVoice: Boolean(payload.audioAsVoice || parsed.audioAsVoice)
+		};
+		if (parsed.isSilent && mergedMedia.length === 0) return [];
+		if (!isRenderablePayload(next)) return [];
+		return [next];
+	});
+}
+
+//#endregion
+//#region src/infra/outbound/deliver.ts
+var deliver_exports = /* @__PURE__ */ __exportAll({ deliverOutboundPayloads: () => deliverOutboundPayloads });
+function throwIfAborted(abortSignal) {
+	if (abortSignal?.aborted) throw new Error("Outbound delivery aborted");
+}
+async function createChannelHandler(params) {
+	const outbound = await loadChannelOutboundAdapter(params.channel);
+	if (!outbound?.sendText || !outbound?.sendMedia) throw new Error(`Outbound not configured for channel: ${params.channel}`);
+	const handler = createPluginHandler({
+		outbound,
+		cfg: params.cfg,
+		channel: params.channel,
+		to: params.to,
+		accountId: params.accountId,
+		replyToId: params.replyToId,
+		threadId: params.threadId,
+		deps: params.deps,
+		gifPlayback: params.gifPlayback
+	});
+	if (!handler) throw new Error(`Outbound not configured for channel: ${params.channel}`);
+	return handler;
+}
+function createPluginHandler(params) {
+	const outbound = params.outbound;
+	if (!outbound?.sendText || !outbound?.sendMedia) return null;
+	const sendText = outbound.sendText;
+	const sendMedia = outbound.sendMedia;
+	return {
+		chunker: outbound.chunker ?? null,
+		chunkerMode: outbound.chunkerMode,
+		textChunkLimit: outbound.textChunkLimit,
+		sendPayload: outbound.sendPayload ? async (payload) => outbound.sendPayload({
+			cfg: params.cfg,
+			to: params.to,
+			text: payload.text ?? "",
+			mediaUrl: payload.mediaUrl,
+			accountId: params.accountId,
+			replyToId: params.replyToId,
+			threadId: params.threadId,
+			gifPlayback: params.gifPlayback,
+			deps: params.deps,
+			payload
+		}) : void 0,
+		sendText: async (text) => sendText({
+			cfg: params.cfg,
+			to: params.to,
+			text,
+			accountId: params.accountId,
+			replyToId: params.replyToId,
+			threadId: params.threadId,
+			gifPlayback: params.gifPlayback,
+			deps: params.deps
+		}),
+		sendMedia: async (caption, mediaUrl) => sendMedia({
+			cfg: params.cfg,
+			to: params.to,
+			text: caption,
+			mediaUrl,
+			accountId: params.accountId,
+			replyToId: params.replyToId,
+			threadId: params.threadId,
+			gifPlayback: params.gifPlayback,
+			deps: params.deps
+		})
+	};
+}
+async function deliverOutboundPayloads(params) {
+	const { cfg, channel, to, payloads } = params;
+	const accountId = params.accountId;
+	const deps = params.deps;
+	const abortSignal = params.abortSignal;
+	const sendSignal = params.deps?.sendSignal ?? sendMessageSignal;
+	const results = [];
+	const handler = await createChannelHandler({
+		cfg,
+		channel,
+		to,
+		deps,
+		accountId,
+		replyToId: params.replyToId,
+		threadId: params.threadId,
+		gifPlayback: params.gifPlayback
+	});
+	const textLimit = handler.chunker ? resolveTextChunkLimit(cfg, channel, accountId, { fallbackLimit: handler.textChunkLimit }) : void 0;
+	const chunkMode = handler.chunker ? resolveChunkMode(cfg, channel, accountId) : "length";
+	const isSignalChannel = channel === "signal";
+	const signalTableMode = isSignalChannel ? resolveMarkdownTableMode({
+		cfg,
+		channel: "signal",
+		accountId
+	}) : "code";
+	const signalMaxBytes = isSignalChannel ? resolveChannelMediaMaxBytes({
+		cfg,
+		resolveChannelLimitMb: ({ cfg, accountId }) => cfg.channels?.signal?.accounts?.[accountId]?.mediaMaxMb ?? cfg.channels?.signal?.mediaMaxMb,
+		accountId
+	}) : void 0;
+	const sendTextChunks = async (text) => {
+		throwIfAborted(abortSignal);
+		if (!handler.chunker || textLimit === void 0) {
+			results.push(await handler.sendText(text));
+			return;
+		}
+		if (chunkMode === "newline") {
+			const blockChunks = (handler.chunkerMode ?? "text") === "markdown" ? chunkMarkdownTextWithMode(text, textLimit, "newline") : chunkByParagraph(text, textLimit);
+			if (!blockChunks.length && text) blockChunks.push(text);
+			for (const blockChunk of blockChunks) {
+				const chunks = handler.chunker(blockChunk, textLimit);
+				if (!chunks.length && blockChunk) chunks.push(blockChunk);
+				for (const chunk of chunks) {
+					throwIfAborted(abortSignal);
+					results.push(await handler.sendText(chunk));
+				}
+			}
+			return;
+		}
+		const chunks = handler.chunker(text, textLimit);
+		for (const chunk of chunks) {
+			throwIfAborted(abortSignal);
+			results.push(await handler.sendText(chunk));
+		}
+	};
+	const sendSignalText = async (text, styles) => {
+		throwIfAborted(abortSignal);
+		return {
+			channel: "signal",
+			...await sendSignal(to, text, {
+				maxBytes: signalMaxBytes,
+				accountId: accountId ?? void 0,
+				textMode: "plain",
+				textStyles: styles
+			})
+		};
+	};
+	const sendSignalTextChunks = async (text) => {
+		throwIfAborted(abortSignal);
+		let signalChunks = textLimit === void 0 ? markdownToSignalTextChunks(text, Number.POSITIVE_INFINITY, { tableMode: signalTableMode }) : markdownToSignalTextChunks(text, textLimit, { tableMode: signalTableMode });
+		if (signalChunks.length === 0 && text) signalChunks = [{
+			text,
+			styles: []
+		}];
+		for (const chunk of signalChunks) {
+			throwIfAborted(abortSignal);
+			results.push(await sendSignalText(chunk.text, chunk.styles));
+		}
+	};
+	const sendSignalMedia = async (caption, mediaUrl) => {
+		throwIfAborted(abortSignal);
+		const formatted = markdownToSignalTextChunks(caption, Number.POSITIVE_INFINITY, { tableMode: signalTableMode })[0] ?? {
+			text: caption,
+			styles: []
+		};
+		return {
+			channel: "signal",
+			...await sendSignal(to, formatted.text, {
+				mediaUrl,
+				maxBytes: signalMaxBytes,
+				accountId: accountId ?? void 0,
+				textMode: "plain",
+				textStyles: formatted.styles
+			})
+		};
+	};
+	const normalizedPayloads = normalizeReplyPayloadsForDelivery(payloads);
+	for (const payload of normalizedPayloads) {
+		const payloadSummary = {
+			text: payload.text ?? "",
+			mediaUrls: payload.mediaUrls ?? (payload.mediaUrl ? [payload.mediaUrl] : []),
+			channelData: payload.channelData
+		};
+		try {
+			throwIfAborted(abortSignal);
+			params.onPayload?.(payloadSummary);
+			if (handler.sendPayload && payload.channelData) {
+				results.push(await handler.sendPayload(payload));
+				continue;
+			}
+			if (payloadSummary.mediaUrls.length === 0) {
+				if (isSignalChannel) await sendSignalTextChunks(payloadSummary.text);
+				else await sendTextChunks(payloadSummary.text);
+				continue;
+			}
+			let first = true;
+			for (const url of payloadSummary.mediaUrls) {
+				throwIfAborted(abortSignal);
+				const caption = first ? payloadSummary.text : "";
+				first = false;
+				if (isSignalChannel) results.push(await sendSignalMedia(caption, url));
+				else results.push(await handler.sendMedia(caption, url));
+			}
+		} catch (err) {
+			if (!params.bestEffort) throw err;
+			params.onError?.(err, payloadSummary);
+		}
+	}
+	if (params.mirror && results.length > 0) {
+		const mirrorText = resolveMirroredTranscriptText({
+			text: params.mirror.text,
+			mediaUrls: params.mirror.mediaUrls
+		});
+		if (mirrorText) await appendAssistantMessageToSessionTranscript({
+			agentId: params.mirror.agentId,
+			sessionKey: params.mirror.sessionKey,
+			text: mirrorText
+		});
+	}
+	return results;
+}
+
+//#endregion
+export { chunkMarkdownText as A, loadWebMediaRaw as B, chunkMarkdownIR as C, resolveFetch as D, resolveMarkdownTableMode as E, resolveTextChunkLimit as F, HEARTBEAT_TOKEN as G, fetchRemoteMedia as H, findFenceSpanAt as I, SILENT_REPLY_TOKEN as K, isSafeFenceBreak as L, chunkText as M, chunkTextWithMode as N, wrapFetchWithAbortSignal as O, resolveChunkMode as P, parseFenceSpans as R, streamSignalEvents as S, markdownToIRWithMeta as T, fetchWithSsrFGuard as U, MediaFetchError as V, resolveChannelMediaMaxBytes as W, sendMessageSignal as _, applyReplyThreading as a, signalCheck as b, shouldSuppressMessagingToolReplies as c, buildTargetResolverSignature as d, normalizeChannelTargetInput as f, parseInlineDirectives as g, splitMediaFromOutput as h, applyReplyTagsToPayload as i, chunkMarkdownTextWithMode as j, chunkByNewline as k, createReplyToModeFilterForChannel as l, parseReplyDirectives as m, deliver_exports as n, filterMessagingToolDuplicates as o, normalizeTargetForProvider as p, isSilentReplyText as q, normalizeReplyPayloadsForDelivery as r, isRenderablePayload as s, deliverOutboundPayloads as t, resolveReplyToMode as u, sendReadReceiptSignal as v, markdownToIR as w, signalRpcRequest as x, sendTypingSignal as y, loadWebMedia as z };