@openclaw/line 2026.7.2-beta.7 → 2026.8.1-beta.3

package/dist/send-BJCeiiOB.js

@@ -0,0 +1,398 @@
+import { i as resolveLineAccount } from "./accounts-BqEVsDoB.js";
+import { h as normalizeLineMessageActions, p as messageAction, t as createLineSendReceipt, x as validateLineMediaUrl } from "./send-receipt-DKZzgHMO.js";
+import { createChannelPartialDeliveryError } from "openclaw/plugin-sdk/channel-inbound";
+import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
+import { logVerbose } from "openclaw/plugin-sdk/runtime-env";
+import { fetchWithRuntimeDispatcherOrMockedGlobal } from "openclaw/plugin-sdk/runtime-fetch";
+import { HTTPFetchError, messagingApi } from "@line/bot-sdk";
+import { collectErrorGraphCandidates, extractErrorCode } from "openclaw/plugin-sdk/error-runtime";
+import { randomUUID } from "node:crypto";
+import lineBotSdkPackage from "@line/bot-sdk/package.json" with { type: "json" };
+import { recordChannelActivity } from "openclaw/plugin-sdk/channel-activity-runtime";
+import { pruneMapToMaxSize } from "openclaw/plugin-sdk/collection-runtime";
+import { requireRuntimeConfig } from "openclaw/plugin-sdk/plugin-config-runtime";
+import { classifyTransientNetworkErrorCode, createChannelApiRetryRunner } from "openclaw/plugin-sdk/retry-runtime";
+//#region extensions/line/src/channel-access-token.ts
+function resolveLineChannelAccessToken(explicit, params) {
+	if (explicit?.trim()) return explicit.trim();
+	if (!params.channelAccessToken) throw new Error(`LINE channel access token missing for account "${params.accountId}" (set channels.line.channelAccessToken or LINE_CHANNEL_ACCESS_TOKEN).`);
+	return params.channelAccessToken.trim();
+}
+//#endregion
+//#region extensions/line/src/send-retry.ts
+function isRetryableLinePushError(error) {
+	const candidates = collectErrorGraphCandidates(error, (candidate) => [candidate.cause, candidate.error]);
+	const httpError = candidates.find((candidate) => candidate instanceof HTTPFetchError);
+	if (httpError) return httpError.status >= 500;
+	return candidates.some((candidate) => classifyTransientNetworkErrorCode(extractErrorCode(candidate)) !== void 0);
+}
+/**
+* Pushes are non-idempotent without a retry key, so the generic message-matching
+* fallback stays off and only the classification above may replay a request.
+*/
+const runLinePushWithRetries = createChannelApiRetryRunner({
+	shouldRetry: isRetryableLinePushError,
+	strictShouldRetry: true,
+	verbose: true
+});
+//#endregion
+//#region extensions/line/src/send.ts
+const userProfileCache = /* @__PURE__ */ new Map();
+const PROFILE_CACHE_TTL_MS = 300 * 1e3;
+const PROFILE_CACHE_MAX_ENTRIES = 1e3;
+const LINE_FLEX_ALT_TEXT_LIMIT = 1500;
+const LINE_LOCATION_LABEL_LIMIT = 100;
+function cacheUserProfile(userId, profile) {
+	userProfileCache.delete(userId);
+	userProfileCache.set(userId, profile);
+	if (userProfileCache.size <= PROFILE_CACHE_MAX_ENTRIES) return;
+	for (const [key, cached] of userProfileCache) if (profile.fetchedAt - cached.fetchedAt >= PROFILE_CACHE_TTL_MS) userProfileCache.delete(key);
+	pruneMapToMaxSize(userProfileCache, PROFILE_CACHE_MAX_ENTRIES);
+}
+function resolveLineProviderMessageIds(response, operation) {
+	const sentMessages = Array.isArray(response?.sentMessages) ? response.sentMessages : [];
+	const messageIds = sentMessages.flatMap((entry) => {
+		const id = entry && typeof entry === "object" ? entry.id : void 0;
+		const messageId = typeof id === "string" ? id.trim() : "";
+		return messageId ? [messageId] : [];
+	});
+	const messageId = messageIds[0];
+	if (!messageId || messageIds.length !== sentMessages.length) throw createChannelPartialDeliveryError(/* @__PURE__ */ new Error(`LINE ${operation} response did not include a sent message id`), {
+		messageIds,
+		visibleReplySent: true
+	});
+	return {
+		messageId,
+		messageIds
+	};
+}
+function normalizeTarget(to) {
+	const trimmed = to.trim();
+	if (!trimmed) throw new Error("Recipient is required for LINE sends");
+	const normalized = trimmed.replace(/^line:group:/i, "").replace(/^line:room:/i, "").replace(/^line:user:/i, "").replace(/^line:/i, "");
+	if (!normalized) throw new Error("Recipient is required for LINE sends");
+	if (normalized.length >= 33 && !/^[CUR]/.test(normalized)) throw new Error(`Recipient is not a valid LINE id (case-sensitive; expected leading capital C/U/R): ${truncateUtf16Safe(normalized, 4)}…`);
+	return normalized;
+}
+function isLineUserChatId(chatId) {
+	return /^U/i.test(chatId);
+}
+function resolveLineMessagingAccount(opts) {
+	const account = resolveLineAccount({
+		cfg: requireRuntimeConfig(opts.cfg, "LINE send"),
+		accountId: opts.accountId
+	});
+	return {
+		account,
+		token: resolveLineChannelAccessToken(opts.channelAccessToken, account)
+	};
+}
+function createLineMessagingClient(opts) {
+	const { account, token } = resolveLineMessagingAccount(opts);
+	return {
+		account,
+		client: new messagingApi.MessagingApiClient({ channelAccessToken: token })
+	};
+}
+function createLinePushContext(to, opts) {
+	const { account, token } = resolveLineMessagingAccount(opts);
+	return {
+		account,
+		token,
+		chatId: normalizeTarget(to)
+	};
+}
+async function sendLineProviderMessages(operation, token, request, retryKey) {
+	const response = await fetchWithRuntimeDispatcherOrMockedGlobal(`https://api.line.me/v2/bot/message/${operation}`, {
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			Authorization: `Bearer ${token}`,
+			"User-Agent": `@line/bot-sdk/${lineBotSdkPackage.version}`,
+			...retryKey ? { "X-Line-Retry-Key": retryKey } : {}
+		},
+		body: JSON.stringify(request)
+	});
+	const acceptedRetryConflict = retryKey !== void 0 && response.status === 409;
+	if (!response.ok && !acceptedRetryConflict) throw new HTTPFetchError(`${response.status} - ${response.statusText}`, {
+		status: response.status,
+		statusText: response.statusText,
+		headers: response.headers,
+		body: await response.text()
+	});
+	try {
+		const text = await response.text();
+		return text ? JSON.parse(text) : null;
+	} catch (error) {
+		throw createChannelPartialDeliveryError(error, {
+			messageIds: [],
+			visibleReplySent: true
+		});
+	}
+}
+function createTextMessage(text) {
+	return {
+		type: "text",
+		text
+	};
+}
+function createImageMessage(originalContentUrl, previewImageUrl) {
+	return {
+		type: "image",
+		originalContentUrl,
+		previewImageUrl: previewImageUrl ?? originalContentUrl
+	};
+}
+function createVideoMessage(originalContentUrl, previewImageUrl, trackingId) {
+	return {
+		type: "video",
+		originalContentUrl,
+		previewImageUrl,
+		...trackingId ? { trackingId } : {}
+	};
+}
+function createAudioMessage(originalContentUrl, durationMs) {
+	return {
+		type: "audio",
+		originalContentUrl,
+		duration: durationMs
+	};
+}
+function isValidLineLocation(location) {
+	return location.title.trim().length > 0 && location.address.trim().length > 0;
+}
+function locationTextFallback(location) {
+	return {
+		type: "text",
+		text: [...[location.title, location.address].map((label) => truncateUtf16Safe(label.trim(), LINE_LOCATION_LABEL_LIMIT)).filter(Boolean), `${location.latitude}, ${location.longitude}`].join("\n")
+	};
+}
+function createLocationMessage(location) {
+	if (!isValidLineLocation(location)) return locationTextFallback(location);
+	return {
+		type: "location",
+		title: truncateUtf16Safe(location.title, LINE_LOCATION_LABEL_LIMIT),
+		address: truncateUtf16Safe(location.address, LINE_LOCATION_LABEL_LIMIT),
+		latitude: location.latitude,
+		longitude: location.longitude
+	};
+}
+function logLineHttpError(err, context) {
+	if (!err || typeof err !== "object") return;
+	const { status, statusText, body } = err;
+	if (typeof body === "string") logVerbose(`line: ${context} failed (${status ? `${status} ${statusText ?? ""}`.trim() : "unknown status"}): ${body}`);
+}
+function recordLineOutboundActivity(accountId, delivery) {
+	try {
+		recordChannelActivity({
+			channel: "line",
+			accountId,
+			direction: "outbound"
+		});
+	} catch (error) {
+		throw createChannelPartialDeliveryError(error, {
+			messageIds: delivery.messageIds,
+			...delivery.receipt ? { receipt: delivery.receipt } : {},
+			visibleReplySent: true
+		});
+	}
+}
+function resolveLineReceiptKind(messages) {
+	const types = new Set(messages.map((message) => message.type));
+	if (types.has("audio")) return "voice";
+	if (types.has("image") || types.has("video")) return "media";
+	if (types.has("flex") || types.has("template") || types.has("location")) return "card";
+	if (types.has("text")) return "text";
+	return "unknown";
+}
+async function pushLineMessages(to, messages, opts, behavior = {}) {
+	if (messages.length === 0) throw new Error("Message must be non-empty for LINE sends");
+	const { account, token, chatId } = createLinePushContext(to, opts);
+	const normalizedMessages = messages.map(normalizeLineMessageActions);
+	const retryKey = randomUUID();
+	const { messageId, messageIds } = resolveLineProviderMessageIds(await runLinePushWithRetries(async () => {
+		try {
+			return await sendLineProviderMessages("push", token, {
+				to: chatId,
+				messages: normalizedMessages
+			}, retryKey);
+		} catch (err) {
+			if (behavior.errorContext) logLineHttpError(err, behavior.errorContext);
+			throw err;
+		}
+	}, "line:push"), "push");
+	const result = {
+		messageId,
+		chatId,
+		receipt: createLineSendReceipt({
+			messageId,
+			messageIds,
+			chatId,
+			kind: resolveLineReceiptKind(messages),
+			messageCount: messages.length
+		})
+	};
+	recordLineOutboundActivity(account.accountId, {
+		messageIds,
+		receipt: result.receipt
+	});
+	if (opts.verbose) logVerbose(behavior.verboseMessage?.(chatId, messages.length) ?? `line: pushed ${messages.length} messages to ${chatId}`);
+	return result;
+}
+async function replyLineMessages(replyToken, messages, opts) {
+	const { account, token } = resolveLineMessagingAccount(opts);
+	return {
+		...resolveLineProviderMessageIds(await sendLineProviderMessages("reply", token, {
+			replyToken,
+			messages: messages.map(normalizeLineMessageActions)
+		}), "reply"),
+		accountId: account.accountId
+	};
+}
+async function sendMessageLine(to, text, opts) {
+	const chatId = normalizeTarget(to);
+	const messages = [];
+	const mediaUrl = opts.mediaUrl?.trim();
+	if (mediaUrl) {
+		await validateLineMediaUrl(mediaUrl);
+		switch (opts.mediaKind) {
+			case "video": {
+				const previewImageUrl = opts.previewImageUrl?.trim();
+				if (!previewImageUrl) throw new Error("LINE video messages require previewImageUrl to reference an image URL");
+				await validateLineMediaUrl(previewImageUrl);
+				const trackingId = isLineUserChatId(chatId) ? opts.trackingId : void 0;
+				messages.push(createVideoMessage(mediaUrl, previewImageUrl, trackingId));
+				break;
+			}
+			case "audio":
+				messages.push(createAudioMessage(mediaUrl, opts.durationMs ?? 6e4));
+				break;
+			default:
+				{
+					const previewImageUrl = opts.previewImageUrl?.trim() || mediaUrl;
+					await validateLineMediaUrl(previewImageUrl);
+					messages.push(createImageMessage(mediaUrl, previewImageUrl));
+				}
+				break;
+		}
+	}
+	if (text?.trim()) messages.push(createTextMessage(text.trim()));
+	if (messages.length === 0) throw new Error("Message must be non-empty for LINE sends");
+	if (opts.replyToken) {
+		const { messageId, messageIds, accountId } = await replyLineMessages(opts.replyToken, messages, opts);
+		const result = {
+			messageId,
+			chatId,
+			receipt: createLineSendReceipt({
+				messageId,
+				messageIds,
+				chatId,
+				kind: resolveLineReceiptKind(messages),
+				messageCount: messages.length
+			})
+		};
+		recordLineOutboundActivity(accountId, {
+			messageIds,
+			receipt: result.receipt
+		});
+		if (opts.verbose) logVerbose(`line: replied to ${chatId}`);
+		return result;
+	}
+	return pushLineMessages(chatId, messages, opts, { verboseMessage: (resolvedChatId) => `line: pushed message to ${resolvedChatId}` });
+}
+async function pushMessageLine(to, text, opts) {
+	return sendMessageLine(to, text, {
+		...opts,
+		replyToken: void 0
+	});
+}
+async function replyMessageLine(replyToken, messages, opts) {
+	const { messageIds, accountId } = await replyLineMessages(replyToken, messages, opts);
+	recordLineOutboundActivity(accountId, { messageIds });
+	if (opts.verbose) logVerbose(`line: replied with ${messages.length} messages`);
+}
+async function pushMessagesLine(to, messages, opts) {
+	return pushLineMessages(to, messages, opts, { errorContext: "push message" });
+}
+function createFlexMessage(altText, contents) {
+	return {
+		type: "flex",
+		altText: truncateUtf16Safe(altText, LINE_FLEX_ALT_TEXT_LIMIT),
+		contents
+	};
+}
+async function pushImageMessage(to, originalContentUrl, previewImageUrl, opts) {
+	await validateLineMediaUrl(originalContentUrl);
+	if (previewImageUrl) await validateLineMediaUrl(previewImageUrl);
+	return pushLineMessages(to, [createImageMessage(originalContentUrl, previewImageUrl)], opts, { verboseMessage: (chatId) => `line: pushed image to ${chatId}` });
+}
+async function pushLocationMessage(to, location, opts) {
+	return pushLineMessages(to, [createLocationMessage(location)], opts, { verboseMessage: (chatId) => `line: pushed location to ${chatId}` });
+}
+async function pushFlexMessage(to, altText, contents, opts) {
+	return pushLineMessages(to, [createFlexMessage(altText, contents)], opts, {
+		errorContext: "push flex message",
+		verboseMessage: (chatId) => `line: pushed flex message to ${chatId}`
+	});
+}
+async function pushTemplateMessage(to, template, opts) {
+	return pushLineMessages(to, [template], opts, { verboseMessage: (chatId) => `line: pushed template message to ${chatId}` });
+}
+async function pushTextMessageWithQuickReplies(to, text, quickReplyLabels, opts) {
+	return pushLineMessages(to, [createTextMessageWithQuickReplies(text, quickReplyLabels)], opts, { verboseMessage: (chatId) => `line: pushed message with quick replies to ${chatId}` });
+}
+function createQuickReplyItems(labels) {
+	return { items: labels.slice(0, 13).map((label) => ({
+		type: "action",
+		action: messageAction(label, label)
+	})) };
+}
+function createTextMessageWithQuickReplies(text, quickReplyLabels) {
+	return {
+		type: "text",
+		text,
+		quickReply: createQuickReplyItems(quickReplyLabels)
+	};
+}
+async function showLoadingAnimation(chatId, opts) {
+	const { client } = createLineMessagingClient(opts);
+	try {
+		await client.showLoadingAnimation({
+			chatId: normalizeTarget(chatId),
+			loadingSeconds: opts.loadingSeconds ?? 20
+		});
+		logVerbose(`line: showing loading animation to ${chatId}`);
+	} catch (err) {
+		logVerbose(`line: loading animation failed (non-fatal): ${String(err)}`);
+	}
+}
+async function getUserProfile(userId, opts) {
+	if (opts.useCache ?? true) {
+		const cached = userProfileCache.get(userId);
+		if (cached && Date.now() - cached.fetchedAt < PROFILE_CACHE_TTL_MS) return {
+			displayName: cached.displayName,
+			pictureUrl: cached.pictureUrl
+		};
+	}
+	const { client } = createLineMessagingClient(opts);
+	try {
+		const profile = await client.getProfile(userId);
+		const result = {
+			displayName: profile.displayName,
+			pictureUrl: profile.pictureUrl
+		};
+		cacheUserProfile(userId, {
+			...result,
+			fetchedAt: Date.now()
+		});
+		return result;
+	} catch (err) {
+		logVerbose(`line: failed to fetch profile for ${userId}: ${String(err)}`);
+		return null;
+	}
+}
+async function getUserDisplayName(userId, opts) {
+	return (await getUserProfile(userId, opts))?.displayName ?? userId;
+}
+//#endregion
+export { replyMessageLine as _, createQuickReplyItems as a, resolveLineChannelAccessToken as b, getUserDisplayName as c, pushImageMessage as d, pushLocationMessage as f, pushTextMessageWithQuickReplies as g, pushTemplateMessage as h, createLocationMessage as i, getUserProfile as l, pushMessagesLine as m, createFlexMessage as n, createTextMessageWithQuickReplies as o, pushMessageLine as p, createImageMessage as r, createVideoMessage as s, createAudioMessage as t, pushFlexMessage as u, sendMessageLine as v, showLoadingAnimation as y };

package/dist/{flex-templates-iKJsyCq-.js → send-receipt-DKZzgHMO.js}

@@ -1,5 +1,94 @@
+import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { createMessageReceiptFromOutboundResults } from "openclaw/plugin-sdk/channel-outbound";
+import { resolvePinnedHostnameWithPolicy } from "openclaw/plugin-sdk/ssrf-runtime";
+import { isRecord as isRecord$1 } from "openclaw/plugin-sdk/channel-secret-basic-runtime";
 import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
-import { isRecord } from "openclaw/plugin-sdk/channel-secret-basic-runtime";
+//#region extensions/line/src/outbound-media.ts
+const LINE_OUTBOUND_MEDIA_SSRF_POLICY = { allowPrivateNetwork: false };
+async function validateLineMediaUrl(url) {
+	let parsed;
+	try {
+		parsed = new URL(url);
+	} catch {
+		throw new Error("LINE outbound media URL must be a valid URL");
+	}
+	if (parsed.protocol !== "https:") throw new Error("LINE outbound media URL must use HTTPS");
+	if (url.length > 2e3) throw new Error(`LINE outbound media URL must be 2000 chars or less (got ${url.length})`);
+	await resolvePinnedHostnameWithPolicy(parsed.hostname, { policy: LINE_OUTBOUND_MEDIA_SSRF_POLICY });
+}
+function isHttpsUrl(url) {
+	try {
+		return new URL(url).protocol === "https:";
+	} catch {
+		return false;
+	}
+}
+function detectLineMediaKindFromUrl(url) {
+	try {
+		const pathname = normalizeLowercaseStringOrEmpty(new URL(url).pathname);
+		if (/\.(png|jpe?g|gif|webp|bmp|heic|heif|avif)$/i.test(pathname)) return "image";
+		if (/\.(mp4|mov|m4v|webm)$/i.test(pathname)) return "video";
+		if (/\.(mp3|m4a|aac|wav|ogg|oga)$/i.test(pathname)) return "audio";
+	} catch {
+		return;
+	}
+}
+async function resolveLineOutboundMedia(mediaUrl, opts = {}) {
+	const trimmedUrl = mediaUrl.trim();
+	if (isHttpsUrl(trimmedUrl)) {
+		await validateLineMediaUrl(trimmedUrl);
+		const previewImageUrl = opts.previewImageUrl?.trim();
+		if (previewImageUrl) await validateLineMediaUrl(previewImageUrl);
+		return {
+			mediaUrl: trimmedUrl,
+			mediaKind: opts.mediaKind ?? (typeof opts.durationMs === "number" ? "audio" : void 0) ?? (opts.trackingId?.trim() ? "video" : void 0) ?? detectLineMediaKindFromUrl(trimmedUrl) ?? "image",
+			...previewImageUrl ? { previewImageUrl } : {},
+			...typeof opts.durationMs === "number" ? { durationMs: opts.durationMs } : {},
+			...opts.trackingId ? { trackingId: opts.trackingId } : {}
+		};
+	}
+	let parsed;
+	try {
+		parsed = new URL(trimmedUrl);
+	} catch {}
+	if (parsed) throw new Error("LINE outbound media URL must use HTTPS");
+	throw new Error("LINE outbound media currently requires a public HTTPS URL");
+}
+function isLineUserTarget(target) {
+	const normalized = target.trim().replace(/^line:(group|room|user):/i, "").replace(/^line:/i, "");
+	return /^U/i.test(normalized);
+}
+function hasLineSpecificMediaOptions(lineData) {
+	return lineData.mediaKind !== void 0 || Boolean(lineData.previewImageUrl?.trim()) || typeof lineData.durationMs === "number" || Boolean(lineData.trackingId?.trim());
+}
+function buildLineMediaMessageObject(resolved, opts) {
+	switch (resolved.mediaKind) {
+		case "video": {
+			const previewImageUrl = resolved.previewImageUrl?.trim();
+			if (!previewImageUrl) throw new Error("LINE video messages require previewImageUrl to reference an image URL");
+			return {
+				type: "video",
+				originalContentUrl: resolved.mediaUrl,
+				previewImageUrl,
+				...opts?.allowTrackingId && resolved.trackingId ? { trackingId: resolved.trackingId } : {}
+			};
+		}
+		case "audio": return {
+			type: "audio",
+			originalContentUrl: resolved.mediaUrl,
+			duration: resolved.durationMs ?? 6e4
+		};
+		default: return {
+			type: "image",
+			originalContentUrl: resolved.mediaUrl,
+			previewImageUrl: resolved.previewImageUrl ?? resolved.mediaUrl
+		};
+	}
+}
+async function buildLineMediaMessage(mediaUrl, opts, target) {
+	return buildLineMediaMessageObject(await resolveLineOutboundMedia(mediaUrl, opts), { allowTrackingId: isLineUserTarget(target) });
+}
+//#endregion
 //#region extensions/line/src/actions.ts
 const LINE_ACTION_LABEL_LIMIT = 20;
 const LINE_ACTION_DATA_LIMIT = 300;
@@ -50,7 +139,7 @@ const actionTypes = /* @__PURE__ */ new Set([
 	"uri"
 ]);
 function isLineAction(value) {
-	return isRecord(value) && typeof value.type === "string" && actionTypes.has(value.type);
+	return isRecord$1(value) && typeof value.type === "string" && actionTypes.has(value.type);
 }
 function isUnavailableAction(action) {
 	return action[unavailableActionMarker] === true;
@@ -61,7 +150,7 @@ function normalizeNestedActions(value, labelLimit, warnings) {
 		for (const item of value) normalized.push(normalizeNestedActions(item, labelLimit, warnings));
 		return normalized;
 	}
-	if (!isRecord(value)) return value;
+	if (!isRecord$1(value)) return value;
 	const normalized = { ...value };
 	for (const [key, nested] of Object.entries(value)) if ((key === "action" || key === "defaultAction") && isLineAction(nested)) {
 		const action = normalizeLineAction(nested, labelLimit);
@@ -74,10 +163,10 @@ function normalizeNestedActions(value, labelLimit, warnings) {
 	return normalized;
 }
 function normalizeFlexBubbleActions(value) {
-	if (!isRecord(value) || value.type !== "bubble") return normalizeNestedActions(value, 40);
+	if (!isRecord$1(value) || value.type !== "bubble") return normalizeNestedActions(value, 40);
 	const warnings = [];
 	const normalized = normalizeNestedActions(value, 40, warnings);
-	if (!isRecord(normalized) || warnings.length === 0) return normalized;
+	if (!isRecord$1(normalized) || warnings.length === 0) return normalized;
 	const warning = {
 		type: "text",
 		text: [...new Set(warnings)].join("\n"),
@@ -87,7 +176,7 @@ function normalizeFlexBubbleActions(value) {
 		margin: "md"
 	};
 	const body = normalized.body;
-	if (isRecord(body) && Array.isArray(body.contents)) normalized.body = {
+	if (isRecord$1(body) && Array.isArray(body.contents)) normalized.body = {
 		...body,
 		contents: [...body.contents, warning]
 	};
@@ -99,7 +188,7 @@ function normalizeFlexBubbleActions(value) {
 	return normalized;
 }
 function normalizeFlexContainerActions(value) {
-	if (!isRecord(value)) return value;
+	if (!isRecord$1(value)) return value;
 	if (value.type === "bubble") return normalizeFlexBubbleActions(value);
 	if (value.type === "carousel" && Array.isArray(value.contents)) return {
 		...value,
@@ -546,85 +635,6 @@ function createActionCard(title, body, actions, options) {
 	};
 	return bubble;
 }
-/**
-* Create a carousel container from multiple bubbles
-* LINE allows max 12 bubbles in a carousel
-*/
-function createCarousel(bubbles) {
-	return {
-		type: "carousel",
-		contents: bubbles.slice(0, 12)
-	};
-}
-/**
-* Create a notification bubble (for alerts, status updates)
-*
-* Editorial design: Bold status indicator with accent color,
-* clear typography, optional icon for context.
-*/
-function createNotificationBubble(text, options) {
-	const typeColors = {
-		info: {
-			accent: "#3B82F6",
-			bg: "#EFF6FF"
-		},
-		success: {
-			accent: "#06C755",
-			bg: "#F0FDF4"
-		},
-		warning: {
-			accent: "#F59E0B",
-			bg: "#FFFBEB"
-		},
-		error: {
-			accent: "#EF4444",
-			bg: "#FEF2F2"
-		}
-	}[options?.type ?? "info"];
-	const contents = [];
-	contents.push({
-		type: "box",
-		layout: "vertical",
-		contents: [],
-		width: "4px",
-		backgroundColor: typeColors.accent,
-		cornerRadius: "2px"
-	});
-	const textContents = [];
-	if (options?.title) textContents.push({
-		type: "text",
-		text: options.title,
-		size: "md",
-		weight: "bold",
-		color: "#111111",
-		wrap: true
-	});
-	textContents.push({
-		type: "text",
-		text,
-		size: options?.title ? "sm" : "md",
-		color: options?.title ? "#666666" : "#333333",
-		wrap: true,
-		margin: options?.title ? "sm" : void 0
-	});
-	contents.push({
-		type: "box",
-		layout: "vertical",
-		contents: textContents,
-		flex: 1,
-		paddingStart: "lg"
-	});
-	return {
-		type: "bubble",
-		body: {
-			type: "box",
-			layout: "horizontal",
-			contents,
-			paddingAll: "xl",
-			backgroundColor: typeColors.bg
-		}
-	};
-}
 //#endregion
 //#region extensions/line/src/flex-templates/schedule-cards.ts
 function buildTitleSubtitleHeader(params) {
@@ -1336,4 +1346,21 @@ function createDeviceControlCard(params) {
 	return bubble;
 }
 //#endregion
-export { postbackAction as _, createEventCard as a, createCarousel as c, createListCard as d, createNotificationBubble as f, normalizeLineMessageActions as g, normalizeLineAction as h, createAgendaCard as i, createImageCard as l, messageAction as m, createDeviceControlCard as n, createReceiptCard as o, datetimePickerAction as p, createMediaPlayerCard as r, createActionCard as s, createAppleTvRemoteCard as t, createInfoCard as u, uriAction as v };
+//#region extensions/line/src/send-receipt.ts
+function createLineSendReceipt(params) {
+	const messageIds = (params.messageIds ?? [params.messageId]).map((messageId) => messageId.trim()).filter(Boolean);
+	const chatId = params.chatId.trim();
+	return createMessageReceiptFromOutboundResults({
+		results: messageIds.map((messageId) => ({
+			channel: "line",
+			messageId,
+			chatId,
+			conversationId: chatId,
+			meta: { messageCount: params.messageCount ?? 1 }
+		})),
+		...chatId ? { threadId: chatId } : {},
+		kind: params.kind ?? "unknown"
+	});
+}
+//#endregion
+export { uriAction as _, createAgendaCard as a, resolveLineOutboundMedia as b, createActionCard as c, createListCard as d, datetimePickerAction as f, postbackAction as g, normalizeLineMessageActions as h, createMediaPlayerCard as i, createImageCard as l, normalizeLineAction as m, createAppleTvRemoteCard as n, createEventCard as o, messageAction as p, createDeviceControlCard as r, createReceiptCard as s, createLineSendReceipt as t, createInfoCard as u, buildLineMediaMessage as v, validateLineMediaUrl as x, hasLineSpecificMediaOptions as y };

package/dist/setup-api.js

@@ -1,2 +1,2 @@
-import { n as lineSetupAdapter, t as lineSetupWizard } from "./setup-surface-DRQ7n0En.js";
+import { n as lineSetupAdapter, t as lineSetupWizard } from "./setup-surface-W0Dbgu58.js";
 export { lineSetupAdapter, lineSetupWizard };

package/dist/{setup-surface-DRQ7n0En.js → setup-surface-W0Dbgu58.js}

@@ -126,7 +126,8 @@ const lineSetupContract = defineChannelSetupContract({
 			cli: {
 				flags: "--use-env",
 				description: "Use LINE environment credentials"
-			}
+			},
+			envVars: ["LINE_CHANNEL_ACCESS_TOKEN", "LINE_CHANNEL_SECRET"]
 		}
 	},
 	legacyAdapter: lineSetupAdapter

package/node_modules/typebox/build/compile/code.d.mts

@@ -0,0 +1,12 @@
+import { type TProperties, type TSchema } from '../type/index.mjs';
+import { type TExternal } from '../schema/index.mjs';
+export interface CodeResult {
+    /** External Variables  */
+    External: TExternal;
+    /** Generated Esm module. */
+    Code: string;
+}
+/** Creates a standalone ESM validation module for the given type. */
+export declare function Code<Type extends TSchema>(type: Type): CodeResult;
+/** Creates a standalone ESM validation module for the given type. */
+export declare function Code<Context extends TProperties, Type extends TSchema>(context: Context, type: Type): CodeResult;