@openclaw/signal 2026.7.1-beta.1 → 2026.7.1-beta.4

package/dist/{channel-aQhurb0Z.js → channel-Cnhy1RwG.js}

@@ -1,14 +1,16 @@
-import { i as resolveSignalAccount, n as listSignalAccountIds, r as resolveDefaultSignalAccountId } from "./accounts-hOCHbEhX.js";
-import { c as resolveSignalSender, d as normalizeSignalMessagingTarget, l as looksLikeUuid, o as resolveSignalPeerId, s as resolveSignalRecipient, u as looksLikeSignalTargetId } from "./identity-B6O4k8xg.js";
-import { i as markdownToSignalTextChunks, n as resolveSignalReactionLevel, o as shouldSuppressLocalSignalExecApprovalPrompt, s as signalApprovalCapability, t as signalMessageActions } from "./message-actions-BnugYXjB.js";
+import { a as resolveSignalReplyToMode, i as resolveSignalAccount, n as listSignalAccountIds, r as resolveDefaultSignalAccountId } from "./accounts-Bz4HtP0g.js";
+import { c as resolveSignalSender, d as normalizeSignalMessagingTarget, l as looksLikeUuid, o as resolveSignalPeerId, s as resolveSignalRecipient, u as looksLikeSignalTargetId } from "./identity-C8-yk4J9.js";
+import { i as resolveSignalTarget, r as listSignalAliasDirectoryEntries } from "./approval-auth-CsHNcAiy.js";
+import { i as markdownToSignalTextChunks, n as resolveSignalReactionLevel, o as shouldSuppressLocalSignalExecApprovalPrompt, s as signalApprovalCapability, t as signalMessageActions } from "./message-actions-3OLDgjis.js";
 import { t as SignalChannelConfigSchema } from "./config-schema-BiojLEsX.js";
 import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/account-id";
 import { buildDmGroupAccountAllowlistAdapter } from "openclaw/plugin-sdk/allowlist-config-edit";
 import { createChatChannelPlugin } from "openclaw/plugin-sdk/channel-core";
 import { defineChannelMessageAdapter, resolveOutboundSendDep } from "openclaw/plugin-sdk/channel-outbound";
 import { createPairingPrefixStripper } from "openclaw/plugin-sdk/channel-pairing";
-import { attachChannelToResult, attachChannelToResults } from "openclaw/plugin-sdk/channel-send-result";
+import { attachChannelToResult } from "openclaw/plugin-sdk/channel-send-result";
 import { PAIRING_APPROVED_MESSAGE } from "openclaw/plugin-sdk/channel-status";
+import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 import { resolveMarkdownTableMode } from "openclaw/plugin-sdk/markdown-table-runtime";
 import { resolveChannelMediaMaxBytes } from "openclaw/plugin-sdk/media-runtime";
 import { chunkText, resolveTextChunkLimit } from "openclaw/plugin-sdk/reply-chunking";
@@ -72,7 +74,10 @@ const INVALID_SIGNAL_ACCOUNT_ERROR = "Invalid E.164 phone number (must start wit
 function normalizeSignalAccountInput(value) {
 	const trimmed = normalizeOptionalString(value);
 	if (!trimmed) return null;
-	const digits = normalizeE164(trimmed).slice(1);
+	const phoneInput = trimmed.replace(/^signal:/i, "").trim();
+	const plusCount = phoneInput.match(/\+/g)?.length ?? 0;
+	if (plusCount > 1 || plusCount === 1 && !phoneInput.startsWith("+")) return null;
+	const digits = normalizeE164(phoneInput).slice(1);
 	if (!DIGITS_ONLY.test(digits)) return null;
 	if (digits.length < MIN_E164_DIGITS || digits.length > MAX_E164_DIGITS) return null;
 	return `+${digits}`;
@@ -235,27 +240,45 @@ function createSignalSetupWizardProxy(loadWizard) {
 //#region extensions/signal/src/shared.ts
 const SIGNAL_CHANNEL = "signal";
 async function loadSignalChannelRuntime() {
-	return await import("./channel.runtime-C5skg4Q0.js");
+	return await import("./channel.runtime-CQN0RaFx.js");
 }
 const signalSetupWizard = createSignalSetupWizardProxy(async () => (await loadSignalChannelRuntime()).signalSetupWizard);
-const signalConfigAdapter = createScopedChannelConfigAdapter({
-	sectionKey: SIGNAL_CHANNEL,
-	listAccountIds: (cfg) => listSignalAccountIds(cfg),
-	resolveAccount: adaptScopedAccountAccessor((params) => resolveSignalAccount(params)),
-	defaultAccountId: (cfg) => resolveDefaultSignalAccountId(cfg),
-	clearBaseFields: [
-		"account",
-		"configPath",
-		"httpUrl",
-		"httpHost",
-		"httpPort",
-		"cliPath",
-		"name"
-	],
-	resolveAllowFrom: (account) => account.config.allowFrom,
-	formatAllowFrom: (allowFrom) => normalizeStringifiedEntries(allowFrom).map((entry) => entry === "*" ? "*" : normalizeE164(entry.replace(/^signal:/i, ""))).filter(Boolean),
-	resolveDefaultTo: (account) => account.config.defaultTo
-});
+const signalConfigAdapter = {
+	...createScopedChannelConfigAdapter({
+		sectionKey: SIGNAL_CHANNEL,
+		listAccountIds: (cfg) => listSignalAccountIds(cfg),
+		resolveAccount: adaptScopedAccountAccessor((params) => resolveSignalAccount(params)),
+		defaultAccountId: (cfg) => resolveDefaultSignalAccountId(cfg),
+		clearBaseFields: [
+			"account",
+			"configPath",
+			"httpUrl",
+			"httpHost",
+			"httpPort",
+			"cliPath",
+			"name"
+		],
+		resolveAllowFrom: (account) => account.config.allowFrom,
+		formatAllowFrom: (allowFrom) => normalizeStringifiedEntries(allowFrom).map((entry) => entry === "*" ? "*" : normalizeE164(entry.replace(/^signal:/i, ""))).filter(Boolean),
+		resolveDefaultTo: (account) => account.config.defaultTo
+	}),
+	resolveDefaultTo({ cfg, accountId }) {
+		const raw = resolveSignalAccount({
+			cfg,
+			accountId
+		}).config.defaultTo;
+		if (typeof raw !== "string" || !raw.trim()) return;
+		try {
+			return resolveSignalTarget({
+				cfg,
+				accountId,
+				input: raw
+			})?.to ?? raw.trim();
+		} catch {
+			return raw.trim();
+		}
+	}
+};
 const signalSecurityAdapter = createRestrictSendersChannelSecurity({
 	channelKey: SIGNAL_CHANNEL,
 	resolveDmPolicy: (account) => account.config.dmPolicy,
@@ -303,26 +326,10 @@ function createSignalPluginBase(params) {
 }
 //#endregion
 //#region extensions/signal/src/channel.ts
-let signalMonitorModulePromise = null;
-let signalProbeModulePromise = null;
-let signalSendRuntimePromise = null;
-let signalApprovalReactionsModulePromise = null;
-async function loadSignalMonitorModule() {
-	signalMonitorModulePromise ??= import("./monitor-C1gdgT7W.js").then((n) => n.n);
-	return await signalMonitorModulePromise;
-}
-async function loadSignalProbeModule() {
-	signalProbeModulePromise ??= import("./probe-BvFJLOBi.js").then((n) => n.n);
-	return await signalProbeModulePromise;
-}
-async function loadSignalSendRuntime() {
-	signalSendRuntimePromise ??= import("./send.runtime-BnjSh7QP.js");
-	return await signalSendRuntimePromise;
-}
-async function loadSignalApprovalReactionsModule() {
-	signalApprovalReactionsModulePromise ??= import("./approval-reactions-H-RPGBK7.js").then((n) => n.n);
-	return await signalApprovalReactionsModulePromise;
-}
+const loadSignalMonitorModule = createLazyRuntimeModule(() => import("./monitor-Bee8O5Ay.js").then((n) => n.n));
+const loadSignalProbeModule = createLazyRuntimeModule(() => import("./probe-Cnht8Ihg.js").then((n) => n.n));
+const loadSignalSendRuntime = createLazyRuntimeModule(() => import("./send.runtime-CEi5oyCG.js"));
+const loadSignalApprovalReactionsModule = createLazyRuntimeModule(() => import("./approval-reactions-UFmUPD0A.js").then((n) => n.r));
 async function resolveSignalSendContext(params) {
 	return {
 		send: resolveOutboundSendDep(params.deps, "signal") ?? (await loadSignalSendRuntime()).sendMessageSignal,
@@ -333,9 +340,16 @@ async function resolveSignalSendContext(params) {
 		})
 	};
 }
+function resolveSignalSendTarget(params) {
+	return resolveSignalTarget({
+		cfg: params.cfg,
+		accountId: params.accountId,
+		input: params.to
+	})?.to ?? params.to.trim();
+}
 async function sendSignalOutbound(params) {
 	const { send, maxBytes } = await resolveSignalSendContext(params);
-	return await send(params.to, params.text, {
+	return await send(resolveSignalSendTarget(params), params.text, {
 		cfg: params.cfg,
 		...params.mediaUrl ? { mediaUrl: params.mediaUrl } : {},
 		...params.mediaLocalRoots?.length ? { mediaLocalRoots: params.mediaLocalRoots } : {},
@@ -397,8 +411,11 @@ function buildSignalBaseSessionKey(params) {
 	});
 }
 function resolveSignalOutboundSessionRoute(params) {
-	const resolved = resolveSignalOutboundTarget(params.target);
+	const target = params.resolvedTarget?.to ?? params.target;
+	const resolved = resolveSignalOutboundTarget(target);
 	if (!resolved) return null;
+	const normalizedTarget = target.replace(/^signal:/i, "").trim();
+	const recipientSessionExact = resolved.chatType === "group" || /^\+?\d{3,15}$/.test(normalizedTarget) ? true : "direct-alias";
 	const baseSessionKey = buildSignalBaseSessionKey({
 		cfg: params.cfg,
 		agentId: params.agentId,
@@ -408,6 +425,7 @@ function resolveSignalOutboundSessionRoute(params) {
 	return {
 		sessionKey: baseSessionKey,
 		baseSessionKey,
+		recipientSessionExact,
 		...resolved
 	};
 }
@@ -418,6 +436,11 @@ async function sendFormattedSignalText(ctx) {
 		deps: ctx.deps
 	});
 	const limit = resolveTextChunkLimit(ctx.cfg, "signal", ctx.accountId ?? void 0, { fallbackLimit: 4e3 });
+	const to = resolveSignalSendTarget({
+		cfg: ctx.cfg,
+		accountId: ctx.accountId ?? void 0,
+		to: ctx.to
+	});
 	const tableMode = resolveMarkdownTableMode({
 		cfg: ctx.cfg,
 		channel: "signal",
@@ -431,16 +454,17 @@ async function sendFormattedSignalText(ctx) {
 	const results = [];
 	for (const chunk of chunks) {
 		ctx.abortSignal?.throwIfAborted();
-		const result = await send(ctx.to, chunk.text, {
+		const deliveryResult = attachChannelToResult("signal", attachSignalVisibleText(await send(to, chunk.text, {
 			cfg: ctx.cfg,
 			maxBytes,
 			accountId: ctx.accountId ?? void 0,
 			textMode: "plain",
 			textStyles: chunk.styles
-		});
-		results.push(attachSignalVisibleText(result, chunk.text));
+		}), chunk.text));
+		results.push(deliveryResult);
+		await ctx.onDeliveryResult?.(deliveryResult);
 	}
-	return attachChannelToResults("signal", results);
+	return results;
 }
 async function sendFormattedSignalMedia(ctx) {
 	ctx.abortSignal?.throwIfAborted();
@@ -449,6 +473,11 @@ async function sendFormattedSignalMedia(ctx) {
 		accountId: ctx.accountId ?? void 0,
 		deps: ctx.deps
 	});
+	const to = resolveSignalSendTarget({
+		cfg: ctx.cfg,
+		accountId: ctx.accountId ?? void 0,
+		to: ctx.to
+	});
 	const tableMode = resolveMarkdownTableMode({
 		cfg: ctx.cfg,
 		channel: "signal",
@@ -458,7 +487,7 @@ async function sendFormattedSignalMedia(ctx) {
 		text: ctx.text,
 		styles: []
 	};
-	return attachChannelToResult("signal", attachSignalVisibleText(await send(ctx.to, formatted.text, {
+	return attachChannelToResult("signal", attachSignalVisibleText(await send(to, formatted.text, {
 		cfg: ctx.cfg,
 		mediaUrl: ctx.mediaUrl,
 		mediaLocalRoots: ctx.mediaLocalRoots,
@@ -474,14 +503,20 @@ async function registerDeliveredSignalApprovalPayloadForReactions(params) {
 		cfg: params.cfg,
 		accountId: params.target.accountId ?? void 0
 	});
-	if (!account.config.account) return;
+	const targetAuthor = normalizeOptionalString(account.config.account);
+	const targetAuthorUuid = normalizeOptionalString(account.config.accountUuid);
+	if (!targetAuthor && !targetAuthorUuid) return;
 	const { registerSignalApprovalReactionTargetForDeliveredPayload } = await loadSignalApprovalReactionsModule();
 	registerSignalApprovalReactionTargetForDeliveredPayload({
 		cfg: params.cfg,
-		target: params.target,
+		target: {
+			...params.target,
+			accountId: account.accountId
+		},
 		payload: params.payload,
 		results: params.results,
-		targetAuthor: account.config.account
+		targetAuthor,
+		targetAuthorUuid
 	});
 }
 async function renderSignalApprovalPayloadForReactions(params) {
@@ -489,14 +524,17 @@ async function renderSignalApprovalPayloadForReactions(params) {
 		cfg: params.ctx.cfg,
 		accountId: params.ctx.accountId ?? void 0
 	});
-	if (!account.config.account) return null;
+	const targetAuthor = normalizeOptionalString(account.config.account);
+	const targetAuthorUuid = normalizeOptionalString(account.config.accountUuid);
+	if (!targetAuthor && !targetAuthorUuid) return null;
 	const { addSignalApprovalReactionHintToStructuredPayload } = await loadSignalApprovalReactionsModule();
 	return addSignalApprovalReactionHintToStructuredPayload({
 		cfg: params.ctx.cfg,
 		accountId: params.ctx.accountId ?? void 0,
 		to: params.ctx.to,
 		payload: params.payload,
-		targetAuthor: account.config.account
+		targetAuthor,
+		targetAuthorUuid
 	});
 }
 const signalPlugin = createChatChannelPlugin({
@@ -537,9 +575,44 @@ const signalPlugin = createChatChannelPlugin({
 			resolveOutboundSessionRoute: (params) => resolveSignalOutboundSessionRoute(params),
 			targetResolver: {
 				looksLikeId: looksLikeSignalTargetId,
-				hint: "<E.164|uuid:ID|group:ID|signal:group:ID|signal:+E.164>"
+				hint: "<E.164|uuid:ID|group:ID|signal:group:ID|signal:+E.164>",
+				resolveTarget: async ({ cfg, accountId, input }) => {
+					let target;
+					try {
+						target = resolveSignalTarget({
+							cfg,
+							accountId,
+							input
+						});
+					} catch {
+						return null;
+					}
+					if (!target) return null;
+					return {
+						to: target.to,
+						kind: target.kind,
+						display: target.source === "alias" ? target.alias : void 0,
+						source: target.source === "alias" ? "directory" : "normalized"
+					};
+				}
 			}
 		},
+		directory: {
+			listPeers: async ({ cfg, accountId, query, limit }) => listSignalAliasDirectoryEntries({
+				cfg,
+				accountId,
+				query,
+				limit,
+				kind: "user"
+			}),
+			listGroups: async ({ cfg, accountId, query, limit }) => listSignalAliasDirectoryEntries({
+				cfg,
+				accountId,
+				query,
+				limit,
+				kind: "group"
+			})
+		},
 		heartbeat: {
 			sendTyping: async ({ cfg, to, accountId }) => {
 				await (await loadSignalSendRuntime()).sendTypingSignal(to, {
@@ -605,9 +678,38 @@ const signalPlugin = createChatChannelPlugin({
 		}
 	} },
 	security: signalSecurityAdapter,
+	threading: { resolveReplyToMode: (params) => resolveSignalReplyToMode(params) },
 	outbound: {
 		base: {
 			deliveryMode: "direct",
+			resolveTarget: ({ cfg, to, accountId }) => {
+				const raw = to?.trim();
+				if (!raw) return {
+					ok: false,
+					error: /* @__PURE__ */ new Error("Signal target is required")
+				};
+				let target;
+				try {
+					target = resolveSignalTarget({
+						cfg: cfg ?? {},
+						accountId,
+						input: raw
+					});
+				} catch (error) {
+					return {
+						ok: false,
+						error: error instanceof Error ? error : new Error(String(error))
+					};
+				}
+				if (!target) return {
+					ok: false,
+					error: /* @__PURE__ */ new Error(`Unknown Signal alias or target "${raw}". Configure channels.signal.aliases.${raw.replace(/^signal:/i, "")} or use E.164, uuid:<id>, username:<name>, or group:<id>.`)
+				};
+				return {
+					ok: true,
+					to: target.to
+				};
+			},
 			chunker: chunkText,
 			chunkerMode: "text",
 			textChunkLimit: 4e3,
@@ -620,13 +722,14 @@ const signalPlugin = createChatChannelPlugin({
 			}),
 			afterDeliverPayload: async (params) => await registerDeliveredSignalApprovalPayloadForReactions(params),
 			renderPresentation: async (params) => await renderSignalApprovalPayloadForReactions(params),
-			sendFormattedText: async ({ cfg, to, text, accountId, deps, abortSignal }) => await sendFormattedSignalText({
+			sendFormattedText: async ({ cfg, to, text, accountId, deps, abortSignal, onDeliveryResult }) => await sendFormattedSignalText({
 				cfg,
 				to,
 				text,
 				accountId,
 				deps,
-				abortSignal
+				abortSignal,
+				onDeliveryResult
 			}),
 			sendFormattedMedia: async ({ cfg, to, text, mediaUrl, mediaLocalRoots, mediaReadFile, accountId, deps, abortSignal }) => await sendFormattedSignalMedia({
 				cfg,

package/dist/channel-plugin-api.js

@@ -1,2 +1,2 @@
-import { t as signalPlugin } from "./channel-aQhurb0Z.js";
+import { t as signalPlugin } from "./channel-Cnhy1RwG.js";
 export { signalPlugin };

package/dist/{channel.runtime-C5skg4Q0.js → channel.runtime-CQN0RaFx.js}

@@ -1,6 +1,6 @@
-import { i as resolveSignalAccount, n as listSignalAccountIds } from "./accounts-hOCHbEhX.js";
-import { c as signalNumberTextInput, i as createSignalCliPathTextInput, o as signalCompletionNote, s as signalDmPolicy } from "./channel-aQhurb0Z.js";
-import { r as installSignalCli } from "./install-signal-cli-TwhJ0DGy.js";
+import { i as resolveSignalAccount, n as listSignalAccountIds } from "./accounts-Bz4HtP0g.js";
+import { c as signalNumberTextInput, i as createSignalCliPathTextInput, o as signalCompletionNote, s as signalDmPolicy } from "./channel-Cnhy1RwG.js";
+import { r as installSignalCli } from "./install-signal-cli-ik8VPaGg.js";
 import { detectBinary } from "openclaw/plugin-sdk/setup-tools";
 import { createDetectedBinaryStatus, createSetupTranslator, setSetupChannelEnabled } from "openclaw/plugin-sdk/setup";
 //#region extensions/signal/src/setup-surface.ts

package/dist/{reaction-runtime-api-BRJCLiqK.js → client-adapter-C9mB2Jz8.js}

@@ -1,13 +1,10 @@
-import { i as resolveSignalAccount } from "./accounts-hOCHbEhX.js";
 import { detectMime, parseMediaContentLength } from "openclaw/plugin-sdk/media-runtime";
-import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { asDateTimestampMs, parseStrictNonNegativeInteger, resolveExpiresAtMsFromDurationMs, resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
-import { requireRuntimeConfig } from "openclaw/plugin-sdk/plugin-config-runtime";
-import fs from "node:fs/promises";
-import path from "node:path";
+import nodePath from "node:path";
 import { resolveFetch } from "openclaw/plugin-sdk/fetch-runtime";
 import { readProviderTextResponse, readResponseTextLimited } from "openclaw/plugin-sdk/provider-http";
 import { readResponseWithLimit } from "openclaw/plugin-sdk/response-limit-runtime";
+import { readRegularFile } from "openclaw/plugin-sdk/security-runtime";
 import WebSocket from "ws";
 import { Buffer as Buffer$1 } from "node:buffer";
 import http from "node:http";
@@ -24,6 +21,8 @@ import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 */
 const DEFAULT_TIMEOUT_MS$2 = 1e4;
 const DEFAULT_ATTACHMENT_RESPONSE_MAX_BYTES = 1048576;
+const SIGNAL_CONTAINER_WS_MAX_PAYLOAD_BYTES = 1024 * 1024;
+const DEFAULT_SIGNAL_CONTAINER_MAX_ATTACHMENT_BYTES = 8 * 1024 * 1024;
 const CONTAINER_TEXT_STYLE_MARKERS = {
 	BOLD: "**",
 	ITALIC: "*",
@@ -123,7 +122,7 @@ function containerReceiveCheck(normalizedBaseUrl, account, timeoutMs) {
 			resolve(result);
 		};
 		try {
-			ws = new WebSocket(wsUrl);
+			ws = new WebSocket(wsUrl, { maxPayload: SIGNAL_CONTAINER_WS_MAX_PAYLOAD_BYTES });
 		} catch (err) {
 			settle({
 				ok: false,
@@ -156,10 +155,11 @@ function containerReceiveCheck(normalizedBaseUrl, account, timeoutMs) {
 			});
 		});
 		ws.once("close", (code, reason) => {
+			const reasonText = reason.length > 0 ? `: ${reason.toString("utf8")}` : "";
 			settle({
 				ok: false,
 				status: null,
-				error: `Signal container receive WebSocket closed before open (${code}${reason.length > 0 ? `: ${reason.toString("utf8")}` : ""})`
+				error: `Signal container receive WebSocket closed before open (${code}${reasonText})`
 			});
 		});
 	});
@@ -227,7 +227,7 @@ async function streamContainerEvents(params) {
 			}
 		};
 		try {
-			ws = new WebSocket(wsUrl);
+			ws = new WebSocket(wsUrl, { maxPayload: SIGNAL_CONTAINER_WS_MAX_PAYLOAD_BYTES });
 		} catch (err) {
 			logError(`[signal-ws] failed to create WebSocket: ${err instanceof Error ? err.message : String(err)}`);
 			reject(toLintErrorObject$1(err, "Non-Error rejection"));
@@ -249,7 +249,8 @@ async function streamContainerEvents(params) {
 			logError(`[signal-ws] error: ${err instanceof Error ? err.message : String(err)}`);
 		});
 		ws.on("close", (code, reason) => {
-			log(`[signal-ws] closed (code=${code}, reason=${reason?.toString() || "no reason"})`);
+			const reasonStr = reason?.toString() || "no reason";
+			log(`[signal-ws] closed (code=${code}, reason=${reasonStr})`);
 			cleanup();
 			resolve();
 		});
@@ -274,15 +275,20 @@ async function streamContainerEvents(params) {
 * Convert local file paths to base64 data URIs for the container REST API.
 * The bbernhard container /v2/send only accepts `base64_attachments` (not file paths).
 */
-async function filesToBase64DataUris(filePaths) {
+async function filesToBase64DataUris(filePaths, maxAttachmentBytes) {
 	const results = [];
+	let remainingBytes = maxAttachmentBytes;
 	for (const filePath of filePaths) {
-		const buffer = await fs.readFile(filePath);
+		const { buffer } = await readRegularFile({
+			filePath,
+			maxBytes: remainingBytes
+		});
+		remainingBytes -= buffer.byteLength;
 		const mime = await detectMime({
 			buffer,
 			filePath
 		}) ?? "application/octet-stream";
-		const filename = path.basename(filePath);
+		const filename = nodePath.basename(filePath);
 		const b64 = buffer.toString("base64");
 		results.push(`data:${mime};filename=${filename};base64,${b64}`);
 	}
@@ -305,7 +311,7 @@ function renderContainerStyledText(text, styles) {
 		};
 	}).filter((span) => span !== null);
 	if (spans.length === 0) return text;
-	const positions = [...new Set([
+	const positions = [.../* @__PURE__ */ new Set([
 		0,
 		text.length,
 		...spans.flatMap((span) => [span.start, span.end])
@@ -326,6 +332,12 @@ function parseContainerSendTimestamp(raw) {
 	if (timestamp === void 0) throw new Error("Signal REST send returned invalid timestamp");
 	return timestamp;
 }
+function normalizeContainerQuoteTimestamp(raw) {
+	return parseStrictNonNegativeInteger(raw) ?? void 0;
+}
+function normalizeContainerQuoteText(raw) {
+	return typeof raw === "string" ? raw : void 0;
+}
 /**
 * Send message via bbernhard container REST API.
 */
@@ -339,7 +351,16 @@ async function containerSendMessage(params) {
 		payload.message = renderContainerStyledText(params.message, params.textStyles);
 		payload["text_mode"] = "styled";
 	}
-	if (params.attachments && params.attachments.length > 0) payload.base64_attachments = await filesToBase64DataUris(params.attachments);
+	if (params.attachments && params.attachments.length > 0) {
+		const configuredMaxBytes = params.maxAttachmentBytes;
+		const maxAttachmentBytes = typeof configuredMaxBytes === "number" && Number.isFinite(configuredMaxBytes) && configuredMaxBytes >= 0 ? Math.floor(configuredMaxBytes) : DEFAULT_SIGNAL_CONTAINER_MAX_ATTACHMENT_BYTES;
+		payload.base64_attachments = await filesToBase64DataUris(params.attachments, maxAttachmentBytes);
+	}
+	if (params.quoteTimestamp !== void 0 && params.quoteAuthor) {
+		payload.quote_timestamp = params.quoteTimestamp;
+		payload.quote_author = params.quoteAuthor;
+		payload.quote_message = params.quoteMessage ?? "";
+	}
 	const timestamp = parseContainerSendTimestamp((await containerRestRequest("/v2/send", {
 		baseUrl: params.baseUrl,
 		timeoutMs: params.timeoutMs
@@ -440,6 +461,8 @@ async function containerRpcRequest(method, params, opts) {
 					style
 				};
 			});
+			const quoteTimestamp = normalizeContainerQuoteTimestamp(p.quoteTimestamp ?? p["quote-timestamp"]);
+			const quoteAuthor = normalizeContainerQuoteText(p.quoteAuthor ?? p["quote-author"]);
 			return await containerSendMessage({
 				baseUrl: opts.baseUrl,
 				account: p.account ?? "",
@@ -447,6 +470,10 @@ async function containerRpcRequest(method, params, opts) {
 				message: p.message ?? "",
 				textStyles,
 				attachments: p.attachments,
+				maxAttachmentBytes: opts.maxAttachmentBytes,
+				quoteTimestamp,
+				quoteAuthor: quoteAuthor ? stripUuidPrefix(quoteAuthor) : void 0,
+				quoteMessage: normalizeContainerQuoteText(p.quoteMessage ?? p["quote-message"]),
 				timeoutMs: opts.timeoutMs
 			});
 		}
@@ -953,127 +980,4 @@ async function streamSignalEvents(params) {
 	});
 }
 //#endregion
-//#region extensions/signal/src/rpc-context.ts
-function resolveSignalRpcContext(opts, accountInfo) {
-	const hasBaseUrl = Boolean(normalizeOptionalString(opts.baseUrl));
-	const hasAccount = Boolean(normalizeOptionalString(opts.account));
-	if ((!hasBaseUrl || !hasAccount) && !accountInfo) throw new Error("Signal account config is required when baseUrl or account is missing");
-	const resolvedAccount = accountInfo;
-	const baseUrl = normalizeOptionalString(opts.baseUrl) ?? resolvedAccount?.baseUrl;
-	if (!baseUrl) throw new Error("Signal base URL is required");
-	return {
-		baseUrl,
-		account: normalizeOptionalString(opts.account) ?? normalizeOptionalString(resolvedAccount?.config.account)
-	};
-}
-//#endregion
-//#region extensions/signal/src/send-reactions.ts
-function normalizeSignalId(raw) {
-	const trimmed = raw.trim();
-	if (!trimmed) return "";
-	return trimmed.replace(/^signal:/i, "").trim();
-}
-function normalizeSignalUuid(raw) {
-	const trimmed = normalizeSignalId(raw);
-	if (!trimmed) return "";
-	if (normalizeLowercaseStringOrEmpty(trimmed).startsWith("uuid:")) return trimmed.slice(5).trim();
-	return trimmed;
-}
-function resolveTargetAuthorParams(params) {
-	const candidates = [
-		params.targetAuthor,
-		params.targetAuthorUuid,
-		params.fallback
-	];
-	for (const candidate of candidates) {
-		const raw = candidate?.trim();
-		if (!raw) continue;
-		const normalized = normalizeSignalUuid(raw);
-		if (normalized) return { targetAuthor: normalized };
-	}
-	return {};
-}
-async function sendReactionSignalCore(params) {
-	const cfg = requireRuntimeConfig(params.opts.cfg, "Signal reactions");
-	const apiMode = cfg.channels?.signal?.apiMode;
-	const accountInfo = resolveSignalAccount({
-		cfg,
-		accountId: params.opts.accountId
-	});
-	const { baseUrl, account } = resolveSignalRpcContext(params.opts, accountInfo);
-	const normalizedRecipient = normalizeSignalUuid(params.recipient);
-	const groupId = params.opts.groupId?.trim();
-	if (!normalizedRecipient && !groupId) throw new Error(params.errors.missingRecipient);
-	if (!Number.isFinite(params.targetTimestamp) || params.targetTimestamp <= 0) throw new Error(params.errors.invalidTargetTimestamp);
-	const normalizedEmoji = params.emoji?.trim();
-	if (!normalizedEmoji) throw new Error(params.errors.missingEmoji);
-	const targetAuthorParams = resolveTargetAuthorParams({
-		targetAuthor: params.opts.targetAuthor,
-		targetAuthorUuid: params.opts.targetAuthorUuid,
-		fallback: normalizedRecipient
-	});
-	if (groupId && !targetAuthorParams.targetAuthor) throw new Error(params.errors.missingTargetAuthor);
-	const requestParams = {
-		emoji: normalizedEmoji,
-		targetTimestamp: params.targetTimestamp,
-		...params.remove ? { remove: true } : {},
-		...targetAuthorParams
-	};
-	if (normalizedRecipient) requestParams.recipients = [normalizedRecipient];
-	if (groupId) requestParams.groupIds = [groupId];
-	if (account) requestParams.account = account;
-	return {
-		ok: true,
-		timestamp: (await signalRpcRequest("sendReaction", requestParams, {
-			baseUrl,
-			timeoutMs: params.opts.timeoutMs,
-			apiMode
-		}))?.timestamp
-	};
-}
-/**
-* Send a Signal reaction to a message
-* @param recipient - UUID or E.164 phone number of the message author
-* @param targetTimestamp - Message ID (timestamp) to react to
-* @param emoji - Emoji to react with
-* @param opts - Optional account/connection overrides
-*/
-async function sendReactionSignal(recipient, targetTimestamp, emoji, opts) {
-	return await sendReactionSignalCore({
-		recipient,
-		targetTimestamp,
-		emoji,
-		remove: false,
-		opts,
-		errors: {
-			missingRecipient: "Recipient or groupId is required for Signal reaction",
-			invalidTargetTimestamp: "Valid targetTimestamp is required for Signal reaction",
-			missingEmoji: "Emoji is required for Signal reaction",
-			missingTargetAuthor: "targetAuthor is required for group reactions"
-		}
-	});
-}
-/**
-* Remove a Signal reaction from a message
-* @param recipient - UUID or E.164 phone number of the message author
-* @param targetTimestamp - Message ID (timestamp) to remove reaction from
-* @param emoji - Emoji to remove
-* @param opts - Optional account/connection overrides
-*/
-async function removeReactionSignal(recipient, targetTimestamp, emoji, opts) {
-	return await sendReactionSignalCore({
-		recipient,
-		targetTimestamp,
-		emoji,
-		remove: true,
-		opts,
-		errors: {
-			missingRecipient: "Recipient or groupId is required for Signal reaction removal",
-			invalidTargetTimestamp: "Valid targetTimestamp is required for Signal reaction removal",
-			missingEmoji: "Emoji is required for Signal reaction removal",
-			missingTargetAuthor: "targetAuthor is required for group reaction removal"
-		}
-	});
-}
-//#endregion
-export { signalRpcRequest as a, signalCheck as i, sendReactionSignal as n, streamSignalEvents as o, resolveSignalRpcContext as r, removeReactionSignal as t };
+export { signalRpcRequest as n, streamSignalEvents as r, signalCheck as t };

package/dist/contract-api.js

@@ -1,3 +1,3 @@
-import { d as normalizeSignalMessagingTarget, i as isSignalSenderAllowed, u as looksLikeSignalTargetId } from "./identity-B6O4k8xg.js";
-import { a as looksLikeArchive, i as installSignalCliFromRelease, n as extractSignalCliArchive, o as pickAsset, r as installSignalCli, t as downloadToFile } from "./install-signal-cli-TwhJ0DGy.js";
+import { d as normalizeSignalMessagingTarget, i as isSignalSenderAllowed, u as looksLikeSignalTargetId } from "./identity-C8-yk4J9.js";
+import { a as looksLikeArchive, i as installSignalCliFromRelease, n as extractSignalCliArchive, o as pickAsset, r as installSignalCli, t as downloadToFile } from "./install-signal-cli-ik8VPaGg.js";
 export { downloadToFile, extractSignalCliArchive, installSignalCli, installSignalCliFromRelease, isSignalSenderAllowed, looksLikeArchive, looksLikeSignalTargetId, normalizeSignalMessagingTarget, pickAsset };