@openclaw/line 2026.7.1 → 2026.7.2-beta.2

package/dist/{monitor-0eXlx_Pe.js → monitor-Db2rZsSX.js}

@@ -1,30 +1,36 @@
 import { i as resolveLineAccount, r as resolveDefaultLineAccountId } from "./accounts-DJVOv1JI.js";
-import { f as resolveLineGroupConfigEntry, i as buildLineQuickReplyFallbackText, s as getLineRuntime } from "./reply-payload-transform-C7r5npxP.js";
-import { A as buildTemplateMessageFromPayload, C as pushMessagesLine, E as replyMessageLine, O as showLoadingAnimation, S as pushMessageLine, T as pushTextMessageWithQuickReplies, _ as getUserDisplayName, c as processLineMessage, d as createFlexMessage, f as createImageMessage, h as createTextMessageWithQuickReplies, m as createQuickReplyItems, p as createLocationMessage } from "./markdown-to-line-DmpZY78n.js";
+import { a as buildLineMediaMessage, i as buildLineQuickReplyFallbackText, l as getLineRuntime, m as resolveLineGroupConfigEntry, o as hasLineSpecificMediaOptions } from "./reply-payload-transform-r9sa-TYT.js";
+import { A as buildTemplateMessageFromPayload, C as pushMessagesLine, E as replyMessageLine, O as showLoadingAnimation, S as pushMessageLine, T as pushTextMessageWithQuickReplies, _ as getUserDisplayName, c as processLineMessage, d as createFlexMessage, h as createTextMessageWithQuickReplies, m as createQuickReplyItems, p as createLocationMessage } from "./markdown-to-line-XceqeKRP.js";
 import { createChannelPairingChallengeIssuer } from "openclaw/plugin-sdk/channel-pairing";
 import { normalizeOptionalString, normalizeStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { createMessageReceiveContext } from "openclaw/plugin-sdk/channel-outbound";
 import { resolveSendableOutboundReplyParts } from "openclaw/plugin-sdk/reply-payload";
+import { sanitizeAssistantVisibleText } from "openclaw/plugin-sdk/text-chunking";
 import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
+import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";
 import { firstDefined } from "openclaw/plugin-sdk/allow-from";
-import { messagingApi } from "@line/bot-sdk";
+import { Readable } from "node:stream";
+import { finished } from "node:stream/promises";
+import { setTimeout as setTimeout$1 } from "node:timers/promises";
 import { saveMediaStream } from "openclaw/plugin-sdk/media-store";
 import { createNonExitingRuntime, danger, logVerbose, shouldLogVerbose, waitForAbortSignal } from "openclaw/plugin-sdk/runtime-env";
+import { fetchWithRuntimeDispatcherOrMockedGlobal } from "openclaw/plugin-sdk/runtime-fetch";
 import { recordChannelActivity } from "openclaw/plugin-sdk/channel-activity-runtime";
 import { buildMentionRegexes, formatInboundEnvelope, formatInboundMediaUnavailableText, formatLocationText, hasFinalInboundReplyDispatch, matchesMentionPatterns, resolveInboundSessionEnvelopeContext, toLocationContext } from "openclaw/plugin-sdk/channel-inbound";
 import { chunkMarkdownText } from "openclaw/plugin-sdk/reply-runtime";
 import { isRequestBodyLimitError, normalizePluginHttpPath, normalizeWebhookPath, registerWebhookTargetWithPluginRoute, requestBodyErrorToText, resolveSingleWebhookTarget } from "openclaw/plugin-sdk/webhook-ingress";
-import { beginWebhookRequestPipelineOrReject, createWebhookInFlightLimiter, isRequestBodyLimitError as isRequestBodyLimitError$1, readRequestBodyWithLimit, requestBodyErrorToText as requestBodyErrorToText$1 } from "openclaw/plugin-sdk/webhook-request-guards";
+import { beginWebhookRequestPipelineOrReject, createWebhookInFlightLimiter, isRequestBodyLimitError as isRequestBodyLimitError$1, readRequestBodyWithLimit, requestBodyErrorToText as requestBodyErrorToText$1, runDetachedWebhookWork } from "openclaw/plugin-sdk/webhook-request-guards";
 import { DEFAULT_GROUP_HISTORY_LIMIT, createChannelHistoryWindow } from "openclaw/plugin-sdk/reply-history";
 import { getRuntimeConfig } from "openclaw/plugin-sdk/runtime-config-snapshot";
 import { resolveStableChannelMessageIngress } from "openclaw/plugin-sdk/channel-ingress-runtime";
-import { shouldComputeCommandAuthorized } from "openclaw/plugin-sdk/command-auth-native";
+import { hasControlCommand } from "openclaw/plugin-sdk/command-auth-native";
 import { ensureConfiguredBindingRouteReady, readChannelAllowFromStore, resolveConfiguredBindingRoute, resolvePairingIdLabel, resolvePinnedMainDmOwnerFromAllowlist, resolveRuntimeConversationBindingRoute, upsertChannelPairingRequest } from "openclaw/plugin-sdk/conversation-runtime";
-import { createClaimableDedupe } from "openclaw/plugin-sdk/persistent-dedupe";
+import { createChannelReplayGuard } from "openclaw/plugin-sdk/persistent-dedupe";
 import { resolveAgentRoute, resolveInboundLastRouteSessionKey } from "openclaw/plugin-sdk/routing";
 import { resolveAllowlistProviderRuntimeGroupPolicy, resolveDefaultGroupPolicy, warnMissingProviderGroupPolicyFallbackOnce } from "openclaw/plugin-sdk/runtime-group-policy";
 import { finalizeInboundContext } from "openclaw/plugin-sdk/reply-dispatch-runtime";
 import crypto from "node:crypto";
+import { safeEqualSecret } from "openclaw/plugin-sdk/security-runtime";
 //#region extensions/line/src/bot-access.ts
 function normalizeLineAllowEntry(value) {
 	const trimmed = String(value).trim();
@@ -42,8 +48,51 @@ const normalizeAllowFrom = (list) => {
 };
 //#endregion
 //#region extensions/line/src/download.ts
+const CONTENT_READY_MAX_ATTEMPTS = 6;
+const CONTENT_READY_BASE_DELAY_MS = 500;
+const CONTENT_READY_MAX_DELAY_MS = 4e3;
+const CONTENT_READY_TIMEOUT_MS = 15e3;
+const LINE_CONTENT_BASE_URL = "https://api-data.line.me/v2/bot/message";
+function contentBackoffDelayMs(attempt) {
+	return Math.min(CONTENT_READY_BASE_DELAY_MS * 2 ** attempt, CONTENT_READY_MAX_DELAY_MS);
+}
+async function fetchLineContentWhenReady(messageId, channelAccessToken) {
+	const controller = new AbortController();
+	const deadline = setTimeout(() => controller.abort(), CONTENT_READY_TIMEOUT_MS);
+	deadline.unref();
+	try {
+		for (let attempt = 0; attempt < CONTENT_READY_MAX_ATTEMPTS; attempt++) {
+			const response = await fetchWithRuntimeDispatcherOrMockedGlobal(`${LINE_CONTENT_BASE_URL}/${encodeURIComponent(messageId)}/content`, {
+				headers: { Authorization: `Bearer ${channelAccessToken}` },
+				redirect: "error",
+				signal: controller.signal
+			});
+			if (response.status === 200) {
+				if (!response.body) throw new Error(`LINE media response for message ${messageId} had no body`);
+				return Readable.fromWeb(response.body);
+			}
+			await response.body?.cancel();
+			if (response.status !== 202) throw new Error(`LINE media download failed for message ${messageId} (HTTP ${response.status})`);
+			if (attempt < CONTENT_READY_MAX_ATTEMPTS - 1) await setTimeout$1(contentBackoffDelayMs(attempt), void 0, { signal: controller.signal });
+		}
+	} catch (err) {
+		if (controller.signal.aborted) throw new Error(`LINE media for message ${messageId} did not become ready within ${CONTENT_READY_TIMEOUT_MS / 1e3} seconds`, { cause: err });
+		throw err;
+	} finally {
+		clearTimeout(deadline);
+	}
+	throw new Error(`LINE media for message ${messageId} was still preparing (HTTP 202) after ${CONTENT_READY_MAX_ATTEMPTS} attempts`);
+}
 async function downloadLineMedia(messageId, channelAccessToken, maxBytes = 10 * 1024 * 1024, options) {
-	const saved = await saveMediaStream(await new messagingApi.MessagingApiBlobClient({ channelAccessToken }).getMessageContent(messageId), void 0, "inbound", maxBytes, options?.originalFilename);
+	const content = await fetchLineContentWhenReady(messageId, channelAccessToken);
+	let saved;
+	try {
+		saved = await saveMediaStream(content, void 0, "inbound", maxBytes, options?.originalFilename);
+	} catch (err) {
+		content.destroy();
+		await finished(content).catch(() => void 0);
+		throw err;
+	}
 	logVerbose(`line: persisted media ${messageId} to ${saved.path} (${saved.size} bytes)`);
 	return {
 		path: saved.path,
@@ -53,15 +102,19 @@ async function downloadLineMedia(messageId, channelAccessToken, maxBytes = 10 *
 }
 //#endregion
 //#region extensions/line/src/auto-reply-delivery.ts
+function toLineDeliveryError(error) {
+	return error instanceof Error ? error : new Error("LINE rich or media message send failed", { cause: error });
+}
 function markLineVisibleDeliveryError(error) {
-	if (error instanceof Error && Object.isExtensible(error)) {
-		Object.assign(error, {
+	const deliveryError = toLineDeliveryError(error);
+	if (Object.isExtensible(deliveryError)) {
+		Object.assign(deliveryError, {
 			sentBeforeError: true,
 			visibleReplySent: true
 		});
-		return error;
+		return deliveryError;
 	}
-	const visibleError = new Error("LINE rich or media message send failed", { cause: error });
+	const visibleError = new Error("LINE rich or media message send failed", { cause: deliveryError });
 	Object.assign(visibleError, {
 		sentBeforeError: true,
 		visibleReplySent: true
@@ -71,12 +124,26 @@ function markLineVisibleDeliveryError(error) {
 async function deliverLineAutoReply(params) {
 	const { payload, lineData, replyToken, accountId, to, textLimit, deps } = params;
 	let replyTokenUsed = params.replyTokenUsed;
+	let visibleReplySent = false;
+	const sendVisible = async (send) => {
+		try {
+			const result = await send();
+			visibleReplySent = true;
+			return result;
+		} catch (error) {
+			if (visibleReplySent) throw markLineVisibleDeliveryError(error);
+			throw error;
+		}
+	};
+	const replyVisible = (...args) => sendVisible(() => deps.replyMessageLine(...args));
+	const pushTextVisible = (...args) => sendVisible(() => deps.pushMessageLine(...args));
+	const pushQuickRepliesVisible = (...args) => sendVisible(() => deps.pushTextMessageWithQuickReplies(...args));
 	const pushLineMessages = async (messages) => {
 		if (messages.length === 0) return;
-		for (let i = 0; i < messages.length; i += 5) await deps.pushMessagesLine(to, messages.slice(i, i + 5), {
+		for (let i = 0; i < messages.length; i += 5) await sendVisible(() => deps.pushMessagesLine(to, messages.slice(i, i + 5), {
 			cfg: params.cfg,
 			accountId
-		});
+		}));
 	};
 	const sendLineMessages = async (messages, allowReplyToken) => {
 		if (messages.length === 0) return;
@@ -84,7 +151,7 @@ async function deliverLineAutoReply(params) {
 		if (allowReplyToken && replyToken && !replyTokenUsed) {
 			const replyBatch = remaining.slice(0, 5);
 			try {
-				await deps.replyMessageLine(replyToken, replyBatch, {
+				await replyVisible(replyToken, replyBatch, {
 					cfg: params.cfg,
 					accountId
 				});
@@ -105,21 +172,38 @@ async function deliverLineAutoReply(params) {
 		if (templateMsg) richMessages.push(templateMsg);
 	}
 	if (lineData.location) richMessages.push(deps.createLocationMessage(lineData.location));
-	const processed = payload.text ? deps.processLineMessage(payload.text) : {
+	const visibleText = payload.text ? sanitizeAssistantVisibleText(payload.text) : "";
+	const processed = visibleText ? deps.processLineMessage(visibleText) : {
 		text: "",
 		flexMessages: []
 	};
 	for (const flexMsg of processed.flexMessages) richMessages.push(deps.createFlexMessage(truncateUtf16Safe(flexMsg.altText, 400), flexMsg.contents));
 	const chunks = processed.text ? deps.chunkMarkdownText(processed.text, textLimit) : [];
-	const mediaMessages = resolveSendableOutboundReplyParts(payload).mediaUrls.map((url) => url?.trim()).filter((url) => Boolean(url)).map((url) => deps.createImageMessage(url));
+	const mediaUrls = resolveSendableOutboundReplyParts(payload).mediaUrls;
+	const mediaOpts = {
+		mediaKind: hasLineSpecificMediaOptions(lineData) ? lineData.mediaKind : "image",
+		previewImageUrl: lineData.previewImageUrl,
+		durationMs: lineData.durationMs,
+		trackingId: lineData.trackingId
+	};
+	const mediaMessages = [];
+	let richMediaError;
+	for (const rawUrl of mediaUrls) {
+		const url = rawUrl?.trim();
+		if (!url) continue;
+		try {
+			mediaMessages.push(await deps.buildMediaMessage(url, mediaOpts, to));
+		} catch (err) {
+			richMediaError ??= err;
+		}
+	}
 	if (chunks.length > 0) {
 		const hasRichOrMedia = richMessages.length > 0 || mediaMessages.length > 0;
 		const sendRichBeforeText = hasQuickReplies && hasRichOrMedia;
-		let richMediaError;
 		if (sendRichBeforeText) try {
 			await sendLineMessages([...richMessages, ...mediaMessages], false);
 		} catch (err) {
-			richMediaError = err;
+			richMediaError ??= err;
 		}
 		const { replyTokenUsed: nextReplyTokenUsed } = await deps.sendLineReplyChunks({
 			to,
@@ -129,23 +213,19 @@ async function deliverLineAutoReply(params) {
 			replyTokenUsed,
 			cfg: params.cfg,
 			accountId,
-			replyMessageLine: deps.replyMessageLine,
-			pushMessageLine: deps.pushMessageLine,
-			pushTextMessageWithQuickReplies: deps.pushTextMessageWithQuickReplies,
-			createTextMessageWithQuickReplies: deps.createTextMessageWithQuickReplies
+			replyMessageLine: replyVisible,
+			pushMessageLine: pushTextVisible,
+			pushTextMessageWithQuickReplies: pushQuickRepliesVisible,
+			createTextMessageWithQuickReplies: deps.createTextMessageWithQuickReplies,
+			onReplyError: deps.onReplyError
 		});
 		replyTokenUsed = nextReplyTokenUsed;
 		if (!sendRichBeforeText) try {
 			await sendLineMessages(richMessages, false);
 			if (mediaMessages.length > 0) await sendLineMessages(mediaMessages, false);
 		} catch (err) {
-			richMediaError = err;
+			richMediaError ??= err;
 		}
-		if (richMediaError !== void 0) return {
-			status: "partial",
-			replyTokenUsed,
-			error: markLineVisibleDeliveryError(richMediaError)
-		};
 	} else {
 		const combined = [...richMessages, ...mediaMessages];
 		if (hasQuickReplies && combined.length === 0) {
@@ -157,9 +237,9 @@ async function deliverLineAutoReply(params) {
 				replyTokenUsed,
 				cfg: params.cfg,
 				accountId,
-				replyMessageLine: deps.replyMessageLine,
-				pushMessageLine: deps.pushMessageLine,
-				pushTextMessageWithQuickReplies: deps.pushTextMessageWithQuickReplies,
+				replyMessageLine: replyVisible,
+				pushMessageLine: pushTextVisible,
+				pushTextMessageWithQuickReplies: pushQuickRepliesVisible,
 				createTextMessageWithQuickReplies: deps.createTextMessageWithQuickReplies,
 				onReplyError: deps.onReplyError
 			});
@@ -176,9 +256,19 @@ async function deliverLineAutoReply(params) {
 			await sendLineMessages(combined, true);
 		}
 	}
+	if (richMediaError !== void 0) {
+		if (!visibleReplySent) throw toLineDeliveryError(richMediaError);
+		return {
+			status: "partial",
+			replyTokenUsed,
+			visibleReplySent: true,
+			error: markLineVisibleDeliveryError(richMediaError)
+		};
+	}
 	return {
 		status: "delivered",
-		replyTokenUsed
+		replyTokenUsed,
+		visibleReplySent
 	};
 }
 //#endregion
@@ -403,7 +493,7 @@ async function finalizeLineInboundContext(params) {
 		sessionKey: params.route.sessionKey
 	});
 	if (shouldLogVerbose()) {
-		const preview = body.slice(0, 200).replace(/\n/g, "\\n");
+		const preview = truncateUtf16Safe(body, 200).replace(/\n/g, "\\n");
 		const mediaInfo = params.verboseLog.kind === "inbound" && (params.verboseLog.mediaCount ?? 0) > 1 ? ` mediaCount=${params.verboseLog.mediaCount}` : "";
 		logVerbose(`${params.verboseLog.kind === "inbound" ? "line inbound" : "line postback"}: from=${ctxPayload.From} len=${body.length}${mediaInfo} preview="${preview}"`);
 	}
@@ -434,7 +524,7 @@ async function finalizeLineInboundContext(params) {
 	};
 }
 async function buildLineMessageContext(params) {
-	const { event, allMedia, mediaUnavailable, cfg, account, commandAuthorized, groupHistories, historyLimit } = params;
+	const { event, allMedia, mediaUnavailable, cfg, account, commandAuthorized, inboundHistory } = params;
 	const source = event.source;
 	const { userId, groupId, roomId, isGroup, peerId, route } = await resolveLineInboundRoute({
 		source,
@@ -464,11 +554,6 @@ async function buildLineMessageContext(params) {
 			address: loc.address
 		});
 	}
-	const historyKey = isGroup ? peerId : void 0;
-	const inboundHistory = historyKey && groupHistories && (historyLimit ?? 0) > 0 ? createChannelHistoryWindow({ historyMap: groupHistories }).buildInboundHistory({
-		historyKey,
-		limit: historyLimit ?? 0
-	}) : void 0;
 	const finalized = await finalizeLineInboundContext({
 		cfg,
 		account,
@@ -569,6 +654,41 @@ async function buildLinePostbackContext(params) {
 	};
 }
 //#endregion
+//#region extensions/line/src/group-history.ts
+const reservedEntries = /* @__PURE__ */ new WeakSet();
+function reserveLineGroupHistory(historyMap, historyKey, limit) {
+	if (!historyMap || !historyKey || limit <= 0) return {
+		commit: () => {},
+		release: () => {}
+	};
+	const consumedEntries = (historyMap.get(historyKey) ?? []).filter((entry) => !reservedEntries.has(entry));
+	for (const entry of consumedEntries) reservedEntries.add(entry);
+	const inboundHistory = createChannelHistoryWindow({ historyMap: /* @__PURE__ */ new Map([[historyKey, consumedEntries]]) }).buildInboundHistory({
+		historyKey,
+		limit
+	});
+	let settled = false;
+	const settle = () => {
+		if (settled) return false;
+		settled = true;
+		for (const entry of consumedEntries) reservedEntries.delete(entry);
+		return true;
+	};
+	return {
+		inboundHistory,
+		commit: () => {
+			if (!settle() || consumedEntries.length === 0) return;
+			const consumed = new Set(consumedEntries);
+			const kept = (historyMap.get(historyKey) ?? []).filter((entry) => !consumed.has(entry));
+			if (kept.length > 0) historyMap.set(historyKey, kept);
+			else historyMap.delete(historyKey);
+		},
+		release: () => {
+			settle();
+		}
+	};
+}
+//#endregion
 //#region extensions/line/src/bot-handlers.ts
 const LINE_DOWNLOADABLE_MESSAGE_TYPES = /* @__PURE__ */ new Set([
 	"image",
@@ -584,16 +704,13 @@ const LINE_WEBHOOK_REPLAY_MAX_ENTRIES = 4096;
 function normalizeLineIngressEntry(value) {
 	return normalizeLineAllowEntry(value) || null;
 }
-var LineRetryableWebhookError = class extends Error {
-	constructor(message, options) {
-		super(message, options);
-		this.name = "LineRetryableWebhookError";
-	}
-};
 function createLineWebhookReplayCache() {
-	return createClaimableDedupe({
-		ttlMs: LINE_WEBHOOK_REPLAY_WINDOW_MS,
-		memoryMaxSize: LINE_WEBHOOK_REPLAY_MAX_ENTRIES
+	return createChannelReplayGuard({
+		dedupe: {
+			ttlMs: LINE_WEBHOOK_REPLAY_WINDOW_MS,
+			memoryMaxSize: LINE_WEBHOOK_REPLAY_MAX_ENTRIES
+		},
+		buildReplayKey: ({ event, accountId }) => buildLineWebhookReplayKey(event, accountId)?.key
 	});
 }
 function buildLineWebhookReplayKey(event, accountId) {
@@ -613,29 +730,6 @@ function buildLineWebhookReplayKey(event, accountId) {
 		eventId: `event:${eventId}`
 	};
 }
-function getLineReplayCandidate(event, context) {
-	const replay = buildLineWebhookReplayKey(event, context.account.accountId);
-	const cache = context.replayCache;
-	if (!replay || !cache) return null;
-	return {
-		key: replay.key,
-		eventId: replay.eventId,
-		cache
-	};
-}
-async function claimLineReplayEvent(candidate) {
-	const claim = await candidate.cache.claim(candidate.key);
-	if (claim.kind === "claimed") return { skip: false };
-	if (claim.kind === "inflight") {
-		logVerbose(`line: skipped in-flight replayed webhook event ${candidate.eventId}`);
-		return {
-			skip: true,
-			inFlightResult: claim.pending.then(() => void 0)
-		};
-	}
-	logVerbose(`line: skipped replayed webhook event ${candidate.eventId}`);
-	return { skip: true };
-}
 function resolveLineGroupConfig(params) {
 	return resolveLineGroupConfigEntry(params.config.groups, {
 		groupId: params.groupId,
@@ -710,7 +804,7 @@ async function shouldProcessLineEvent(event, context) {
 		defaultGroupPolicy: resolveDefaultGroupPolicy(cfg)
 	});
 	const groupPolicy = runtimeGroupPolicy === "disabled" ? "disabled" : groupConfig?.allowFrom !== void 0 ? "allowlist" : runtimeGroupPolicy;
-	const groupAllowFrom = normalizeStringEntries(firstDefined(groupConfig?.allowFrom, account.config.groupAllowFrom, account.config.allowFrom?.length ? account.config.allowFrom : void 0));
+	const groupAllowFrom = normalizeStringEntries(firstDefined(groupConfig?.allowFrom, account.config.groupAllowFrom));
 	const mentionFacts = (() => {
 		if (!isGroup || event.type !== "message") return {
 			canDetectMention: false,
@@ -775,7 +869,7 @@ async function shouldProcessLineEvent(event, context) {
 		allowFrom: normalizeStringEntries(account.config.allowFrom),
 		groupAllowFrom,
 		command: {
-			hasControlCommand: shouldComputeCommandAuthorized(rawText, cfg),
+			hasControlCommand: hasControlCommand(rawText, cfg),
 			groupOwnerAllowFrom: "none"
 		}
 	});
@@ -873,42 +967,41 @@ async function handleMessageEvent(event, context) {
 		});
 		return;
 	}
-	const allMedia = [];
-	let mediaUnavailable = false;
-	if (isDownloadableLineMessageType(message.type)) try {
-		const originalFilename = message.type === "file" ? normalizeOptionalString(message.fileName) : void 0;
-		const media = await downloadLineMedia(message.id, account.channelAccessToken, mediaMaxBytes, { originalFilename });
-		allMedia.push({
-			path: media.path,
-			contentType: media.contentType
-		});
-	} catch (err) {
-		mediaUnavailable = true;
-		const errMsg = String(err);
-		if (errMsg.includes("exceeds") && errMsg.includes("limit")) logVerbose(`line: media exceeds size limit for message ${message.id}`);
-		else runtime.error?.(danger(`line: failed to download media: ${errMsg}`));
-	}
-	const messageContext = await buildLineMessageContext({
-		event,
-		allMedia,
-		mediaUnavailable,
-		cfg,
-		account,
-		commandAuthorized: decision.commandAccess.authorized,
-		groupHistories: context.groupHistories,
-		historyLimit: context.historyLimit ?? DEFAULT_GROUP_HISTORY_LIMIT
-	});
-	if (!messageContext) {
-		logVerbose("line: skipping empty message");
-		return;
-	}
-	await processMessage(messageContext);
-	if (isGroup && context.groupHistories) {
-		const historyKey = groupId ?? roomId;
-		if (historyKey && context.groupHistories.has(historyKey)) createChannelHistoryWindow({ historyMap: context.groupHistories }).clear({
-			historyKey,
-			limit: context.historyLimit ?? DEFAULT_GROUP_HISTORY_LIMIT
+	const groupHistoryKey = isGroup ? groupId ?? roomId : void 0;
+	const historyReservation = reserveLineGroupHistory(context.groupHistories, groupHistoryKey, context.historyLimit ?? DEFAULT_GROUP_HISTORY_LIMIT);
+	try {
+		const allMedia = [];
+		let mediaUnavailable = false;
+		if (isDownloadableLineMessageType(message.type)) try {
+			const originalFilename = message.type === "file" ? normalizeOptionalString(message.fileName) : void 0;
+			const media = await downloadLineMedia(message.id, account.channelAccessToken, mediaMaxBytes, { originalFilename });
+			allMedia.push({
+				path: media.path,
+				contentType: media.contentType
+			});
+		} catch (err) {
+			mediaUnavailable = true;
+			const errMsg = String(err);
+			if (errMsg.includes("exceeds") && errMsg.includes("limit")) logVerbose(`line: media exceeds size limit for message ${message.id}`);
+			else runtime.error?.(danger(`line: failed to download media: ${errMsg}`));
+		}
+		const messageContext = await buildLineMessageContext({
+			event,
+			allMedia,
+			mediaUnavailable,
+			cfg,
+			account,
+			commandAuthorized: decision.commandAccess.authorized,
+			inboundHistory: historyReservation.inboundHistory
 		});
+		if (!messageContext) {
+			logVerbose("line: skipping empty message");
+			return;
+		}
+		await processMessage(messageContext);
+		historyReservation.commit();
+	} finally {
+		historyReservation.release();
 	}
 }
 async function handleFollowEvent(event, _context) {
@@ -943,50 +1036,55 @@ async function handlePostbackEvent(event, context) {
 }
 async function handleLineWebhookEvents(events, context) {
 	let firstError;
-	for (const event of events) {
-		const replayCandidate = getLineReplayCandidate(event, context);
-		const replaySkip = replayCandidate ? await claimLineReplayEvent(replayCandidate) : null;
-		if (replaySkip?.skip) {
-			if (replaySkip.inFlightResult) try {
-				await replaySkip.inFlightResult;
+	for (const event of events) try {
+		if (!context.replayCache) {
+			await handleLineWebhookEvent(event, context);
+			continue;
+		}
+		const replayEvent = {
+			event,
+			accountId: context.account.accountId
+		};
+		const result = await context.replayCache.processGuarded(replayEvent, async () => await handleLineWebhookEvent(event, context), { onError: "commit" });
+		const replayId = buildLineWebhookReplayKey(event, context.account.accountId)?.eventId;
+		if (result.kind === "inflight") {
+			logVerbose(`line: skipped in-flight replayed webhook event ${replayId ?? "unknown"}`);
+			try {
+				await result.pending;
 			} catch (err) {
 				context.runtime.error?.(danger(`line: replayed in-flight event failed: ${String(err)}`));
 				firstError ??= err;
 			}
-			continue;
-		}
-		try {
-			switch (event.type) {
-				case "message":
-					await handleMessageEvent(event, context);
-					break;
-				case "follow":
-					await handleFollowEvent(event, context);
-					break;
-				case "unfollow":
-					await handleUnfollowEvent(event, context);
-					break;
-				case "join":
-					await handleJoinEvent(event, context);
-					break;
-				case "leave":
-					await handleLeaveEvent(event, context);
-					break;
-				case "postback":
-					await handlePostbackEvent(event, context);
-					break;
-				default: logVerbose(`line: unhandled event type: ${event.type}`);
-			}
-			if (replayCandidate) await replayCandidate.cache.commit(replayCandidate.key);
-		} catch (err) {
-			if (replayCandidate) if (err instanceof LineRetryableWebhookError) replayCandidate.cache.release(replayCandidate.key, { error: err });
-			else await replayCandidate.cache.commit(replayCandidate.key);
-			context.runtime.error?.(danger(`line: event handler failed: ${String(err)}`));
-			firstError ??= err;
-		}
+		} else if (result.kind === "duplicate") logVerbose(`line: skipped replayed webhook event ${replayId ?? "unknown"}`);
+	} catch (err) {
+		context.runtime.error?.(danger(`line: event handler failed: ${String(err)}`));
+		firstError ??= err;
 	}
 	if (firstError) throw toLintErrorObject(firstError, "Non-Error thrown");
 }
+async function handleLineWebhookEvent(event, context) {
+	switch (event.type) {
+		case "message":
+			await handleMessageEvent(event, context);
+			break;
+		case "follow":
+			await handleFollowEvent(event, context);
+			break;
+		case "unfollow":
+			await handleUnfollowEvent(event, context);
+			break;
+		case "join":
+			await handleJoinEvent(event, context);
+			break;
+		case "leave":
+			await handleLeaveEvent(event, context);
+			break;
+		case "postback":
+			await handlePostbackEvent(event, context);
+			break;
+		default: logVerbose(`line: unhandled event type: ${event.type}`);
+	}
+}
 function toLintErrorObject(value, fallbackMessage) {
 	if (value instanceof Error) return value;
 	if (typeof value === "string") return new Error(value);
@@ -1044,43 +1142,48 @@ function resolveLineDurableReplyOptions(params) {
 //#endregion
 //#region extensions/line/src/reply-chunks.ts
 async function sendLineReplyChunks(params) {
-	const hasQuickReplies = Boolean(params.quickReplies?.length);
+	const quickReplies = params.quickReplies?.length ? params.quickReplies : void 0;
 	let replyTokenUsed = Boolean(params.replyTokenUsed);
 	if (params.chunks.length === 0) return { replyTokenUsed };
-	if (params.replyToken && !replyTokenUsed) try {
-		const replyBatch = params.chunks.slice(0, 5);
-		const remaining = params.chunks.slice(replyBatch.length);
-		const replyMessages = replyBatch.map((chunk) => ({
-			type: "text",
-			text: chunk
-		}));
-		if (hasQuickReplies && remaining.length === 0 && replyMessages.length > 0) {
-			const lastIndex = replyMessages.length - 1;
-			replyMessages[lastIndex] = params.createTextMessageWithQuickReplies(replyBatch[lastIndex], params.quickReplies);
+	if (params.replyToken && !replyTokenUsed) {
+		let replySucceeded = false;
+		try {
+			const replyBatch = params.chunks.slice(0, 5);
+			const remaining = params.chunks.slice(replyBatch.length);
+			const replyMessages = replyBatch.map((chunk) => ({
+				type: "text",
+				text: chunk
+			}));
+			if (quickReplies && remaining.length === 0 && replyMessages.length > 0) {
+				const lastIndex = replyMessages.length - 1;
+				replyMessages[lastIndex] = params.createTextMessageWithQuickReplies(expectDefined(replyBatch[lastIndex], "last non-empty LINE reply batch chunk"), quickReplies);
+			}
+			await params.replyMessageLine(params.replyToken, replyMessages, {
+				cfg: params.cfg,
+				accountId: params.accountId
+			});
+			replyTokenUsed = true;
+			replySucceeded = true;
+			for (const [i, chunk] of remaining.entries()) if (i === remaining.length - 1 && quickReplies) await params.pushTextMessageWithQuickReplies(params.to, chunk, quickReplies, {
+				cfg: params.cfg,
+				accountId: params.accountId
+			});
+			else await params.pushMessageLine(params.to, chunk, {
+				cfg: params.cfg,
+				accountId: params.accountId
+			});
+			return { replyTokenUsed };
+		} catch (err) {
+			if (replySucceeded) throw err;
+			params.onReplyError?.(err);
+			replyTokenUsed = true;
 		}
-		await params.replyMessageLine(params.replyToken, replyMessages, {
-			cfg: params.cfg,
-			accountId: params.accountId
-		});
-		replyTokenUsed = true;
-		for (let i = 0; i < remaining.length; i += 1) if (i === remaining.length - 1 && hasQuickReplies) await params.pushTextMessageWithQuickReplies(params.to, remaining[i], params.quickReplies, {
-			cfg: params.cfg,
-			accountId: params.accountId
-		});
-		else await params.pushMessageLine(params.to, remaining[i], {
-			cfg: params.cfg,
-			accountId: params.accountId
-		});
-		return { replyTokenUsed };
-	} catch (err) {
-		params.onReplyError?.(err);
-		replyTokenUsed = true;
 	}
-	for (let i = 0; i < params.chunks.length; i += 1) if (i === params.chunks.length - 1 && hasQuickReplies) await params.pushTextMessageWithQuickReplies(params.to, params.chunks[i], params.quickReplies, {
+	for (const [i, chunk] of params.chunks.entries()) if (i === params.chunks.length - 1 && quickReplies) await params.pushTextMessageWithQuickReplies(params.to, chunk, quickReplies, {
 		cfg: params.cfg,
 		accountId: params.accountId
 	});
-	else await params.pushMessageLine(params.to, params.chunks[i], {
+	else await params.pushMessageLine(params.to, chunk, {
 		cfg: params.cfg,
 		accountId: params.accountId
 	});
@@ -1089,16 +1192,7 @@ async function sendLineReplyChunks(params) {
 //#endregion
 //#region extensions/line/src/signature.ts
 function validateLineSignature(body, signature, channelSecret) {
-	const hash = crypto.createHmac("SHA256", channelSecret).update(body).digest("base64");
-	const hashBuffer = Buffer.from(hash);
-	const signatureBuffer = Buffer.from(signature);
-	const maxLen = Math.max(hashBuffer.length, signatureBuffer.length);
-	const paddedHash = Buffer.alloc(maxLen);
-	const paddedSig = Buffer.alloc(maxLen);
-	hashBuffer.copy(paddedHash);
-	signatureBuffer.copy(paddedSig);
-	const timingResult = crypto.timingSafeEqual(paddedHash, paddedSig);
-	return hashBuffer.length === signatureBuffer.length && timingResult;
+	return safeEqualSecret(signature, crypto.createHmac("SHA256", channelSecret).update(body).digest("base64"));
 }
 //#endregion
 //#region extensions/line/src/webhook-utils.ts
@@ -1186,7 +1280,7 @@ function createLineNodeWebhookHandler(params) {
 			if (receiveContext.shouldAckAfter("receive_record")) await receiveContext.ack();
 			if (body.events && body.events.length > 0) {
 				logVerbose(`line: received ${body.events.length} webhook events`);
-				Promise.resolve().then(() => params.bot.handleWebhook(body)).catch((err) => logLineWebhookDispatchError(params.runtime, err));
+				runDetachedWebhookWork(() => params.bot.handleWebhook(body)).catch((err) => logLineWebhookDispatchError(params.runtime, err));
 			}
 		} catch (err) {
 			await receiveContext?.nack(err);
@@ -1213,24 +1307,10 @@ function createLineNodeWebhookHandler(params) {
 }
 //#endregion
 //#region extensions/line/src/monitor.ts
-const runtimeState = /* @__PURE__ */ new Map();
 const lineWebhookInFlightLimiter = createWebhookInFlightLimiter();
 const LINE_WEBHOOK_PREAUTH_MAX_BODY_BYTES = 64 * 1024;
 const LINE_WEBHOOK_PREAUTH_BODY_TIMEOUT_MS = 5e3;
 const lineWebhookTargets = /* @__PURE__ */ new Map();
-function recordChannelRuntimeState(params) {
-	const key = `${params.channel}:${params.accountId}`;
-	const existing = runtimeState.get(key) ?? {
-		running: false,
-		lastStartAt: null,
-		lastStopAt: null,
-		lastError: null
-	};
-	runtimeState.set(key, {
-		...existing,
-		...params.state
-	});
-}
 function startLineLoadingKeepalive(params) {
 	const intervalMs = params.intervalMs ?? 18e3;
 	const loadingSeconds = params.loadingSeconds ?? 20;
@@ -1267,11 +1347,6 @@ async function monitorLineProvider(opts) {
 		onMessage: async (ctx) => {
 			if (!ctx) return;
 			const { ctxPayload, replyToken, route } = ctx;
-			recordChannelRuntimeState({
-				channel: "line",
-				accountId: resolvedAccountId,
-				state: { lastInboundAt: Date.now() }
-			});
 			const shouldShowLoading = Boolean(ctx.userId && !ctx.isGroup);
 			const displayNamePromise = ctx.userId ? getUserDisplayName(ctx.userId, {
 				cfg: config,
@@ -1343,7 +1418,7 @@ async function monitorLineProvider(opts) {
 											createTextMessageWithQuickReplies,
 											pushMessagesLine,
 											createFlexMessage,
-											createImageMessage,
+											buildMediaMessage: buildLineMediaMessage,
 											createLocationMessage,
 											onReplyError: (replyErr) => {
 												logVerbose(`line: reply token failed, falling back to push: ${String(replyErr)}`);
@@ -1352,11 +1427,7 @@ async function monitorLineProvider(opts) {
 									});
 									replyTokenUsed = deliveryResult.replyTokenUsed;
 									if (deliveryResult.status === "partial") throw deliveryResult.error;
-									recordChannelRuntimeState({
-										channel: "line",
-										accountId: resolvedAccountId,
-										state: { lastOutboundAt: Date.now() }
-									});
+									return { visibleReplySent: deliveryResult.visibleReplySent };
 								},
 								onError: (err, info) => {
 									runtime.error?.(danger(`line ${info.kind} reply failed: ${String(err)}`));
@@ -1462,7 +1533,7 @@ async function monitorLineProvider(opts) {
 					res.end(JSON.stringify({ status: "ok" }));
 					if (body.events && body.events.length > 0) {
 						logVerbose(`line: received ${body.events.length} webhook events`);
-						Promise.resolve().then(() => match.target.bot.handleWebhook(body)).catch((err) => {
+						runDetachedWebhookWork(() => match.target.bot.handleWebhook(body)).catch((err) => {
 							match.target.runtime.error?.(danger(`line webhook dispatch failed: ${String(err)}`));
 						});
 					}
@@ -1491,14 +1562,6 @@ async function monitorLineProvider(opts) {
 			}
 		}
 	});
-	recordChannelRuntimeState({
-		channel: "line",
-		accountId: resolvedAccountId,
-		state: {
-			running: true,
-			lastStartAt: Date.now()
-		}
-	});
 	logVerbose(`line: registered webhook handler at ${normalizedPath}`);
 	let stopped = false;
 	const stopHandler = () => {
@@ -1506,14 +1569,6 @@ async function monitorLineProvider(opts) {
 		stopped = true;
 		logVerbose(`line: stopping provider for account ${resolvedAccountId}`);
 		unregisterHttp();
-		recordChannelRuntimeState({
-			channel: "line",
-			accountId: resolvedAccountId,
-			state: {
-				running: false,
-				lastStopAt: Date.now()
-			}
-		});
 	};
 	if (abortSignal?.aborted) stopHandler();
 	else if (abortSignal) {