@kodelyth/zalouser 2026.5.39 → 2026.6.1

package/dist/runtime-api.js

@@ -0,0 +1,19 @@
+import { n as zalouserSetupWizard } from "./setup-surface-Cfj4GQlB.js";
+import { n as createZalouserSetupWizardProxy, r as zalouserSetupAdapter } from "./shared-DjK0e2FC.js";
+import { r as setZalouserRuntime, t as zalouserPlugin } from "./channel-pby_3Sur.js";
+import { n as isZalouserMutableGroupEntry, t as collectZalouserSecurityAuditFindings } from "./security-audit-D_rftvs-.js";
+import { t as zalouserSetupPlugin } from "./channel.setup-CqyWwqcQ.js";
+import { t as createZalouserTool } from "./api-DSWT4Dh_.js";
+import { buildBaseAccountStatusSnapshot } from "klaw/plugin-sdk/status-helpers";
+import { formatAllowFromLowercase, mergeAllowlist, summarizeMapping } from "klaw/plugin-sdk/allow-from";
+import { DEFAULT_ACCOUNT_ID, buildChannelConfigSchema, normalizeAccountId } from "klaw/plugin-sdk/core";
+import { isDangerousNameMatchingEnabled } from "klaw/plugin-sdk/dangerous-name-runtime";
+import { chunkTextForOutbound } from "klaw/plugin-sdk/text-chunking";
+import { deliverTextOrMediaReply, isNumericTargetId, resolveSendableOutboundReplyParts, sendPayloadWithChunkedTextAndMedia } from "klaw/plugin-sdk/reply-payload";
+import { createChannelMessageReplyPipeline } from "klaw/plugin-sdk/channel-message";
+import { createChannelPairingController } from "klaw/plugin-sdk/channel-pairing";
+import { resolvePreferredKlawTmpDir } from "klaw/plugin-sdk/temp-path";
+import { loadOutboundMediaFromUrl } from "klaw/plugin-sdk/outbound-media";
+import { resolveDefaultGroupPolicy, resolveOpenProviderRuntimeGroupPolicy, warnMissingProviderGroupPolicyFallbackOnce } from "klaw/plugin-sdk/runtime-group-policy";
+import { resolveInboundMentionDecision } from "klaw/plugin-sdk/channel-inbound";
+export { DEFAULT_ACCOUNT_ID, buildBaseAccountStatusSnapshot, buildChannelConfigSchema, chunkTextForOutbound, collectZalouserSecurityAuditFindings, createChannelMessageReplyPipeline, createChannelPairingController, createZalouserSetupWizardProxy, createZalouserTool, deliverTextOrMediaReply, formatAllowFromLowercase, isDangerousNameMatchingEnabled, isNumericTargetId, isZalouserMutableGroupEntry, loadOutboundMediaFromUrl, mergeAllowlist, normalizeAccountId, resolveDefaultGroupPolicy, resolveInboundMentionDecision, resolveOpenProviderRuntimeGroupPolicy, resolvePreferredKlawTmpDir, resolveSendableOutboundReplyParts, sendPayloadWithChunkedTextAndMedia, setZalouserRuntime, summarizeMapping, warnMissingProviderGroupPolicyFallbackOnce, zalouserPlugin, zalouserSetupAdapter, zalouserSetupPlugin, zalouserSetupWizard };

package/dist/secret-contract-api.js

@@ -0,0 +1,5 @@
+//#region extensions/zalouser/secret-contract-api.ts
+const secretTargetRegistryEntries = [];
+function collectRuntimeConfigAssignments() {}
+//#endregion
+export { collectRuntimeConfigAssignments, secretTargetRegistryEntries };

package/dist/security-audit-D_rftvs-.js

@@ -0,0 +1,34 @@
+import { isDangerousNameMatchingEnabled } from "klaw/plugin-sdk/dangerous-name-runtime";
+//#region extensions/zalouser/src/security-audit.ts
+function isZalouserMutableGroupEntry(raw) {
+	const text = raw.trim();
+	if (!text || text === "*") return false;
+	const normalized = text.replace(/^(zalouser|zlu):/i, "").replace(/^group:/i, "").trim();
+	if (!normalized) return false;
+	if (/^\d+$/.test(normalized)) return false;
+	return !/^g-\S+$/i.test(normalized);
+}
+function collectZalouserSecurityAuditFindings(params) {
+	const zalouserCfg = params.account.config ?? {};
+	const accountId = params.accountId?.trim() || params.account.accountId || "default";
+	const dangerousNameMatchingEnabled = isDangerousNameMatchingEnabled(zalouserCfg);
+	const zalouserPathPrefix = params.orderedAccountIds.length > 1 || params.hasExplicitAccountPath ? `channels.zalouser.accounts.${accountId}` : "channels.zalouser";
+	const mutableGroupEntries = /* @__PURE__ */ new Set();
+	const groups = zalouserCfg.groups;
+	if (groups && typeof groups === "object" && !Array.isArray(groups)) for (const key of Object.keys(groups)) {
+		if (!isZalouserMutableGroupEntry(key)) continue;
+		mutableGroupEntries.add(`${zalouserPathPrefix}.groups:${key}`);
+	}
+	if (mutableGroupEntries.size === 0) return [];
+	const examples = Array.from(mutableGroupEntries).slice(0, 5);
+	const more = mutableGroupEntries.size > examples.length ? ` (+${mutableGroupEntries.size - examples.length} more)` : "";
+	return [{
+		checkId: "channels.zalouser.groups.mutable_entries",
+		severity: dangerousNameMatchingEnabled ? "info" : "warn",
+		title: dangerousNameMatchingEnabled ? "Zalouser group routing uses break-glass name matching" : "Zalouser group routing contains mutable group entries",
+		detail: dangerousNameMatchingEnabled ? `Zalouser group-name routing is explicitly enabled via dangerouslyAllowNameMatching. This mutable-identity mode is operator-selected break-glass behavior and out-of-scope for vulnerability reports by itself. Found: ${examples.join(", ")}${more}.` : `Zalouser group auth is ID-only by default, so unresolved group-name or slug entries are ignored for auth and can drift from the intended trusted group. Found: ${examples.join(", ")}${more}.`,
+		remediation: dangerousNameMatchingEnabled ? "Prefer stable Zalo group IDs (for example group:<id> or provider-native g- ids), then disable dangerouslyAllowNameMatching." : "Prefer stable Zalo group IDs in channels.zalouser.groups, or explicitly opt in with dangerouslyAllowNameMatching=true if you accept mutable group-name matching."
+	}];
+}
+//#endregion
+export { isZalouserMutableGroupEntry as n, collectZalouserSecurityAuditFindings as t };

package/dist/send-uRjUB8mG.js

@@ -0,0 +1,542 @@
+import { S as TextStyle, _ as sendZaloTypingEvent, f as sendZaloDeliveredEvent, g as sendZaloTextMessage, h as sendZaloSeenEvent, m as sendZaloReaction, p as sendZaloLink, x as createZalouserSendReceipt } from "./zalo-js-B80cRyDF.js";
+//#region extensions/zalouser/src/text-styles.ts
+const ESCAPE_SENTINEL_START = "
";
+const ESCAPE_SENTINEL_END = "";
+const TAG_STYLE_MAP = {
+	red: TextStyle.Red,
+	orange: TextStyle.Orange,
+	yellow: TextStyle.Yellow,
+	green: TextStyle.Green,
+	small: null,
+	big: TextStyle.Big,
+	underline: TextStyle.Underline
+};
+const INLINE_MARKERS = [
+	{
+		pattern: /`([^`\n]+)`/g,
+		extractText: (match) => match[0],
+		literal: true
+	},
+	{
+		pattern: /\\([*_~#\\{}>+\-`])/g,
+		extractText: (match) => match[1],
+		literal: true
+	},
+	{
+		pattern: new RegExp(`\\{(${Object.keys(TAG_STYLE_MAP).join("|")})\\}(.+?)\\{/\\1\\}`, "g"),
+		extractText: (match) => match[2],
+		resolveStyles: (match) => {
+			const style = TAG_STYLE_MAP[match[1]];
+			return style ? [style] : [];
+		}
+	},
+	{
+		pattern: /(?<!\*)\*\*\*(?=\S)([^\n]*?\S)(?<!\*)\*\*\*(?!\*)/g,
+		extractText: (match) => match[1],
+		resolveStyles: () => [TextStyle.Bold, TextStyle.Italic]
+	},
+	{
+		pattern: /(?<!\*)\*\*(?![\s*])([^\n]*?\S)(?<!\*)\*\*(?!\*)/g,
+		extractText: (match) => match[1],
+		resolveStyles: () => [TextStyle.Bold]
+	},
+	{
+		pattern: /(?<![\w_])__(?![\s_])([^\n]*?\S)(?<!_)__(?![\w_])/g,
+		extractText: (match) => match[1],
+		resolveStyles: () => [TextStyle.Bold]
+	},
+	{
+		pattern: /(?<!~)~~(?=\S)([^\n]*?\S)(?<!~)~~(?!~)/g,
+		extractText: (match) => match[1],
+		resolveStyles: () => [TextStyle.StrikeThrough]
+	},
+	{
+		pattern: /(?<!\*)\*(?![\s*])([^\n]*?\S)(?<!\*)\*(?!\*)/g,
+		extractText: (match) => match[1],
+		resolveStyles: () => [TextStyle.Italic]
+	},
+	{
+		pattern: /(?<![\w_])_(?![\s_])([^\n]*?\S)(?<!_)_(?![\w_])/g,
+		extractText: (match) => match[1],
+		resolveStyles: () => [TextStyle.Italic]
+	}
+];
+function parseZalouserTextStyles(input) {
+	const allStyles = [];
+	const escapeMap = [];
+	const lines = input.replace(/\r\n?/g, "\n").split("\n");
+	const lineStyles = [];
+	const processedLines = [];
+	let activeFence = null;
+	for (let lineIndex = 0; lineIndex < lines.length; lineIndex += 1) {
+		const rawLine = lines[lineIndex];
+		const { text: unquotedLine, indent: baseIndent } = stripQuotePrefix(rawLine);
+		if (activeFence) {
+			const codeLine = activeFence.quoteIndent > 0 ? stripQuotePrefix(rawLine, activeFence.quoteIndent).text : rawLine;
+			if (isClosingFence(codeLine, activeFence)) {
+				activeFence = null;
+				continue;
+			}
+			processedLines.push(escapeLiteralText(normalizeCodeBlockLeadingWhitespace(stripCodeFenceIndent(codeLine, activeFence.indent)), escapeMap));
+			continue;
+		}
+		let line = unquotedLine;
+		const openingFence = resolveOpeningFence(rawLine);
+		if (openingFence) {
+			const fenceLine = openingFence.quoteIndent > 0 ? unquotedLine : rawLine;
+			if (!hasClosingFence(lines, lineIndex + 1, openingFence)) {
+				processedLines.push(escapeLiteralText(fenceLine, escapeMap));
+				activeFence = openingFence;
+				continue;
+			}
+			activeFence = openingFence;
+			continue;
+		}
+		const outputLineIndex = processedLines.length;
+		if (isIndentedCodeBlockLine(line)) {
+			if (baseIndent > 0) lineStyles.push({
+				lineIndex: outputLineIndex,
+				style: TextStyle.Indent,
+				indentSize: baseIndent
+			});
+			processedLines.push(escapeLiteralText(normalizeCodeBlockLeadingWhitespace(line), escapeMap));
+			continue;
+		}
+		const { text: markdownLine, size: markdownPadding } = stripOptionalMarkdownPadding(line);
+		const headingMatch = markdownLine.match(/^(#{1,4})\s(.*)$/);
+		if (headingMatch) {
+			const depth = headingMatch[1].length;
+			lineStyles.push({
+				lineIndex: outputLineIndex,
+				style: TextStyle.Bold
+			});
+			if (depth === 1) lineStyles.push({
+				lineIndex: outputLineIndex,
+				style: TextStyle.Big
+			});
+			if (baseIndent > 0) lineStyles.push({
+				lineIndex: outputLineIndex,
+				style: TextStyle.Indent,
+				indentSize: baseIndent
+			});
+			processedLines.push(headingMatch[2]);
+			continue;
+		}
+		const indentMatch = markdownLine.match(/^(\s+)(.*)$/);
+		let indentLevel = 0;
+		let content = markdownLine;
+		if (indentMatch) {
+			indentLevel = clampIndent(indentMatch[1].length);
+			content = indentMatch[2];
+		}
+		const totalIndent = Math.min(5, baseIndent + indentLevel);
+		if (/^[-*+]\s\[[ xX]\]\s/.test(content)) {
+			if (totalIndent > 0) lineStyles.push({
+				lineIndex: outputLineIndex,
+				style: TextStyle.Indent,
+				indentSize: totalIndent
+			});
+			processedLines.push(content);
+			continue;
+		}
+		const orderedListMatch = content.match(/^(\d+)\.\s(.*)$/);
+		if (orderedListMatch) {
+			if (totalIndent > 0) lineStyles.push({
+				lineIndex: outputLineIndex,
+				style: TextStyle.Indent,
+				indentSize: totalIndent
+			});
+			lineStyles.push({
+				lineIndex: outputLineIndex,
+				style: TextStyle.OrderedList
+			});
+			processedLines.push(orderedListMatch[2]);
+			continue;
+		}
+		const unorderedListMatch = content.match(/^[-*+]\s(.*)$/);
+		if (unorderedListMatch) {
+			if (totalIndent > 0) lineStyles.push({
+				lineIndex: outputLineIndex,
+				style: TextStyle.Indent,
+				indentSize: totalIndent
+			});
+			lineStyles.push({
+				lineIndex: outputLineIndex,
+				style: TextStyle.UnorderedList
+			});
+			processedLines.push(unorderedListMatch[1]);
+			continue;
+		}
+		if (markdownPadding > 0) {
+			if (baseIndent > 0) lineStyles.push({
+				lineIndex: outputLineIndex,
+				style: TextStyle.Indent,
+				indentSize: baseIndent
+			});
+			processedLines.push(line);
+			continue;
+		}
+		if (totalIndent > 0) {
+			lineStyles.push({
+				lineIndex: outputLineIndex,
+				style: TextStyle.Indent,
+				indentSize: totalIndent
+			});
+			processedLines.push(content);
+			continue;
+		}
+		processedLines.push(line);
+	}
+	const segments = parseInlineSegments(processedLines.join("\n"));
+	let plainText = "";
+	for (const segment of segments) {
+		const start = plainText.length;
+		plainText += segment.text;
+		for (const style of segment.styles) allStyles.push({
+			start,
+			len: segment.text.length,
+			st: style
+		});
+	}
+	if (escapeMap.length > 0) {
+		const escapeRegex = new RegExp(`${ESCAPE_SENTINEL_START}(\\d+)${ESCAPE_SENTINEL_END}`, "g");
+		const shifts = [];
+		let cumulativeDelta = 0;
+		for (const match of plainText.matchAll(escapeRegex)) {
+			const escapeIndex = Number.parseInt(match[1], 10);
+			cumulativeDelta += match[0].length - escapeMap[escapeIndex].length;
+			shifts.push({
+				pos: (match.index ?? 0) + match[0].length,
+				delta: cumulativeDelta
+			});
+		}
+		for (const style of allStyles) {
+			let startDelta = 0;
+			let endDelta = 0;
+			const end = style.start + style.len;
+			for (const shift of shifts) {
+				if (shift.pos <= style.start) startDelta = shift.delta;
+				if (shift.pos <= end) endDelta = shift.delta;
+			}
+			style.start -= startDelta;
+			style.len -= endDelta - startDelta;
+		}
+		plainText = plainText.replace(escapeRegex, (_match, index) => escapeMap[Number.parseInt(index, 10)]);
+	}
+	const finalLines = plainText.split("\n");
+	let offset = 0;
+	for (let lineIndex = 0; lineIndex < finalLines.length; lineIndex += 1) {
+		const lineLength = finalLines[lineIndex].length;
+		if (lineLength > 0) for (const lineStyle of lineStyles) {
+			if (lineStyle.lineIndex !== lineIndex) continue;
+			if (lineStyle.style === TextStyle.Indent) allStyles.push({
+				start: offset,
+				len: lineLength,
+				st: TextStyle.Indent,
+				indentSize: lineStyle.indentSize
+			});
+			else allStyles.push({
+				start: offset,
+				len: lineLength,
+				st: lineStyle.style
+			});
+		}
+		offset += lineLength + 1;
+	}
+	return {
+		text: plainText,
+		styles: allStyles
+	};
+}
+function clampIndent(spaceCount) {
+	return Math.min(5, Math.max(1, Math.floor(spaceCount / 2)));
+}
+function stripOptionalMarkdownPadding(line) {
+	const match = line.match(/^( {1,3})(?=\S)/);
+	if (!match) return {
+		text: line,
+		size: 0
+	};
+	return {
+		text: line.slice(match[1].length),
+		size: match[1].length
+	};
+}
+function hasClosingFence(lines, startIndex, fence) {
+	for (let index = startIndex; index < lines.length; index += 1) if (isClosingFence(fence.quoteIndent > 0 ? stripQuotePrefix(lines[index], fence.quoteIndent).text : lines[index], fence)) return true;
+	return false;
+}
+function resolveOpeningFence(line) {
+	const directFence = parseFenceMarker(line);
+	if (directFence) return {
+		...directFence,
+		quoteIndent: 0
+	};
+	const quoted = stripQuotePrefix(line);
+	if (quoted.indent === 0) return null;
+	const quotedFence = parseFenceMarker(quoted.text);
+	if (!quotedFence) return null;
+	return {
+		...quotedFence,
+		quoteIndent: quoted.indent
+	};
+}
+function stripQuotePrefix(line, maxDepth = Number.POSITIVE_INFINITY) {
+	let cursor = 0;
+	while (cursor < line.length && cursor < 3 && line[cursor] === " ") cursor += 1;
+	let removedDepth = 0;
+	let consumedCursor = cursor;
+	while (removedDepth < maxDepth && consumedCursor < line.length && line[consumedCursor] === ">") {
+		removedDepth += 1;
+		consumedCursor += 1;
+		if (line[consumedCursor] === " ") consumedCursor += 1;
+	}
+	if (removedDepth === 0) return {
+		text: line,
+		indent: 0
+	};
+	return {
+		text: line.slice(consumedCursor),
+		indent: Math.min(5, removedDepth)
+	};
+}
+function parseFenceMarker(line) {
+	const match = line.match(/^([ ]{0,3})(`{3,}|~{3,})(.*)$/);
+	if (!match) return null;
+	const marker = match[2];
+	const char = marker[0];
+	if (char !== "`" && char !== "~") return null;
+	return {
+		char,
+		length: marker.length,
+		indent: match[1].length
+	};
+}
+function isClosingFence(line, fence) {
+	const match = line.match(/^([ ]{0,3})(`{3,}|~{3,})[ \t]*$/);
+	if (!match) return false;
+	return match[2][0] === fence.char && match[2].length >= fence.length;
+}
+function escapeLiteralText(input, escapeMap) {
+	return input.replace(/[\\*_~{}`]/g, (ch) => {
+		const index = escapeMap.length;
+		escapeMap.push(ch);
+		return `\x01${index}\x02`;
+	});
+}
+function parseInlineSegments(text, inheritedStyles = []) {
+	const segments = [];
+	let cursor = 0;
+	while (cursor < text.length) {
+		const nextMatch = findNextInlineMatch(text, cursor);
+		if (!nextMatch) {
+			pushSegment(segments, text.slice(cursor), inheritedStyles);
+			break;
+		}
+		if (nextMatch.match.index > cursor) pushSegment(segments, text.slice(cursor, nextMatch.match.index), inheritedStyles);
+		const combinedStyles = [...inheritedStyles, ...nextMatch.styles];
+		if (nextMatch.marker.literal) pushSegment(segments, nextMatch.text, combinedStyles);
+		else segments.push(...parseInlineSegments(nextMatch.text, combinedStyles));
+		cursor = nextMatch.match.index + nextMatch.match[0].length;
+	}
+	return segments;
+}
+function findNextInlineMatch(text, startIndex) {
+	let bestMatch = null;
+	for (const [priority, marker] of INLINE_MARKERS.entries()) {
+		const regex = new RegExp(marker.pattern.source, marker.pattern.flags);
+		regex.lastIndex = startIndex;
+		const match = regex.exec(text);
+		if (!match) continue;
+		if (bestMatch && (match.index > bestMatch.match.index || match.index === bestMatch.match.index && priority > bestMatch.priority)) continue;
+		bestMatch = {
+			match,
+			marker,
+			text: marker.extractText(match),
+			styles: marker.resolveStyles?.(match) ?? [],
+			priority
+		};
+	}
+	return bestMatch;
+}
+function pushSegment(segments, text, styles) {
+	if (!text) return;
+	const lastSegment = segments.at(-1);
+	if (lastSegment && sameStyles(lastSegment.styles, styles)) {
+		lastSegment.text += text;
+		return;
+	}
+	segments.push({
+		text,
+		styles: [...styles]
+	});
+}
+function sameStyles(left, right) {
+	return left.length === right.length && left.every((style, index) => style === right[index]);
+}
+function normalizeCodeBlockLeadingWhitespace(line) {
+	return line.replace(/^[ \t]+/, (leadingWhitespace) => leadingWhitespace.replace(/\t/g, "\xA0\xA0\xA0\xA0").replace(/ /g, "\xA0"));
+}
+function isIndentedCodeBlockLine(line) {
+	return /^(?: {4,}|\t)/.test(line);
+}
+function stripCodeFenceIndent(line, indent) {
+	let consumed = 0;
+	let cursor = 0;
+	while (cursor < line.length && consumed < indent && line[cursor] === " ") {
+		cursor += 1;
+		consumed += 1;
+	}
+	return line.slice(cursor);
+}
+//#endregion
+//#region extensions/zalouser/src/send.ts
+const ZALO_TEXT_LIMIT = 2e3;
+const DEFAULT_TEXT_CHUNK_MODE = "length";
+async function sendMessageZalouser(threadId, text, options = {}) {
+	const prepared = options.textMode === "markdown" ? parseZalouserTextStyles(text) : {
+		text,
+		styles: options.textStyles
+	};
+	const textChunkLimit = options.textChunkLimit ?? ZALO_TEXT_LIMIT;
+	const chunks = splitStyledText(prepared.text, (prepared.styles?.length ?? 0) > 0 ? prepared.styles : void 0, textChunkLimit, options.textChunkMode);
+	let lastResult = null;
+	for (const [index, chunk] of chunks.entries()) {
+		const chunkOptions = index === 0 ? {
+			...options,
+			textStyles: chunk.styles
+		} : {
+			...options,
+			caption: void 0,
+			mediaLocalRoots: void 0,
+			mediaUrl: void 0,
+			textStyles: chunk.styles
+		};
+		const result = await sendZaloTextMessage(threadId, chunk.text, chunkOptions);
+		if (!result.ok) return result;
+		lastResult = result;
+	}
+	return lastResult ?? {
+		ok: false,
+		error: "No message content provided",
+		receipt: createZalouserSendReceipt({
+			threadId,
+			kind: "text"
+		})
+	};
+}
+async function sendImageZalouser(threadId, imageUrl, options = {}) {
+	return await sendMessageZalouser(threadId, options.caption ?? "", {
+		...options,
+		caption: void 0,
+		mediaUrl: imageUrl
+	});
+}
+async function sendLinkZalouser(threadId, url, options = {}) {
+	return await sendZaloLink(threadId, url, options);
+}
+async function sendTypingZalouser(threadId, options = {}) {
+	await sendZaloTypingEvent(threadId, options);
+}
+async function sendReactionZalouser(params) {
+	const result = await sendZaloReaction({
+		profile: params.profile,
+		threadId: params.threadId,
+		isGroup: params.isGroup,
+		msgId: params.msgId,
+		cliMsgId: params.cliMsgId,
+		emoji: params.emoji,
+		remove: params.remove
+	});
+	return {
+		ok: result.ok,
+		error: result.error,
+		receipt: createZalouserSendReceipt({
+			threadId: params.threadId,
+			kind: "unknown"
+		})
+	};
+}
+async function sendDeliveredZalouser(params) {
+	await sendZaloDeliveredEvent(params);
+}
+async function sendSeenZalouser(params) {
+	await sendZaloSeenEvent(params);
+}
+function splitStyledText(text, styles, limit, mode) {
+	if (text.length === 0) return [{
+		text,
+		styles: void 0
+	}];
+	const chunks = [];
+	for (const range of splitTextRanges(text, limit, mode ?? DEFAULT_TEXT_CHUNK_MODE)) {
+		const { start, end } = range;
+		chunks.push({
+			text: text.slice(start, end),
+			styles: sliceTextStyles(styles, start, end)
+		});
+	}
+	return chunks;
+}
+function sliceTextStyles(styles, start, end) {
+	if (!styles || styles.length === 0) return;
+	const chunkStyles = styles.map((style) => {
+		const overlapStart = Math.max(style.start, start);
+		const overlapEnd = Math.min(style.start + style.len, end);
+		if (overlapEnd <= overlapStart) return null;
+		if (style.st === TextStyle.Indent) return {
+			start: overlapStart - start,
+			len: overlapEnd - overlapStart,
+			st: style.st,
+			indentSize: style.indentSize
+		};
+		return {
+			start: overlapStart - start,
+			len: overlapEnd - overlapStart,
+			st: style.st
+		};
+	}).filter((style) => style !== null);
+	return chunkStyles.length > 0 ? chunkStyles : void 0;
+}
+function splitTextRanges(text, limit, mode) {
+	if (mode === "newline") return splitTextRangesByPreferredBreaks(text, limit);
+	const ranges = [];
+	for (let start = 0; start < text.length; start += limit) ranges.push({
+		start,
+		end: Math.min(text.length, start + limit)
+	});
+	return ranges;
+}
+function splitTextRangesByPreferredBreaks(text, limit) {
+	const ranges = [];
+	let start = 0;
+	while (start < text.length) {
+		const maxEnd = Math.min(text.length, start + limit);
+		let end = maxEnd;
+		if (maxEnd < text.length) end = findParagraphBreak(text, start, maxEnd) ?? findLastBreak(text, "\n", start, maxEnd) ?? findLastWhitespaceBreak(text, start, maxEnd) ?? maxEnd;
+		if (end <= start) end = maxEnd;
+		ranges.push({
+			start,
+			end
+		});
+		start = end;
+	}
+	return ranges;
+}
+function findParagraphBreak(text, start, end) {
+	const matches = text.slice(start, end).matchAll(/\n[\t ]*\n+/g);
+	let lastMatch;
+	for (const match of matches) lastMatch = match;
+	if (!lastMatch || lastMatch.index === void 0) return;
+	return start + lastMatch.index + lastMatch[0].length;
+}
+function findLastBreak(text, marker, start, end) {
+	const index = text.lastIndexOf(marker, end - 1);
+	if (index < start) return;
+	return index + marker.length;
+}
+function findLastWhitespaceBreak(text, start, end) {
+	for (let index = end - 1; index > start; index -= 1) if (/\s/.test(text[index])) return index + 1;
+}
+//#endregion
+export { sendReactionZalouser as a, sendMessageZalouser as i, sendImageZalouser as n, sendSeenZalouser as o, sendLinkZalouser as r, sendTypingZalouser as s, sendDeliveredZalouser as t };

package/dist/session-route-CalHiv1d.js

@@ -0,0 +1,92 @@
+import { normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString } from "klaw/plugin-sdk/string-coerce-runtime";
+import { buildChannelOutboundSessionRoute } from "klaw/plugin-sdk/core";
+//#region extensions/zalouser/src/session-route.ts
+function stripZalouserTargetPrefix(raw) {
+	return raw.trim().replace(/^(zalouser|zlu):/i, "").trim();
+}
+function normalizeZalouserTarget(raw) {
+	const trimmed = stripZalouserTargetPrefix(raw);
+	if (!trimmed) return;
+	const lower = normalizeLowercaseStringOrEmpty(trimmed);
+	if (lower.startsWith("group:")) {
+		const id = trimmed.slice(6).trim();
+		return id ? `group:${id}` : void 0;
+	}
+	if (lower.startsWith("g:")) {
+		const id = trimmed.slice(2).trim();
+		return id ? `group:${id}` : void 0;
+	}
+	if (lower.startsWith("user:")) {
+		const id = trimmed.slice(5).trim();
+		return id ? `user:${id}` : void 0;
+	}
+	if (lower.startsWith("dm:")) {
+		const id = trimmed.slice(3).trim();
+		return id ? `user:${id}` : void 0;
+	}
+	if (lower.startsWith("u:")) {
+		const id = trimmed.slice(2).trim();
+		return id ? `user:${id}` : void 0;
+	}
+	if (/^g-\S+$/i.test(trimmed)) return `group:${trimmed}`;
+	if (/^u-\S+$/i.test(trimmed)) return `user:${trimmed}`;
+	return trimmed;
+}
+function parseZalouserOutboundTarget(raw) {
+	const normalized = normalizeZalouserTarget(raw);
+	if (!normalized) throw new Error("Zalouser target is required");
+	const lowered = normalizeLowercaseStringOrEmpty(normalized);
+	if (lowered.startsWith("group:")) {
+		const threadId = normalized.slice(6).trim();
+		if (!threadId) throw new Error("Zalouser group target is missing group id");
+		return {
+			threadId,
+			isGroup: true
+		};
+	}
+	if (lowered.startsWith("user:")) {
+		const threadId = normalized.slice(5).trim();
+		if (!threadId) throw new Error("Zalouser user target is missing user id");
+		return {
+			threadId,
+			isGroup: false
+		};
+	}
+	return {
+		threadId: normalized,
+		isGroup: false
+	};
+}
+function parseZalouserDirectoryGroupId(raw) {
+	const normalized = normalizeZalouserTarget(raw);
+	if (!normalized) throw new Error("Zalouser group target is required");
+	const lowered = normalizeLowercaseStringOrEmpty(normalized);
+	if (lowered.startsWith("group:")) {
+		const groupId = normalized.slice(6).trim();
+		if (!groupId) throw new Error("Zalouser group target is missing group id");
+		return groupId;
+	}
+	if (lowered.startsWith("user:")) throw new Error("Zalouser group members lookup requires a group target (group:<id>)");
+	return normalized;
+}
+function resolveZalouserOutboundSessionRoute(params) {
+	const normalized = normalizeZalouserTarget(params.target);
+	if (!normalized) return null;
+	const isGroup = (normalizeOptionalLowercaseString(normalized) ?? "").startsWith("group:");
+	const peerId = normalized.replace(/^(group|user):/i, "").trim();
+	return buildChannelOutboundSessionRoute({
+		cfg: params.cfg,
+		agentId: params.agentId,
+		channel: "zalouser",
+		accountId: params.accountId,
+		peer: {
+			kind: isGroup ? "group" : "direct",
+			id: peerId
+		},
+		chatType: isGroup ? "group" : "direct",
+		from: isGroup ? `zalouser:group:${peerId}` : `zalouser:${peerId}`,
+		to: `zalouser:${peerId}`
+	});
+}
+//#endregion
+export { resolveZalouserOutboundSessionRoute as i, parseZalouserDirectoryGroupId as n, parseZalouserOutboundTarget as r, normalizeZalouserTarget as t };