@openclaw/line 2026.7.2-beta.3 → 2026.7.2-beta.4

package/dist/{monitor-Bk-lpoOZ.js → monitor-BinAXvIY.js}

@@ -1,22 +1,23 @@
 import { i as resolveLineAccount, r as resolveDefaultLineAccountId } from "./accounts-BUBOoW5Q.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-D1vapcdP.js";
+import { a as resolveLineGroupConfigEntry, n as getLineRuntime, t as buildLineQuickReplyFallbackText } from "./quick-reply-fallback-D86FwAfr.js";
+import { n as buildLineMediaMessage, r as hasLineSpecificMediaOptions } from "./send-receipt-CY2ey8XH.js";
+import { E as buildTemplateMessageFromPayload, S as replyMessageLine, i as processLineMessage, l as createLocationMessage, p as getUserDisplayName, s as createFlexMessage, u as createQuickReplyItems, v as pushMessageLine, w as showLoadingAnimation, y as pushMessagesLine } from "./markdown-to-line-DWIdzBfy.js";
 import { createChannelPairingChallengeIssuer } from "openclaw/plugin-sdk/channel-pairing";
 import { normalizeOptionalString, normalizeStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { DEFAULT_INGRESS_ADOPTION_STALL_MS, DEFAULT_INGRESS_RETRY_MAX_ATTEMPTS, bindIngressLifecycleToReplyOptions, createChannelIngressDrain } from "openclaw/plugin-sdk/channel-outbound";
+import { DEFAULT_INGRESS_ADOPTION_STALL_MS, DEFAULT_INGRESS_RETRY_MAX_ATTEMPTS, bindIngressLifecycleToReplyOptions, createChannelIngressMonitor } 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 { Readable } from "node:stream";
-import { finished } from "node:stream/promises";
 import { setTimeout as setTimeout$1 } from "node:timers/promises";
+import { MediaFetchError } from "openclaw/plugin-sdk/media-runtime";
 import { saveMediaStream } from "openclaw/plugin-sdk/media-store";
-import { createNonExitingRuntime, danger, logVerbose, shouldLogVerbose, waitForAbortSignal } from "openclaw/plugin-sdk/runtime-env";
+import { createNonExitingRuntime, danger, logVerbose, shouldLogVerbose, waitForAbortSignal, warn } from "openclaw/plugin-sdk/runtime-env";
 import { fetchWithRuntimeDispatcherOrMockedGlobal } from "openclaw/plugin-sdk/runtime-fetch";
+import { HTTPFetchError } from "@line/bot-sdk";
 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 { buildMentionRegexes, formatInboundEnvelope, formatInboundMediaUnavailableText, formatLocationText, hasFinalInboundReplyDispatch, matchesMentionPatterns, resolveInboundSessionEnvelopeContext, toInboundMediaFacts, 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, runDetachedWebhookWork } from "openclaw/plugin-sdk/webhook-request-guards";
@@ -52,44 +53,85 @@ 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";
+var RetryableLineMediaFetchError = class extends MediaFetchError {
+	constructor(message, options) {
+		super("fetch_failed", message, options);
+		this.name = "RetryableLineMediaFetchError";
+	}
+};
 function contentBackoffDelayMs(attempt) {
 	return Math.min(CONTENT_READY_BASE_DELAY_MS * 2 ** attempt, CONTENT_READY_MAX_DELAY_MS);
 }
+function lineContentUrl(messageId) {
+	return `${LINE_CONTENT_BASE_URL}/${encodeURIComponent(messageId)}/content`;
+}
+async function* lineResponseBodyChunks(response, messageId) {
+	const body = response.body;
+	if (!body) throw new RetryableLineMediaFetchError(`LINE media response for message ${messageId} had no body`);
+	const reader = body.getReader();
+	let completed = false;
+	try {
+		while (true) {
+			let chunk;
+			try {
+				chunk = await reader.read();
+			} catch (err) {
+				throw new RetryableLineMediaFetchError(`LINE media response stream failed for message ${messageId}`, { cause: err });
+			}
+			if (chunk.done) {
+				completed = true;
+				return;
+			}
+			if (chunk.value.byteLength > 0) yield chunk.value;
+		}
+	} finally {
+		if (!completed) await reader.cancel().catch(() => void 0);
+		try {
+			reader.releaseLock();
+		} catch {}
+	}
+}
 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`, {
+			const response = await fetchWithRuntimeDispatcherOrMockedGlobal(lineContentUrl(messageId), {
 				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);
+				if (!response.body) throw new RetryableLineMediaFetchError(`LINE media response for message ${messageId} had no body`);
+				return response;
 			}
-			await response.body?.cancel();
-			if (response.status !== 202) throw new Error(`LINE media download failed for message ${messageId} (HTTP ${response.status})`);
+			await response.body?.cancel().catch(() => void 0);
+			if (response.status !== 202) throw new MediaFetchError("http_error", `LINE media download failed for message ${messageId} (HTTP ${response.status})`, { status: 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;
+		if (controller.signal.aborted) throw new RetryableLineMediaFetchError(`LINE media for message ${messageId} did not become ready within ${CONTENT_READY_TIMEOUT_MS / 1e3} seconds`, { cause: err });
+		if (err instanceof MediaFetchError) throw err;
+		throw new RetryableLineMediaFetchError(`LINE media download failed for message ${messageId}`, { cause: err });
 	} finally {
 		clearTimeout(deadline);
 	}
-	throw new Error(`LINE media for message ${messageId} was still preparing (HTTP 202) after ${CONTENT_READY_MAX_ATTEMPTS} attempts`);
+	throw new MediaFetchError("http_error", `LINE media for message ${messageId} was still preparing (HTTP 202) after ${CONTENT_READY_MAX_ATTEMPTS} attempts`, { status: 202 });
+}
+function isRetryableLineInboundMediaError(err) {
+	if (err instanceof RetryableLineMediaFetchError) return true;
+	if (!(err instanceof MediaFetchError)) return false;
+	if (err.code === "http_error") return err.status === 202 || err.status === 408 || err.status === 429 || typeof err.status === "number" && err.status >= 500;
+	return false;
 }
 async function downloadLineMedia(messageId, channelAccessToken, maxBytes = 10 * 1024 * 1024, options) {
-	const content = await fetchLineContentWhenReady(messageId, channelAccessToken);
+	const response = await fetchLineContentWhenReady(messageId, channelAccessToken);
 	let saved;
 	try {
-		saved = await saveMediaStream(content, void 0, "inbound", maxBytes, options?.originalFilename);
+		saved = await saveMediaStream(lineResponseBodyChunks(response, messageId), response.headers.get("content-type") ?? void 0, "inbound", maxBytes, options?.originalFilename);
 	} catch (err) {
-		content.destroy();
-		await finished(content).catch(() => void 0);
+		await response.body?.cancel().catch(() => void 0);
 		throw err;
 	}
 	logVerbose(`line: persisted media ${messageId} to ${saved.path} (${saved.size} bytes)`);
@@ -102,7 +144,11 @@ 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 });
+	return error instanceof Error ? error : new Error("LINE message send failed", { cause: error });
+}
+function getLineHttpError(error) {
+	if (error instanceof HTTPFetchError) return error;
+	return error instanceof Error && error.cause instanceof HTTPFetchError ? error.cause : void 0;
 }
 function markLineVisibleDeliveryError(error) {
 	const deliveryError = toLineDeliveryError(error);
@@ -113,7 +159,7 @@ function markLineVisibleDeliveryError(error) {
 		});
 		return deliveryError;
 	}
-	const visibleError = new Error("LINE rich or media message send failed", { cause: deliveryError });
+	const visibleError = new Error("LINE message send failed", { cause: deliveryError });
 	Object.assign(visibleError, {
 		sentBeforeError: true,
 		visibleReplySent: true
@@ -135,14 +181,25 @@ async function deliverLineAutoReply(params) {
 		}
 	};
 	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) => {
+	const failedPushSegments = /* @__PURE__ */ new WeakMap();
+	const pushLineMessages = async (messages, allowFailedBatchTextRecovery, externalTail = []) => {
 		if (messages.length === 0) return;
-		for (let i = 0; i < messages.length; i += 5) await sendVisible(() => deps.pushMessagesLine(to, messages.slice(i, i + 5), {
-			cfg: params.cfg,
-			accountId
-		}));
+		for (let i = 0; i < messages.length; i += 5) {
+			const batch = messages.slice(i, i + 5);
+			try {
+				await sendVisible(() => deps.pushMessagesLine(to, batch, {
+					cfg: params.cfg,
+					accountId
+				}));
+			} catch (error) {
+				if (typeof error === "object" && error !== null) failedPushSegments.set(error, {
+					allowFailedBatchTextRecovery,
+					failedBatch: batch,
+					unattemptedTail: [...messages.slice(i + batch.length), ...externalTail]
+				});
+				throw error;
+			}
+		}
 	};
 	const sendLineMessages = async (messages, allowReplyToken) => {
 		if (messages.length === 0) return;
@@ -156,12 +213,13 @@ async function deliverLineAutoReply(params) {
 				});
 			} catch (err) {
 				deps.onReplyError?.(err);
-				await pushLineMessages(replyBatch);
+				await pushLineMessages(replyBatch, getLineHttpError(err)?.status === 400, remaining.slice(replyBatch.length));
+			} finally {
+				replyTokenUsed = true;
 			}
-			replyTokenUsed = true;
 			remaining = remaining.slice(replyBatch.length);
 		}
-		if (remaining.length > 0) await pushLineMessages(remaining);
+		if (remaining.length > 0) await pushLineMessages(remaining, true);
 	};
 	const richMessages = [];
 	const hasQuickReplies = Boolean(lineData.quickReplies?.length);
@@ -186,82 +244,59 @@ async function deliverLineAutoReply(params) {
 		trackingId: lineData.trackingId
 	};
 	const mediaMessages = [];
-	let richMediaError;
+	let deliveryError;
 	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;
+			deliveryError ??= err;
 		}
 	}
-	if (chunks.length > 0) {
-		const hasRichOrMedia = richMessages.length > 0 || mediaMessages.length > 0;
-		const sendRichBeforeText = hasQuickReplies && hasRichOrMedia;
-		if (sendRichBeforeText) try {
-			await sendLineMessages([...richMessages, ...mediaMessages], false);
-		} catch (err) {
-			richMediaError ??= err;
-		}
-		const { replyTokenUsed: nextReplyTokenUsed } = await deps.sendLineReplyChunks({
-			to,
-			chunks,
-			quickReplies: lineData.quickReplies,
-			replyToken,
-			replyTokenUsed,
-			cfg: params.cfg,
-			accountId,
-			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;
-		}
-	} else {
-		const combined = [...richMessages, ...mediaMessages];
-		if (hasQuickReplies && combined.length === 0) {
-			const { replyTokenUsed: nextReplyTokenUsed } = await deps.sendLineReplyChunks({
-				to,
-				chunks: [buildLineQuickReplyFallbackText(lineData.quickReplies)],
-				quickReplies: lineData.quickReplies,
-				replyToken,
-				replyTokenUsed,
-				cfg: params.cfg,
-				accountId,
-				replyMessageLine: replyVisible,
-				pushMessageLine: pushTextVisible,
-				pushTextMessageWithQuickReplies: pushQuickRepliesVisible,
-				createTextMessageWithQuickReplies: deps.createTextMessageWithQuickReplies,
-				onReplyError: deps.onReplyError
-			});
-			replyTokenUsed = nextReplyTokenUsed;
-		} else {
-			if (hasQuickReplies && combined.length > 0) {
-				const quickReply = deps.createQuickReplyItems(lineData.quickReplies);
-				const targetIndex = replyToken && !replyTokenUsed ? Math.min(4, combined.length - 1) : combined.length - 1;
-				combined[targetIndex] = {
-					...combined[targetIndex],
-					quickReply
-				};
-			}
-			await sendLineMessages(combined, true);
-		}
+	const textMessages = chunks.map((text) => ({
+		type: "text",
+		text
+	}));
+	const richMediaMessages = [...richMessages, ...mediaMessages];
+	if (hasQuickReplies && textMessages.length === 0 && richMediaMessages.length === 0) textMessages.push({
+		type: "text",
+		text: buildLineQuickReplyFallbackText(lineData.quickReplies)
+	});
+	if (hasQuickReplies) {
+		const targetMessages = textMessages.length > 0 ? textMessages : richMediaMessages;
+		const lastIndex = targetMessages.length - 1;
+		targetMessages[lastIndex] = {
+			...expectDefined(targetMessages[lastIndex], "last LINE auto-reply message"),
+			quickReply: deps.createQuickReplyItems(lineData.quickReplies)
+		};
 	}
-	if (richMediaError !== void 0) {
-		if (!visibleReplySent) throw toLineDeliveryError(richMediaError);
+	const messages = hasQuickReplies ? [...richMediaMessages, ...textMessages] : [...textMessages, ...richMediaMessages];
+	try {
+		await sendLineMessages(messages, true);
+	} catch (err) {
+		deliveryError ??= err;
+		const failedSegment = typeof err === "object" && err !== null ? failedPushSegments.get(err) : void 0;
+		const httpError = getLineHttpError(err);
+		const retryCandidates = failedSegment ? [...failedSegment.allowFailedBatchTextRecovery ? failedSegment.failedBatch : [], ...failedSegment.unattemptedTail] : [];
+		const retryTextMessages = retryCandidates.filter((message) => message.type === "text");
+		const quickRepliesNeedCarrier = hasQuickReplies && retryCandidates.some((message) => "quickReply" in message);
+		const retryMessages = retryTextMessages.length > 0 ? retryTextMessages : quickRepliesNeedCarrier ? [{
+			type: "text",
+			text: buildLineQuickReplyFallbackText(lineData.quickReplies),
+			quickReply: deps.createQuickReplyItems(lineData.quickReplies)
+		}] : [];
+		if (retryMessages.length > 0 && failedSegment?.failedBatch.some((message) => message.type !== "text") && httpError?.status === 400) try {
+			await sendLineMessages(retryMessages, false);
+		} catch {}
+	}
+	if (deliveryError !== void 0) {
+		if (!visibleReplySent) throw toLineDeliveryError(deliveryError);
 		return {
 			status: "partial",
 			replyTokenUsed,
 			visibleReplySent: true,
-			error: markLineVisibleDeliveryError(richMediaError)
+			error: markLineVisibleDeliveryError(deliveryError)
 		};
 	}
 	return {
@@ -397,13 +432,13 @@ function extractMessageText(message) {
 	}
 	return "";
 }
-function extractMediaPlaceholder(message) {
+function extractNativeMediaKind(message) {
 	switch (message.type) {
-		case "image": return "<media:image>";
-		case "video": return "<media:video>";
-		case "audio": return "<media:audio>";
-		case "file": return "<media:document>";
-		default: return "";
+		case "image": return "image";
+		case "video": return "video";
+		case "audio": return "audio";
+		case "file": return "document";
+		default: return;
 	}
 }
 function resolveLineConversationLabel(params) {
@@ -439,6 +474,7 @@ async function finalizeLineInboundContext(params) {
 		sessionKey: params.route.sessionKey
 	});
 	const agentBody = params.agentBody ?? params.rawBody;
+	const media = toInboundMediaFacts(params.media);
 	const body = formatInboundEnvelope({
 		channel: "LINE",
 		from: conversationLabel,
@@ -467,12 +503,7 @@ async function finalizeLineInboundContext(params) {
 		Surface: "line",
 		MessageSid: params.messageSid,
 		Timestamp: params.timestamp,
-		MediaPath: params.media.firstPath,
-		MediaType: params.media.firstContentType,
-		MediaUrl: params.media.firstPath,
-		MediaPaths: params.media.paths,
-		MediaUrls: params.media.paths,
-		MediaTypes: params.media.types,
+		media,
 		...params.locationContext,
 		CommandAuthorized: params.commandAuthorized,
 		OriginatingChannel: "line",
@@ -535,15 +566,17 @@ async function buildLineMessageContext(params) {
 	const messageId = message.id;
 	const timestamp = event.timestamp;
 	const textContent = extractMessageText(message);
-	const placeholder = extractMediaPlaceholder(message);
-	let rawBody = textContent || placeholder;
-	if (!rawBody && allMedia.length > 0) rawBody = `<media:image>${allMedia.length > 1 ? ` (${allMedia.length} images)` : ""}`;
+	const nativeMediaKind = extractNativeMediaKind(message);
+	const mediaFacts = allMedia.length > 0 ? allMedia.map((media) => ({
+		...media,
+		kind: nativeMediaKind
+	})) : nativeMediaKind ? [{ kind: nativeMediaKind }] : [];
+	const rawBody = textContent;
 	const agentBody = mediaUnavailable ? formatInboundMediaUnavailableText({
 		body: rawBody,
-		mediaPlaceholder: placeholder,
 		notice: "[line attachment unavailable]"
 	}) : rawBody;
-	if (!agentBody && allMedia.length === 0) return null;
+	if (!agentBody && mediaFacts.length === 0) return null;
 	let locationContext;
 	if (message.type === "location") {
 		const loc = message;
@@ -571,12 +604,7 @@ async function buildLineMessageContext(params) {
 		timestamp,
 		messageSid: messageId,
 		commandAuthorized,
-		media: {
-			firstPath: allMedia[0]?.path,
-			firstContentType: allMedia[0]?.contentType,
-			paths: allMedia.length > 0 ? allMedia.map((m) => m.path) : void 0,
-			types: allMedia.length > 0 ? allMedia.map((m) => m.contentType).filter(Boolean) : void 0
-		},
+		media: mediaFacts,
 		locationContext,
 		verboseLog: {
 			kind: "inbound",
@@ -632,12 +660,7 @@ async function buildLinePostbackContext(params) {
 		timestamp,
 		messageSid,
 		commandAuthorized,
-		media: {
-			firstPath: "",
-			firstContentType: void 0,
-			paths: void 0,
-			types: void 0
-		},
+		media: [],
 		verboseLog: { kind: "postback" }
 	});
 	return {
@@ -952,6 +975,7 @@ async function handleMessageEvent(event, context) {
 				contentType: media.contentType
 			});
 		} catch (err) {
+			if (isRetryableLineInboundMediaError(err)) throw err;
 			mediaUnavailable = true;
 			const errMsg = String(err);
 			if (errMsg.includes("exceeds") && errMsg.includes("limit")) logVerbose(`line: media exceeds size limit for message ${message.id}`);
@@ -1052,6 +1076,7 @@ const LINE_WEBHOOK_SPOOL_VERSION = 1;
 const LINE_WEBHOOK_DRAIN_INTERVAL_MS = 500;
 const LINE_WEBHOOK_MAX_CONCURRENT_DELIVERIES = 8;
 const LINE_WEBHOOK_DRAIN_SCAN_LIMIT = 100;
+const LINE_WEBHOOK_ACTIVE_DELIVERY_STOP_GRACE_MS = 5e3;
 const LINE_WEBHOOK_TOMBSTONE_TTL_MS = 720 * 60 * 6e4;
 const LINE_WEBHOOK_TOMBSTONE_MAX_ENTRIES = 4096;
 var LineWebhookPayloadError = class extends Error {
@@ -1099,15 +1124,13 @@ function laneKeyFor(event, eventId) {
 	}
 	return eventId;
 }
-function parseClaimedEvent(payload, claimedId) {
-	if (payload.version !== LINE_WEBHOOK_SPOOL_VERSION || typeof payload.rawEvent !== "string" || typeof payload.destination !== "string") throw new LineWebhookPayloadError("LINE webhook spool payload is invalid.");
+function parseStoredEvent(rawEvent) {
 	let event;
 	try {
-		event = JSON.parse(payload.rawEvent);
+		event = JSON.parse(rawEvent);
 	} catch (error) {
 		throw new LineWebhookPayloadError("LINE webhook event JSON is invalid.", { cause: error });
 	}
-	if (eventIdFor(event) !== claimedId) throw new LineWebhookPayloadError("LINE webhook event id changed after durable admission.");
 	return event;
 }
 function errorText(error) {
@@ -1118,41 +1141,61 @@ function isLineAuthenticationFailure(error) {
 	const status = error.status;
 	return status === 401 || status === 403;
 }
+async function waitForActiveDeliveriesBeforeDispose(activeDeliveries) {
+	let timeout;
+	try {
+		return await Promise.race([Promise.allSettled(activeDeliveries).then(() => true), new Promise((resolve) => {
+			timeout = setTimeout(() => resolve(false), LINE_WEBHOOK_ACTIVE_DELIVERY_STOP_GRACE_MS);
+			timeout.unref?.();
+		})]);
+	} finally {
+		if (timeout) clearTimeout(timeout);
+	}
+}
 function createLineWebhookSpool(options) {
 	const queue = options.queue ?? getLineRuntime().state.openChannelIngressQueue({ accountId: options.accountId });
-	const shutdown = new AbortController();
 	const activeDeliveries = /* @__PURE__ */ new Set();
 	const deferredClaims = /* @__PURE__ */ new Map();
-	const drain = createChannelIngressDrain({
+	let acceptsDeferredClaims = true;
+	const monitor = createChannelIngressMonitor({
 		queue,
-		abortSignal: shutdown.signal,
-		adoptionStallTimeoutMs: DEFAULT_INGRESS_ADOPTION_STALL_MS,
-		orderBy: "received",
-		scanLimit: LINE_WEBHOOK_DRAIN_SCAN_LIMIT,
-		startLimit: LINE_WEBHOOK_MAX_CONCURRENT_DELIVERIES,
-		retryPolicy: {
-			maxAttempts: DEFAULT_INGRESS_RETRY_MAX_ATTEMPTS,
-			deadLetterMinAgeMs: 0
-		},
-		resolveNonRetryableFailure: (error) => {
-			if (error instanceof LineWebhookPayloadError) return {
-				reason: "invalid-event",
-				message: error.message
+		inspect: ({ event }) => {
+			const eventId = eventIdFor(event);
+			return {
+				eventId,
+				laneKey: laneKeyFor(event, eventId)
 			};
-			if (error instanceof LineWebhookTerminalDeliveryError) return {
-				reason: error.reason,
-				message: error.message
-			};
-			if (isLineAuthenticationFailure(error)) return {
-				reason: "authentication-failed",
-				message: errorText(error)
-			};
-			return null;
 		},
-		onLog: (message) => options.runtime.error?.(danger(`line: ${message}`)),
-		dispatchClaimedEvent: async (claimed, lifecycle) => {
-			const event = parseClaimedEvent(claimed.payload, claimed.id);
+		payload: {
+			version: LINE_WEBHOOK_SPOOL_VERSION,
+			serialize: ({ event, destination }) => ({
+				rawEvent: JSON.stringify(event),
+				destination
+			}),
+			deserialize: ({ rawEvent, destination }) => ({
+				event: parseStoredEvent(rawEvent),
+				destination
+			}),
+			encode: ({ version, body }) => ({
+				version,
+				rawEvent: body.rawEvent,
+				destination: body.destination
+			}),
+			decode: (payload) => {
+				if (typeof payload.rawEvent !== "string" || typeof payload.destination !== "string") throw new LineWebhookPayloadError("LINE webhook spool payload is invalid.");
+				return {
+					version: payload.version,
+					body: {
+						rawEvent: payload.rawEvent,
+						destination: payload.destination
+					}
+				};
+			},
+			createClaimError: (kind) => new LineWebhookPayloadError(kind === "invalid-version" ? "LINE webhook spool payload is invalid." : "LINE webhook event identity changed after durable admission.")
+		},
+		deliver: async ({ event, destination }, lifecycle, claim) => {
 			const boundLifecycle = bindIngressLifecycleToReplyOptions(lifecycle).turnAdoptionLifecycle;
+			let handedOff = false;
 			let resolveDeferredClaim;
 			const deferredClaim = new Promise((resolve) => {
 				resolveDeferredClaim = resolve;
@@ -1161,12 +1204,13 @@ function createLineWebhookSpool(options) {
 			const settleDeferredClaim = () => {
 				if (deferredClaimSettled) return;
 				deferredClaimSettled = true;
-				if (deferredClaims.get(claimed.id) === deferredClaim) deferredClaims.delete(claimed.id);
+				if (deferredClaims.get(claim.id) === deferredClaim) deferredClaims.delete(claim.id);
 				resolveDeferredClaim();
 			};
-			const delivery = options.deliver(event, claimed.payload.destination, { turnAdoptionLifecycle: {
+			const delivery = options.deliver(event, destination, { turnAdoptionLifecycle: {
 				...boundLifecycle,
 				onAdopted: async () => {
+					handedOff = true;
 					try {
 						await boundLifecycle.onAdopted();
 					} finally {
@@ -1174,10 +1218,19 @@ function createLineWebhookSpool(options) {
 					}
 				},
 				onDeferred: () => {
-					if (!deferredClaimSettled) deferredClaims.set(claimed.id, deferredClaim);
+					handedOff = true;
+					if (!acceptsDeferredClaims) {
+						settleDeferredClaim();
+						Promise.resolve().then(() => boundLifecycle.onAbandoned()).catch((error) => {
+							options.runtime.error?.(danger(`line: failed to abandon a late webhook delivery: ${errorText(error)}`));
+						});
+						return;
+					}
+					if (!deferredClaimSettled) deferredClaims.set(claim.id, deferredClaim);
 					boundLifecycle.onDeferred();
 				},
 				onAbandoned: async () => {
+					handedOff = true;
 					try {
 						await boundLifecycle.onAbandoned();
 					} finally {
@@ -1191,73 +1244,80 @@ function createLineWebhookSpool(options) {
 			} finally {
 				activeDeliveries.delete(delivery);
 			}
-		}
+			if (stopTask && !handedOff) return {
+				kind: "failed-retryable",
+				error: /* @__PURE__ */ new Error("LINE webhook spool stopped before delivery handoff.")
+			};
+		},
+		pollIntervalMs: LINE_WEBHOOK_DRAIN_INTERVAL_MS,
+		retention: {
+			pruneIntervalMs: 0,
+			completedTtlMs: LINE_WEBHOOK_TOMBSTONE_TTL_MS,
+			completedMaxEntries: LINE_WEBHOOK_TOMBSTONE_MAX_ENTRIES,
+			failedTtlMs: LINE_WEBHOOK_TOMBSTONE_TTL_MS,
+			failedMaxEntries: LINE_WEBHOOK_TOMBSTONE_MAX_ENTRIES
+		},
+		appendRetryDelaysMs: [0],
+		waitForDeliveryIdleBeforeRepump: false,
+		waitForDeliveryIdleOnStop: false,
+		runPumpTask: runDetachedWebhookWork,
+		admissionMode: "durable-after-stop",
+		drain: {
+			adoptionStallTimeoutMs: DEFAULT_INGRESS_ADOPTION_STALL_MS,
+			orderBy: "received",
+			scanLimit: LINE_WEBHOOK_DRAIN_SCAN_LIMIT,
+			startLimit: LINE_WEBHOOK_MAX_CONCURRENT_DELIVERIES,
+			retryPolicy: {
+				maxAttempts: DEFAULT_INGRESS_RETRY_MAX_ATTEMPTS,
+				deadLetterMinAgeMs: 0
+			},
+			resolveNonRetryableFailure: (error) => {
+				if (error instanceof LineWebhookPayloadError) return {
+					reason: "invalid-event",
+					message: error.message
+				};
+				if (error instanceof LineWebhookTerminalDeliveryError) return {
+					reason: error.reason,
+					message: error.message
+				};
+				if (isLineAuthenticationFailure(error)) return {
+					reason: "authentication-failed",
+					message: errorText(error)
+				};
+				return null;
+			},
+			onLog: (message) => options.runtime.error?.(danger(`line: ${message}`))
+		},
+		createStoppedError: () => /* @__PURE__ */ new Error("LINE webhook spool is stopped."),
+		onError: (error) => options.runtime.error?.(danger(`line: webhook spool drain failed: ${errorText(error)}`))
 	});
-	let running = false;
-	let drainRequested = false;
-	let drainTask;
-	let drainTimer;
-	const requestDrain = () => {
-		if (!running || shutdown.signal.aborted) return;
-		drainRequested = true;
-		if (drainTask) return;
-		drainTask = runDetachedWebhookWork(async () => {
-			while (drainRequested && !shutdown.signal.aborted) {
-				if (!running) break;
-				drainRequested = false;
-				await drain.drainOnce({ shouldStop: () => !running || shutdown.signal.aborted || activeDeliveries.size >= LINE_WEBHOOK_MAX_CONCURRENT_DELIVERIES });
-			}
-		}).catch((error) => {
-			options.runtime.error?.(danger(`line: webhook spool drain failed: ${errorText(error)}`));
-		}).finally(() => {
-			drainTask = void 0;
-			if (running && drainRequested && !shutdown.signal.aborted) requestDrain();
-		});
-	};
+	let stopTask;
 	return {
 		accept: async (body) => {
 			const events = body.events ?? [];
 			if (events.length === 0) return;
-			await queue.prune({
-				completedTtlMs: LINE_WEBHOOK_TOMBSTONE_TTL_MS,
-				completedMaxEntries: LINE_WEBHOOK_TOMBSTONE_MAX_ENTRIES,
-				failedTtlMs: LINE_WEBHOOK_TOMBSTONE_TTL_MS,
-				failedMaxEntries: LINE_WEBHOOK_TOMBSTONE_MAX_ENTRIES
-			});
-			const receivedAt = Date.now();
-			for (const event of events) {
-				const eventId = eventIdFor(event);
-				await queue.enqueue(eventId, {
-					version: LINE_WEBHOOK_SPOOL_VERSION,
-					rawEvent: JSON.stringify(event),
-					destination: body.destination ?? ""
-				}, {
-					receivedAt,
-					laneKey: laneKeyFor(event, eventId)
-				});
-			}
-			requestDrain();
+			await monitor.admitBatch(events.map((event) => ({
+				event,
+				destination: body.destination ?? ""
+			})), { receivedAt: Date.now() });
 		},
 		start: () => {
-			if (running) return;
-			running = true;
-			requestDrain();
-			drainTimer = setInterval(requestDrain, LINE_WEBHOOK_DRAIN_INTERVAL_MS);
-			drainTimer.unref?.();
+			if (!stopTask) monitor.start();
 		},
-		stop: async () => {
-			if (!running && shutdown.signal.aborted) return;
-			running = false;
-			if (drainTimer) {
-				clearInterval(drainTimer);
-				drainTimer = void 0;
-			}
-			shutdown.abort();
-			await drainTask;
-			await Promise.allSettled(activeDeliveries);
-			await Promise.allSettled(deferredClaims.values());
-			await drain.waitForIdle();
-			drain.dispose();
+		stop: () => {
+			stopTask ??= (async () => {
+				await monitor.pause();
+				try {
+					const deliveriesSettled = await waitForActiveDeliveriesBeforeDispose(activeDeliveries);
+					if (!deliveriesSettled) options.runtime.log(warn(`line: timed out after ${LINE_WEBHOOK_ACTIVE_DELIVERY_STOP_GRACE_MS}ms waiting for active webhook deliveries; releasing drain ownership`));
+					while (deferredClaims.size > 0) await Promise.allSettled(deferredClaims.values());
+					acceptsDeferredClaims = false;
+					if (deliveriesSettled) await monitor.waitForIdle();
+				} finally {
+					await monitor.stop();
+				}
+			})();
+			return stopTask;
 		}
 	};
 }
@@ -1311,56 +1371,6 @@ function resolveLineDurableReplyOptions(params) {
 	return { to: params.to };
 }
 //#endregion
-//#region extensions/line/src/reply-chunks.ts
-async function sendLineReplyChunks(params) {
-	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) {
-		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;
-		}
-	}
-	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, chunk, {
-		cfg: params.cfg,
-		accountId: params.accountId
-	});
-	return { replyTokenUsed };
-}
-//#endregion
 //#region extensions/line/src/signature.ts
 function validateLineSignature(body, signature, channelSecret) {
 	return safeEqualSecret(signature, crypto.createHmac("SHA256", channelSecret).update(body).digest("base64"));
@@ -1576,12 +1586,8 @@ async function monitorLineProvider(opts) {
 											buildTemplateMessageFromPayload,
 											processLineMessage,
 											chunkMarkdownText,
-											sendLineReplyChunks,
 											replyMessageLine,
-											pushMessageLine,
-											pushTextMessageWithQuickReplies,
 											createQuickReplyItems,
-											createTextMessageWithQuickReplies,
 											pushMessagesLine,
 											createFlexMessage,
 											buildMediaMessage: buildLineMediaMessage,