@openclaw/discord 2026.9.1-beta.1 → 2026.9.2

package/dist/{retry-Cv4jCU5Z.js → retry-DQt1zDgH.js}

@@ -1,4 +1,4 @@
-import { t as parseDiscordRetryAfterBodySeconds } from "./retry-after-DdLPmPoa.js";
+import { t as parseDiscordRetryAfterBodySeconds } from "./retry-after-BrLjLUJi.js";
 import "node:module";
 import { redactIdentifier, redactSensitiveFieldValue } from "openclaw/plugin-sdk/logging-core";
 import { ApplicationCommandOptionType, ApplicationCommandType, ButtonStyle, ComponentType, GatewayDispatchEvents, InteractionContextType, InteractionResponseType, InteractionType, MessageFlags, Routes, TextInputStyle } from "discord-api-types/v10";
@@ -15,8 +15,8 @@ import { classifyTransientNetworkErrorCode, createChannelApiRetryRunner, parseRe
 import { buildMessagingTarget, parseMentionPrefixOrAtUserTarget, requireTargetKind } from "openclaw/plugin-sdk/channel-targets";
 import { sleepWithAbort } from "openclaw/plugin-sdk/runtime-env";
 import { resolveAllowlistMatchByCandidates } from "openclaw/plugin-sdk/allow-from";
-import { chunkMarkdownTextWithMode } from "openclaw/plugin-sdk/reply-chunking";
-import { chunkTextForOutbound } from "openclaw/plugin-sdk/text-chunking";
+import { chunkByParagraph } from "openclaw/plugin-sdk/reply-chunking";
+import { avoidTrailingHighSurrogateBreak, chunkTextForOutbound, findCodeRegions } from "openclaw/plugin-sdk/text-chunking";
 import { isSingleUseReplyToMode } from "openclaw/plugin-sdk/reply-reference";
 import { createMessageReceiptFromOutboundResults } from "openclaw/plugin-sdk/channel-outbound";
 import { attachChannelToResults } from "openclaw/plugin-sdk/channel-send-result";
@@ -1676,6 +1676,7 @@ var BaseInteraction = class {
 		this.message = null;
 		this.response = new InteractionResponseController();
 		this.pendingResponse = Promise.resolve();
+		this.sentFollowUp = false;
 		this.id = rawData.id;
 		this.token = rawData.token;
 		this.user = readInteractionUser(rawData, client);
@@ -1692,6 +1693,14 @@ var BaseInteraction = class {
 	set responseState(nextState) {
 		this.response.state = nextState;
 	}
+	/**
+	* True once a follow-up message has been delivered. Follow-ups are visible to
+	* the user but never advance `responseState`, so this is the only record that
+	* the interaction has already produced output.
+	*/
+	get hasSentFollowUp() {
+		return this.sentFollowUp;
+	}
 	enqueueResponse(operation) {
 		const result = this.pendingResponse.then(operation);
 		this.pendingResponse = result.then(() => void 0, () => void 0);
@@ -1726,6 +1735,24 @@ var BaseInteraction = class {
 	async editReply(payload) {
 		return await this.enqueueResponse(() => this.performReplyEdit(payload));
 	}
+	/**
+	* Edits the deferred placeholder only if this interaction is still an
+	* unanswered spinner when the queue reaches this operation.
+	*
+	* Both conditions are re-read inside the queue. A follow-up that was still in
+	* flight when the caller decided to report will have settled — and recorded
+	* itself in `sentFollowUp` — by the time this runs, so the decision cannot be
+	* made against state that is about to change.
+	*
+	* Resolves true when the edit was sent.
+	*/
+	async editDeferredPlaceholderIfUnanswered(payload) {
+		return await this.enqueueResponse(async () => {
+			if (this.responseState !== "deferred" || this.sentFollowUp) return false;
+			await this.performReplyEdit(payload);
+			return true;
+		});
+	}
 	async performReplyEdit(payload) {
 		const body = serializePayload(payload);
 		const query = needsComponentsV2Query(body) ? { with_components: true } : void 0;
@@ -1755,7 +1782,9 @@ var BaseInteraction = class {
 	}
 	async performFollowUp(payload) {
 		const body = serializePayload(payload);
-		return await createWebhookMessage(this.client.rest, this.client.options.clientId, this.token, { body }, needsComponentsV2Query(body) ? { with_components: true } : void 0);
+		const result = await createWebhookMessage(this.client.rest, this.client.options.clientId, this.token, { body }, needsComponentsV2Query(body) ? { with_components: true } : void 0);
+		this.sentFollowUp = true;
+		return result;
 	}
 };
 var CommandInteraction = class extends BaseInteraction {
@@ -1844,6 +1873,14 @@ async function dispatchInteraction(client, rawData) {
 		if (command.commandKind === "leaf") await command.autocomplete(autocompleteInteraction);
 		return;
 	}
+	try {
+		await dispatchAcknowledgeableInteraction(client, rawData, interaction);
+	} catch (error) {
+		await reportInteractionFailure(interaction);
+		throw error;
+	}
+}
+async function dispatchAcknowledgeableInteraction(client, rawData, interaction) {
 	if (rawData.type === InteractionType.ApplicationCommand) {
 		const command = client.commands.find((entry) => entry.name === readInteractionName(rawData));
 		if (command) {
@@ -1879,6 +1916,44 @@ async function dispatchInteraction(client, rawData) {
 		if (modal) await modal.run(interaction, modal.customIdParser(customId).data);
 	}
 }
+/**
+* Fixed text. The thrown error is deliberately not echoed here: an interaction
+* response is visible to the whole channel, and handler exceptions routinely
+* carry absolute paths, config keys, and provider responses. The rethrow keeps
+* the detail in the Gateway log where operators already look for it.
+*/
+const INTERACTION_FAILURE_NOTICE = "Command failed. Check the Gateway logs for details.";
+/**
+* Best-effort user-visible notice for a failed interaction. Never throws: a
+* reporting failure must not mask the original error.
+*
+* Deliberately narrow. It reports only for `deferred`, where a spinner is known
+* to exist and the original response is a placeholder this dispatch created:
+*
+* - `deferred`        the deferring callback succeeded (state advances only
+*                     after a REST success), so editing the original response
+*                     resolves a spinner that would otherwise hang forever.
+* - `deferred-update` a component acknowledgement. Discord leaves no spinner,
+*                     and the original response is the message the component is
+*                     attached to, so editing it would overwrite content the
+*                     user is still reading.
+* - `unacknowledged`  nothing is known to have reached Discord. A second
+*                     initial callback risks "already acknowledged" if the
+*                     first one landed after all, and Discord already shows its
+*                     own "did not respond" notice.
+* - `replied`         the user has seen a message, and nextReplyAction() would
+*                     turn this into a contradictory follow-up beside it.
+*/
+async function reportInteractionFailure(interaction) {
+	if (interaction.responseState !== "deferred") return;
+	if (interaction.hasSentFollowUp) return;
+	try {
+		await interaction.editDeferredPlaceholderIfUnanswered({
+			content: INTERACTION_FAILURE_NOTICE,
+			allowed_mentions: { parse: [] }
+		});
+	} catch {}
+}
 function resolveConditionalComponentOption(value, interaction) {
 	return typeof value === "function" ? value(interaction) : value;
 }
@@ -2054,7 +2129,8 @@ function redactDiscordErrorBody(body, fieldKey = "", sensitiveAncestorKey, state
 	return redacted;
 }
 function readDiscordCode(body) {
-	return parseStrictNonNegativeInteger(body && typeof body === "object" && "code" in body ? body.code : void 0);
+	const value = body && typeof body === "object" && "code" in body ? body.code : void 0;
+	return parseStrictNonNegativeInteger(value);
 }
 function readDiscordMessage(body, fallback) {
 	const value = body && typeof body === "object" && "message" in body ? body.message : void 0;
@@ -2064,7 +2140,8 @@ function isUnknownDiscordVoiceStateError(err) {
 	return (err && typeof err === "object" && "discordCode" in err ? parseStrictNonNegativeInteger(err.discordCode) : void 0) === DISCORD_UNKNOWN_VOICE_STATE || /unknown voice state/i.test(formatErrorMessage(err));
 }
 function readRetryAfter(body, response, fallbackSeconds = 0) {
-	return parseDiscordRetryAfterBodySeconds(body && typeof body === "object" && "retry_after" in body ? body.retry_after : void 0) ?? parseRetryAfterHeaderSeconds(response.headers.get("Retry-After")) ?? fallbackSeconds;
+	const bodyValue = body && typeof body === "object" && "retry_after" in body ? body.retry_after : void 0;
+	return parseDiscordRetryAfterBodySeconds(bodyValue) ?? parseRetryAfterHeaderSeconds(response.headers.get("Retry-After")) ?? fallbackSeconds;
 }
 function readDiscordRateLimitBucket(response) {
 	const value = response.headers.get("X-RateLimit-Bucket")?.trim();
@@ -2076,7 +2153,8 @@ function readDiscordRateLimitScope(response) {
 }
 var DiscordError = class extends Error {
 	constructor(response, body) {
-		const redactedMessage = redactSensitiveFieldValue("message", readDiscordMessage(body, `Discord API request failed (${response.status})`));
+		const fallbackMessage = `Discord API request failed (${response.status})`;
+		const redactedMessage = redactSensitiveFieldValue("message", readDiscordMessage(body, fallbackMessage));
 		const redactedBody = redactDiscordErrorBody(body);
 		super(redactedMessage);
 		this.name = "DiscordError";
@@ -2149,7 +2227,7 @@ function appendQuery(path, query) {
 }
 //#endregion
 //#region extensions/discord/src/internal/rest-scheduler.ts
-const INVALID_REQUEST_WINDOW_MS = 10 * 6e4;
+const INVALID_REQUEST_WINDOW_MS = 6e5;
 const requestPriorities = [
 	"critical",
 	"standard",
@@ -2538,7 +2616,7 @@ const defaultLaneOptions = {
 		weight: 1
 	}
 };
-const DISCORD_REST_RESPONSE_BODY_MAX_BYTES = 8 * 1024 * 1024;
+const DISCORD_REST_RESPONSE_BODY_MAX_BYTES = 8388608;
 const GZIP_MAGIC = [31, 139];
 function createResponseBodyOverflowError(size) {
 	return /* @__PURE__ */ new Error(`Discord REST response body exceeds ${DISCORD_REST_RESPONSE_BODY_MAX_BYTES} bytes (received ${size})`);
@@ -3057,9 +3135,10 @@ function parseDiscordProviderPrefixedTarget(raw) {
 	return buildMessagingTarget(kind, id, `${kind}:${id}`);
 }
 function resolveDiscordChannelId(raw) {
+	const target = parseDiscordTarget(raw, { defaultKind: "channel" });
 	return requireTargetKind({
 		platform: "Discord",
-		target: parseDiscordTarget(raw, { defaultKind: "channel" }),
+		target,
 		kind: "channel"
 	});
 }
@@ -3098,8 +3177,9 @@ function normalizeDiscordOutboundTarget(to, allowFrom) {
 function allowFromContainsDiscordUserId(allowFrom, userId) {
 	const normalizedUserId = userId.trim();
 	if (!normalizedUserId) return false;
+	const normalizedAllowFrom = (allowFrom ?? []).map(normalizeAllowFromDiscordUserId).filter((entry) => Boolean(entry));
 	return resolveAllowlistMatchByCandidates({
-		allowList: (allowFrom ?? []).map(normalizeAllowFromDiscordUserId).filter((entry) => Boolean(entry)),
+		allowList: normalizedAllowFrom,
 		candidates: [{
 			value: normalizedUserId,
 			source: "id"
@@ -3174,35 +3254,36 @@ function createDiscordSendReceiptFromResults(params) {
 	};
 }
 function createDiscordSendReceipt(params) {
-	return createMessageReceiptFromOutboundResults({
-		results: params.platformMessageIds.map((messageId) => messageId.trim()).filter((messageId) => messageId && messageId !== "unknown").map((messageId, index) => {
-			const result = {
+	const results = params.platformMessageIds.map((messageId) => messageId.trim()).filter(Boolean).map((messageId, index) => {
+		const result = {
+			channel: "discord",
+			messageId
+		};
+		if (params.channelId) result.channelId = params.channelId;
+		if (params.reply?.scope === "first" && index === 0) {
+			const rawResult = {
 				channel: "discord",
 				messageId
 			};
-			if (params.channelId) result.channelId = params.channelId;
-			if (params.reply?.scope === "first" && index === 0) {
-				const rawResult = {
-					channel: "discord",
-					messageId
-				};
-				if (params.channelId) rawResult.channelId = params.channelId;
-				result.receipt = createMessageReceiptFromOutboundResults({
-					results: [rawResult],
-					kind: params.kind,
-					threadId: params.threadId,
-					replyToId: params.reply.messageId
-				});
-			}
-			return result;
-		}),
+			if (params.channelId) rawResult.channelId = params.channelId;
+			result.receipt = createMessageReceiptFromOutboundResults({
+				results: [rawResult],
+				kind: params.kind,
+				threadId: params.threadId,
+				replyToId: params.reply.messageId
+			});
+		}
+		return result;
+	});
+	return createMessageReceiptFromOutboundResults({
+		results,
 		kind: params.kind,
 		threadId: params.threadId,
 		replyToId: params.reply?.scope === "all" ? params.reply.messageId : void 0
 	});
 }
 function createDiscordSendResult(params) {
-	const messageId = params.result.id || "unknown";
+	const messageId = params.result.id ?? "";
 	const channelId = params.result.channel_id ?? params.fallbackChannelId;
 	const receiptParams = {
 		platformMessageIds: params.result.platformMessageIds?.length ? params.result.platformMessageIds : [messageId],
@@ -3234,213 +3315,268 @@ function countLines(text) {
 	if (!text) return 0;
 	return text.split("\n").length;
 }
-function parseFenceLine(line) {
+function parseFenceLine(line, maxChars = Number.POSITIVE_INFINITY) {
 	const match = line.match(FENCE_RE);
 	if (!match) return null;
-	const indent = match[1] ?? "";
 	const marker = match[2] ?? "";
+	const closeLine = (match[1] ?? "") + marker;
+	const canBalance = closeLine.length * 2 + 3 <= maxChars;
+	const reopenLine = line.length + closeLine.length + 3 <= maxChars ? line : closeLine;
 	return {
-		indent,
-		markerChar: marker[0] ?? "`",
-		markerLen: marker.length,
-		openLine: line
+		marker,
+		closeLine,
+		reopenLine: canBalance ? reopenLine : null
 	};
 }
-function closeFenceLine(openFence) {
-	return `${openFence.indent}${openFence.markerChar.repeat(openFence.markerLen)}`;
-}
-function canBalanceFence(openFence, maxChars) {
-	return closeFenceLine(openFence).length * 2 + 3 <= maxChars;
-}
-function reopenFenceLine(openFence, maxChars) {
-	const bareMarker = closeFenceLine(openFence);
-	if (!canBalanceFence(openFence, maxChars)) return null;
-	if (openFence.openLine.length + bareMarker.length + 3 <= maxChars) return openFence.openLine;
-	return bareMarker;
-}
-function closeFenceIfNeeded(text, openFence, maxChars) {
-	if (!openFence || !canBalanceFence(openFence, maxChars)) return text;
-	const closeLine = closeFenceLine(openFence);
-	if (!text) return closeLine;
-	if (!text.endsWith("\n")) return `${text}\n${closeLine}`;
-	return `${text}${closeLine}`;
+function closesFence(open, close) {
+	return open.marker[0] === close.marker[0] && close.marker.length >= open.marker.length;
 }
-/**
-* Chunks outbound Discord text by both character count and (soft) line count,
-* while keeping fenced code blocks balanced across chunks.
-*/
 function chunkDiscordText(text, opts = {}) {
 	const hardMaxChars = resolveDiscordChunkLimit(opts.maxChars, DEFAULT_MAX_CHARS);
 	const maxLines = resolveDiscordChunkLimit(opts.maxLines, DEFAULT_MAX_LINES);
-	const body = text ?? "";
-	if (!body) return [];
-	if (body.length <= hardMaxChars && countLines(body) <= maxLines) return [body];
-	const maxChars = hardMaxChars >= MIN_REASONING_ITALICS_CHUNK_CHARS && hasReasoningItalics(body) ? hardMaxChars - REASONING_ITALICS_MARKER_CHARS : hardMaxChars;
-	const lines = body.split("\n");
+	if (!text) return [];
+	if (text.length <= hardMaxChars && countLines(text) <= maxLines) return [text];
+	const maxChars = hardMaxChars >= MIN_REASONING_ITALICS_CHUNK_CHARS && hasReasoningItalics(text) ? hardMaxChars - REASONING_ITALICS_MARKER_CHARS : hardMaxChars;
+	const ranges = createDiscordRanges(text, maxChars, maxLines);
 	const chunks = [];
-	let current = "";
-	let currentLines = 0;
-	let openFence = null;
-	const flush = () => {
-		if (!current) return;
-		const payload = closeFenceIfNeeded(current, openFence, maxChars);
-		if (payload.trim().length) chunks.push(payload);
-		current = "";
-		currentLines = 0;
-		if (openFence) {
-			const reopenLine = reopenFenceLine(openFence, maxChars);
-			if (reopenLine) {
-				current = reopenLine;
-				currentLines = 1;
-			}
-		}
+	let current;
+	let consumed = 0;
+	let lineStart = 0;
+	const raw = (frame) => {
+		const prefix = ranges.fenceAt(frame.start)?.reopenLine ?? "";
+		const body = text.slice(frame.start, frame.end);
+		return prefix + (prefix ? "\n" : "") + body;
 	};
-	for (const originalLine of lines) {
-		const fenceInfo = parseFenceLine(originalLine);
-		const wasInsideFence = openFence !== null;
-		let nextOpenFence = openFence;
-		if (fenceInfo) {
-			if (!openFence) nextOpenFence = fenceInfo;
-			else if (openFence.markerChar === fenceInfo.markerChar && fenceInfo.markerLen >= openFence.markerLen) nextOpenFence = null;
+	const render = (frame) => {
+		const body = ranges.render(frame.start, frame.end);
+		if (body === void 0) return;
+		const prefix = ranges.fenceAt(frame.start)?.reopenLine ?? "";
+		const result = prefix + (prefix ? "\n" : "") + body;
+		const close = ranges.fenceAt(frame.end);
+		return close?.reopenLine ? result + (result.endsWith("\n") ? "" : "\n") + close.closeLine : result;
+	};
+	const fits = (frame) => {
+		const payload = render(frame);
+		return payload !== void 0 && payload.length <= maxChars && countLines(payload) <= Math.max(maxLines, ranges.fenceAt(frame.start)?.reopenLine || ranges.fenceAt(frame.end)?.reopenLine ? 3 : 1);
+	};
+	const flush = (frame) => {
+		let end = ranges.overlaps(frame.start, frame.end) ? ranges.cutBoundary(frame.start, frame.end) : ranges.boundary(frame.start, frame.end);
+		if (frame.end > frame.start && end <= frame.start) return frame;
+		const minimum = ranges.boundary(frame.start, frame.start + 1);
+		while (end > minimum && !fits({
+			...frame,
+			end
+		})) {
+			const cut = ranges.cutBoundary(frame.start, end - 1);
+			end = cut > frame.start ? cut : minimum;
 		}
-		const candidateFence = nextOpenFence ?? openFence;
-		const fenceToReserve = candidateFence && canBalanceFence(candidateFence, maxChars) ? candidateFence : null;
-		const reserveChars = fenceToReserve ? closeFenceLine(fenceToReserve).length + 1 : 0;
-		const reserveLines = fenceToReserve ? 1 : 0;
-		const effectiveMaxChars = maxChars - reserveChars;
-		const effectiveMaxLines = maxLines - reserveLines;
-		const charLimit = effectiveMaxChars > 0 ? effectiveMaxChars : maxChars;
-		const lineLimit = effectiveMaxLines > 0 ? effectiveMaxLines : maxLines;
-		const reopenPrefixLen = fenceToReserve ? reopenFenceLine(fenceToReserve, maxChars)?.length ?? 0 : 0;
-		const prefixLen = current.length > 0 ? current.length + 1 : 0;
-		const reopenBudget = reopenPrefixLen > 0 ? reopenPrefixLen + 1 : 0;
-		const segments = chunkTextForOutbound(originalLine, Math.max(1, charLimit - Math.max(prefixLen, reopenBudget)), { preserveWhitespace: wasInsideFence });
-		for (let segIndex = 0; segIndex < segments.length; segIndex++) {
-			const segment = segments[segIndex];
-			const isLineContinuation = segIndex > 0;
-			let delimiter = isLineContinuation ? "" : current.length > 0 ? "\n" : "";
-			let addition = `${delimiter}${segment}`;
-			const nextLen = current.length + addition.length;
-			const nextLines = currentLines + (isLineContinuation ? 0 : 1);
-			if ((nextLen > charLimit || nextLines > lineLimit) && current.length > 0) {
-				flush();
-				delimiter = current.length > 0 ? "\n" : "";
-				addition = `${delimiter}${segment}`;
-			}
-			if (current.length > 0) {
-				current += addition;
-				if (!isLineContinuation || delimiter) currentLines += 1;
-			} else {
-				current = expectDefined(segment, "current Discord chunk segment");
-				currentLines = 1;
+		const payload = expectDefined(render({
+			...frame,
+			end
+		}), "renderable Discord source range");
+		if (payload.trim()) chunks.push(payload);
+		consumed = end;
+		return end < frame.end ? {
+			start: end,
+			end: frame.end
+		} : void 0;
+	};
+	for (const line of text.split("\n")) {
+		const openFence = ranges.fenceAt(lineStart - 1);
+		const candidateFence = ranges.fenceAt(lineStart + line.length) ?? openFence;
+		const fence = candidateFence?.reopenLine ? candidateFence : null;
+		const charLimit = maxChars - (fence ? fence.closeLine.length + 1 : 0);
+		const lineLimit = Math.max(1, maxLines - (fence ? 1 : 0));
+		const content = current ? raw(current) : ranges.fenceAt(consumed)?.reopenLine ?? "";
+		const segmentLimit = openFence?.reopenLine && openFence.closeStart === lineStart && fits({
+			start: lineStart,
+			end: lineStart + line.length
+		}) ? maxChars : Math.max(1, charLimit - Math.max(content ? content.length + 1 : 0, fence?.reopenLine ? fence.reopenLine.length + 1 : 0));
+		let segmentStart = lineStart;
+		for (const segment of chunkTextForOutbound(line, segmentLimit, { preserveWhitespace: Boolean(openFence) })) {
+			const end = segmentStart + segment.length;
+			const start = current?.start ?? (ranges.joins(consumed, segmentStart) ? consumed : segmentStart);
+			const candidate = {
+				start,
+				end
+			};
+			const exceeds = openFence && !ranges.fenceAt(end) ? !fits(candidate) : raw(candidate).length > charLimit || countLines(raw(candidate)) > lineLimit || ranges.overlaps(start, end) && !fits(candidate);
+			if (current && exceeds) {
+				current = flush(current);
+				candidate.start = current?.start ?? (ranges.joins(consumed, segmentStart) ? consumed : segmentStart);
 			}
+			current = raw(candidate) ? candidate : void 0;
+			segmentStart = end;
 		}
-		openFence = nextOpenFence;
-	}
-	if (current.length) {
-		const payload = closeFenceIfNeeded(current, openFence, maxChars);
-		if (payload.trim().length) chunks.push(payload);
+		lineStart += line.length + 1;
 	}
+	while (current) current = flush(current);
 	return rebalanceReasoningItalics(text, chunks, hardMaxChars);
 }
 function chunkDiscordTextWithMode(text, opts) {
 	if ((opts.chunkMode ?? "length") !== "newline") return chunkDiscordText(text, opts);
-	const lineChunks = chunkMarkdownTextWithMode(text, resolveDiscordChunkLimit(opts.maxChars, DEFAULT_MAX_CHARS), "newline");
-	const chunks = [];
-	for (const line of lineChunks) {
-		const nested = chunkDiscordText(line, opts);
-		if (!nested.length && line) {
-			chunks.push(line);
-			continue;
-		}
-		chunks.push(...nested);
-	}
-	return chunks;
-}
-function leadingCodeSpanEnd(body) {
-	if (!body) return -1;
-	const firstNewline = body.indexOf("\n");
-	const openFence = parseFenceLine(firstNewline === -1 ? body : body.slice(0, firstNewline));
-	if (openFence) {
-		if (firstNewline === -1) return body.length;
-		let lineStart = firstNewline + 1;
-		while (lineStart <= body.length) {
-			const lineEnd = body.indexOf("\n", lineStart);
-			const line = lineEnd === -1 ? body.slice(lineStart) : body.slice(lineStart, lineEnd);
-			const closeFence = parseFenceLine(line);
-			const closeSuffix = closeFence ? line.slice(closeFence.indent.length + closeFence.markerLen) : "";
-			if (closeFence?.markerChar === openFence.markerChar && closeFence.markerLen >= openFence.markerLen && /^[ \t]*_?[ \t]*$/u.test(closeSuffix)) {
-				const markerEnd = closeFence.indent.length + closeFence.markerLen;
-				const trailingSpaces = /^ */.exec(line.slice(markerEnd))?.[0].length ?? 0;
-				return lineStart + markerEnd + trailingSpaces;
-			}
-			if (lineEnd === -1) return body.length;
-			lineStart = lineEnd + 1;
-		}
-		return body.length;
-	}
-	if (!body.startsWith("`")) return -1;
-	const ticks = /^(?<ticks>`+)/.exec(body)?.groups?.ticks;
-	if (!ticks) return -1;
-	for (let index = ticks.length; index < body.length;) {
-		if (body[index] !== "`") {
-			index += 1;
-			continue;
-		}
-		let runEnd = index + 1;
-		while (body[runEnd] === "`") runEnd += 1;
-		if (runEnd - index === ticks.length) return runEnd;
-		index = runEnd;
-	}
-	return -1;
+	return chunkByParagraph(text, resolveDiscordChunkLimit(opts.maxChars, DEFAULT_MAX_CHARS), { splitLongParagraphs: false }).flatMap((line) => {
+		const chunks = chunkDiscordText(line, opts);
+		return chunks.length || !line ? chunks : [line];
+	});
 }
 function leadingCodePrefixEnd(body) {
-	let prefixEnd = leadingCodeSpanEnd(body);
-	if (prefixEnd < 0) return -1;
-	while (prefixEnd < body.length) {
-		const separator = /^\s+/u.exec(body.slice(prefixEnd))?.[0] ?? "";
-		if (!separator) break;
-		const nextStart = prefixEnd + separator.length;
-		const nextEnd = leadingCodeSpanEnd(body.slice(nextStart));
-		if (nextEnd < 0) break;
-		prefixEnd = nextStart + nextEnd;
+	let offset = 0;
+	let prefixEnd = -1;
+	while (offset < body.length) {
+		const rest = body.slice(offset);
+		const fence = parseFenceLine(rest.split("\n", 1)[0] ?? "");
+		const marker = fence?.marker ?? /^`+/.exec(rest)?.[0];
+		if (!marker) return prefixEnd;
+		const pattern = fence ? `\\n( {0,3}${marker[0]}{${marker.length},} *)(?=[\\t ]*_?[\\t ]*(?:\\n|$))` : "(?<!`)`{" + marker.length + "}(?!`)";
+		const delimiter = new RegExp(pattern, "g");
+		delimiter.lastIndex = fence ? 0 : marker.length;
+		const match = delimiter.exec(rest);
+		if (!match) return fence ? body.length : prefixEnd;
+		prefixEnd = offset + match.index + match[0].length;
+		const separator = /^\s+/u.exec(body.slice(prefixEnd))?.[0];
+		if (!separator) return prefixEnd;
+		offset = prefixEnd + separator.length;
 	}
 	return prefixEnd;
 }
-function hasReasoningItalicsOpen(chunk) {
-	const trimmed = chunk.trimStart();
-	if (trimmed.startsWith("_") || /^(?:Reasoning:|Thinking\.{0,3})\n+_/u.test(trimmed)) return true;
-	const codeEnd = leadingCodePrefixEnd(trimmed);
-	return codeEnd >= 0 && trimmed.slice(codeEnd).trimStart().startsWith("_");
-}
-function reopenReasoningItalicsAfterLeadingCode(body, codeEnd) {
-	const code = body.slice(0, codeEnd);
-	const rest = body.slice(codeEnd);
-	if (!rest.trim()) return code + rest;
-	if (/^\s*_\s*$/.test(rest)) return code;
-	const whitespaceLength = rest.length - rest.trimStart().length;
-	const whitespace = rest.slice(0, whitespaceLength);
-	const restBody = rest.slice(whitespaceLength);
-	return restBody.startsWith("_") ? code + rest : `${code}${whitespace}_${restBody}`;
-}
 function rebalanceReasoningItalics(source, chunks, maxChars) {
-	if (chunks.length <= 1 || maxChars < MIN_REASONING_ITALICS_CHUNK_CHARS) return chunks;
-	if (!hasReasoningItalics(source)) return chunks;
-	const adjusted = [...chunks];
-	for (let i = 0; i < adjusted.length; i++) {
-		const isLast = i === adjusted.length - 1;
-		const current = expectDefined(adjusted[i], "Discord chunk adjustment index");
-		if (!current.trimEnd().endsWith("_") && hasReasoningItalicsOpen(current)) adjusted[i] = `${current}_`;
-		if (isLast) break;
-		const next = expectDefined(adjusted[i + 1], "non-final Discord chunk successor");
-		const leadingWhitespaceLen = next.length - next.trimStart().length;
-		const leadingWhitespace = next.slice(0, leadingWhitespaceLen);
-		const nextBody = next.slice(leadingWhitespaceLen);
-		if (nextBody.startsWith("_")) continue;
-		const codeEnd = leadingCodePrefixEnd(nextBody);
-		adjusted[i + 1] = codeEnd >= 0 ? `${leadingWhitespace}${reopenReasoningItalicsAfterLeadingCode(nextBody, codeEnd)}` : `${leadingWhitespace}_${nextBody}`;
-	}
-	return adjusted;
+	if (chunks.length <= 1 || maxChars < MIN_REASONING_ITALICS_CHUNK_CHARS || !hasReasoningItalics(source)) return chunks;
+	return chunks.map((chunk, index) => {
+		const leadingWhitespace = chunk.length - chunk.trimStart().length;
+		const codeEnd = leadingCodePrefixEnd(chunk.slice(leadingWhitespace));
+		const prefixEnd = leadingWhitespace + Math.max(0, codeEnd);
+		const prefix = chunk.slice(0, prefixEnd);
+		let body = chunk.slice(prefixEnd);
+		if (index > 0) {
+			if (codeEnd >= 0 && /^\s*_\s*$/.test(body)) return prefix;
+			const content = body.trimStart();
+			if (content && !content.startsWith("_")) body = `${body.slice(0, body.length - content.length)}_${content}`;
+		}
+		if (!body.trimEnd().endsWith("_") && /^(?:_|(?:Reasoning:|Thinking\.{0,3})\n+_)/u.test(body.trimStart())) body += "_";
+		return prefix + body;
+	});
+}
+function renderInlineCode(body, delimiter) {
+	const runs = new Set(Array.from(body.matchAll(/`+/g), (match) => match[0].length));
+	let marker = delimiter;
+	if (runs.has(marker.length) || marker.length >= 3 && /[\r\n]/.test(body)) {
+		marker = "`";
+		while (runs.has(marker.length)) marker += "`";
+	}
+	if (marker.length >= 3 && /[\r\n]/.test(body) && !body.split(/\r\n|[\r\n]/, 1)[0]?.includes("`")) return;
+	const normalized = body.replace(/\r\n|[\r\n]/g, " ");
+	const padding = body.startsWith("`") || body.endsWith("`") || normalized.startsWith(" ") && normalized.endsWith(" ") && /[^ ]/.test(normalized) ? " " : "";
+	return marker + padding + body + padding + marker;
+}
+function createDiscordRanges(source, maxChars, maxLines) {
+	const spans = [];
+	const fences = [];
+	let offset = 0;
+	let plainStart = 0;
+	let fence;
+	const collect = (end) => {
+		for (const span of findCodeRegions(source.slice(plainStart, end), {
+			includeSource: true,
+			syntax: "commonmark"
+		})) {
+			if (span.block) continue;
+			const start = plainStart + span.start;
+			const finish = plainStart + span.end;
+			const marker = /^`+/.exec(source.slice(start, finish))?.[0];
+			if (!marker) continue;
+			const code = expectDefined(span.source, "inline code source map");
+			const atomicTicks = (renderInlineCode("`", marker)?.length ?? Infinity) + code.prefix.text.length > maxChars;
+			const pattern = atomicTicks ? /`+|\r\n|[\s\S]/gu : /\r\n|[\s\S]/gu;
+			if (Array.from(source.slice(start, finish).matchAll(pattern)).every(({ index, 0: raw }) => {
+				const value = code.value.slice(code.offsets[index], code.offsets[index + raw.length]);
+				return !value || (renderInlineCode(value, marker)?.length ?? Infinity) + code.prefix.text.length <= maxChars;
+			}) && (maxLines > 1 || !code.value.includes("\n"))) spans.push({
+				start,
+				end: finish,
+				code,
+				base: plainStart,
+				marker,
+				atomicTicks
+			});
+		}
+	};
+	for (const line of source.split("\n")) {
+		const info = parseFenceLine(line, maxChars);
+		if (info && !fence) {
+			collect(offset);
+			fence = {
+				start: offset,
+				bodyStart: offset + line.length + 1,
+				closeStart: source.length,
+				end: source.length,
+				...info
+			};
+			fences.push(fence);
+		} else if (info && fence && closesFence(fence, info)) {
+			fence.closeStart = offset;
+			fence.end = offset + line.length;
+			fence = void 0;
+			plainStart = offset + line.length + 1;
+		}
+		offset += line.length + 1;
+	}
+	if (!fence) collect(source.length);
+	const overlaps = (start, end) => spans.some((span) => span.start < end && span.end > start);
+	const joins = (end, start) => end <= start && spans.some((span) => span.start < end && end < span.end && start < span.end);
+	const boundary = (start, end) => {
+		let safe = avoidTrailingHighSurrogateBreak(source, start, end);
+		for (const span of spans) {
+			const prefix = span.code.prefix;
+			if (span.base + prefix.start < safe && safe < span.base + prefix.end) return span.base + prefix.start;
+			if (span.start < safe && safe < span.end) {
+				if (source[safe - 1] === "\r" && source[safe] === "\n") safe -= 1;
+				if (span.atomicTicks) while (source[safe - 1] === "`" && source[safe] === "`") safe -= 1;
+			}
+		}
+		return safe;
+	};
+	const render = (start, end) => {
+		let cursor = start, text = "";
+		for (const span of spans) {
+			if (span.end <= start || span.start >= end) continue;
+			const prefix = span.code.prefix;
+			const prefixStart = span.base + prefix.start;
+			if (start > span.base + prefix.ownerStart && cursor <= prefixStart) {
+				text += source.slice(cursor, prefixStart) + prefix.text;
+				cursor = span.base + prefix.end;
+			}
+			text += source.slice(cursor, Math.max(cursor, span.start));
+			if (span.start >= start && span.end <= end) text += source.slice(span.start, span.end);
+			else {
+				const body = span.code.value.slice(span.code.offsets[Math.max(start, span.start) - span.start], span.code.offsets[Math.min(end, span.end) - span.start]);
+				if (body) {
+					const value = renderInlineCode(body, span.marker);
+					if (value === void 0) return;
+					text += (span.start < start ? span.code.prefix.text : "") + value;
+				}
+			}
+			cursor = Math.min(end, span.end);
+		}
+		return text + source.slice(cursor, end);
+	};
+	const fenceAt = (position) => fences.find((range) => range.bodyStart - 1 <= position && (position < range.end || position === range.end && range.closeStart === range.end));
+	const cutBoundary = (start, end) => {
+		const safe = boundary(start, end);
+		for (const range of fences) {
+			if (start < range.start && range.start < safe && safe <= range.bodyStart) return range.start;
+			if (range.closeStart < safe && safe < range.end) return range.closeStart;
+		}
+		return safe;
+	};
+	return {
+		render,
+		overlaps,
+		joins,
+		boundary,
+		fenceAt,
+		cutBoundary
+	};
 }
 //#endregion
 //#region extensions/discord/src/retry.ts
@@ -3455,7 +3591,8 @@ const DISCORD_TRANSIENT_MESSAGE_RE = /\b(?:bad gateway|fetch failed|network erro
 const ambiguousDiscordMessageCreates = /* @__PURE__ */ new WeakSet();
 function readDiscordErrorStatus(err) {
 	if (!err || typeof err !== "object") return;
-	return parseStrictNonNegativeInteger("status" in err && err.status !== void 0 ? err.status : "statusCode" in err && err.statusCode !== void 0 ? err.statusCode : void 0);
+	const raw = "status" in err && err.status !== void 0 ? err.status : "statusCode" in err && err.statusCode !== void 0 ? err.statusCode : void 0;
+	return parseStrictNonNegativeInteger(raw);
 }
 function classifyDiscordDeliveryFailure(error) {
 	const candidates = collectErrorGraphCandidates(error, (current) => [current.cause, current.error]);
@@ -3476,6 +3613,11 @@ function recordDiscordMessageCreateAmbiguity(error) {
 function hasDiscordMessageCreateAmbiguity(error) {
 	return collectErrorGraphCandidates(error, (current) => [current.cause, current.error]).some((candidate) => candidate !== null && typeof candidate === "object" && ambiguousDiscordMessageCreates.has(candidate));
 }
+function canFallbackDiscordWebhookSend(error) {
+	if (hasDiscordMessageCreateAmbiguity(error)) return false;
+	const failure = classifyDiscordDeliveryFailure(error);
+	return failure === "rejected" || failure === "pre-connect";
+}
 function hasDiscordRateLimitRejection(error) {
 	return error instanceof RateLimitError || collectErrorGraphCandidates(error, (current) => [current.cause, current.error]).some((candidate) => readDiscordErrorStatus(candidate) === 429);
 }
@@ -3540,4 +3682,4 @@ function createDiscordRetryRunner(params) {
 	};
 }
 //#endregion
-export { TextInput as $, listGuildRoles as $t, ThreadUpdateListener as A, getChannel as At, readRetryAfter as B, addGuildMemberRole as Bt, MessageCreateListener as C, listMessageReactionUsers as Ct, ReadyListener as D, deleteChannelMessage as Dt, PresenceUpdateListener as E, deleteChannel as Et, DiscordError as F, listChannelPins as Ft, User as G, createGuildSticker as Gt, CommandWithSubcommands as H, createGuildChannel as Ht, RateLimitError as I, pinChannelMessage as It, Embed as J, getGuildMember as Jt, hasDiscordV2Components as K, deleteChannelPermission as Kt, isUnknownDiscordVoiceStateError as L, searchGuildMessages as Lt, Client as M, getThreadMember as Mt, Plugin as N, listChannelArchivedThreads as Nt, ResumedListener as O, editChannel as Ot, RequestClient as P, listChannelMessages as Pt, RadioGroup as Q, listGuildEmojis as Qt, readDiscordCode as R, sendChannelTyping as Rt, InteractionCreateListener as S, deleteOwnMessageReaction as St, MessageReactionRemoveListener as T, createThread as Tt, Guild as U, createGuildEmoji as Ut, Command as V, createGuildBan as Vt, Message as W, createGuildScheduledEvent as Wt, Label as X, listGuildActiveThreads as Xt, CheckboxGroup as Y, getGuildVoiceState as Yt, Modal as Z, listGuildChannels as Zt, parseDiscordTarget as _, stripUndefinedFields as _t, chunkDiscordTextWithMode as a, timeoutGuildMember as an, MediaGallery as at, GuildCreateListener as b, getCurrentUser as bt, createDiscordSendResult as c, Row as ct, resolveDiscordReplyMessageId as d, StringSelectMenu as dt, listGuildScheduledEvents as en, Button as et, resolveDiscordReplyReference as f, TextDisplay as ft, normalizeDiscordOutboundTarget as g, parseCustomId as gt, normalizeDiscordMessagingTarget as h, BaseMessageInteractiveComponent as ht, recordDiscordMessageCreateAmbiguity as i, removeGuildMemberRole as in, LinkButton as it, VoiceStateUpdateListener as j, getChannelMessage as jt, ThreadDeleteListener as k, editChannelMessage as kt, toDiscordOutboundDeliveryResult as l, Section as lt, looksLikeDiscordTargetId as m, UserSelectMenu as mt, createDiscordRetryRunner as n, putChannelPermission as nn, Container as nt, createDiscordSendReceipt as o, __exportAll as on, MentionableSelectMenu as ot, allowFromContainsDiscordUserId as p, Thumbnail as pt, serializePayload as q, getGuild as qt, hasDiscordMessageCreateAmbiguity as r, removeGuildMember as rn, File as rt, createDiscordSendReceiptFromResults as s, RoleSelectMenu as st, classifyDiscordDeliveryFailure as t, moveGuildChannels as tn, ChannelSelectMenu as tt, createReusableDiscordReplyReference as u, Separator as ut, resolveDiscordChannelId as v, createChannelWebhook as vt, MessageReactionAddListener as w, createChannelMessage as wt, GuildDeleteListener as x, createOwnMessageReaction as xt, discord_exports as y, createUserDmChannel as yt, readDiscordMessage as z, unpinChannelMessage as zt };
+export { RadioGroup as $, listGuildEmojis as $t, ThreadDeleteListener as A, editChannelMessage as At, readDiscordMessage as B, unpinChannelMessage as Bt, InteractionCreateListener as C, deleteOwnMessageReaction as Ct, PresenceUpdateListener as D, deleteChannel as Dt, MessageReactionRemoveListener as E, createThread as Et, RequestClient as F, listChannelMessages as Ft, Message as G, createGuildScheduledEvent as Gt, Command as H, createGuildBan as Ht, DiscordError as I, listChannelPins as It, serializePayload as J, getGuild as Jt, User as K, createGuildSticker as Kt, RateLimitError as L, pinChannelMessage as Lt, VoiceStateUpdateListener as M, getChannelMessage as Mt, Client as N, getThreadMember as Nt, ReadyListener as O, deleteChannelMessage as Ot, Plugin as P, listChannelArchivedThreads as Pt, Modal as Q, listGuildChannels as Qt, isUnknownDiscordVoiceStateError as R, searchGuildMessages as Rt, GuildDeleteListener as S, createOwnMessageReaction as St, MessageReactionAddListener as T, createChannelMessage as Tt, CommandWithSubcommands as U, createGuildChannel as Ut, readRetryAfter as V, addGuildMemberRole as Vt, Guild as W, createGuildEmoji as Wt, CheckboxGroup as X, getGuildVoiceState as Xt, Embed as Y, getGuildMember as Yt, Label as Z, listGuildActiveThreads as Zt, normalizeDiscordOutboundTarget as _, parseCustomId as _t, recordDiscordMessageCreateAmbiguity as a, removeGuildMemberRole as an, LinkButton as at, discord_exports as b, createUserDmChannel as bt, createDiscordSendReceiptFromResults as c, RoleSelectMenu as ct, createReusableDiscordReplyReference as d, Separator as dt, listGuildRoles as en, TextInput as et, resolveDiscordReplyMessageId as f, StringSelectMenu as ft, normalizeDiscordMessagingTarget as g, BaseMessageInteractiveComponent as gt, looksLikeDiscordTargetId as h, UserSelectMenu as ht, hasDiscordMessageCreateAmbiguity as i, removeGuildMember as in, File as it, ThreadUpdateListener as j, getChannel as jt, ResumedListener as k, editChannel as kt, createDiscordSendResult as l, Row as lt, allowFromContainsDiscordUserId as m, Thumbnail as mt, classifyDiscordDeliveryFailure as n, moveGuildChannels as nn, ChannelSelectMenu as nt, chunkDiscordTextWithMode as o, timeoutGuildMember as on, MediaGallery as ot, resolveDiscordReplyReference as p, TextDisplay as pt, hasDiscordV2Components as q, deleteChannelPermission as qt, createDiscordRetryRunner as r, putChannelPermission as rn, Container as rt, createDiscordSendReceipt as s, __exportAll as sn, MentionableSelectMenu as st, canFallbackDiscordWebhookSend as t, listGuildScheduledEvents as tn, Button as tt, toDiscordOutboundDeliveryResult as u, Section as ut, parseDiscordTarget as v, stripUndefinedFields as vt, MessageCreateListener as w, listMessageReactionUsers as wt, GuildCreateListener as x, getCurrentUser as xt, resolveDiscordChannelId as y, createChannelWebhook as yt, readDiscordCode as z, sendChannelTyping as zt };