@openclaw/signal 2026.7.2-beta.3 → 2026.7.2-beta.5

package/dist/{reply-authors-DcNqGpX-.js → transport-detection-Da06-LOL.js}

@@ -1,55 +1,36 @@
-import { i as resolveSignalAccount, n as listSignalAccountIds, r as resolveDefaultSignalAccountId, t as listEnabledSignalAccounts } from "./accounts-Bz4HtP0g.js";
+import { u as normalizeSignalTransportUrl } from "./transport-policy-DxvSMHp9.js";
+import { i as resolveSignalAccount, n as listSignalAccountIds, r as resolveDefaultSignalAccountId, t as listEnabledSignalAccounts } from "./accounts-DrStJjiK.js";
 import { d as normalizeSignalMessagingTarget } from "./identity-BQ4OzXXk.js";
-import { i as signalApprovalAuth, r as getSignalApprovalApprovers, t as getOptionalSignalRuntime } from "./runtime-B900w6lc.js";
-import { n as sendReactionSignal, t as removeReactionSignal } from "./reaction-runtime-api-tPkUVRoL.js";
+import { i as signalApprovalAuth, r as getSignalApprovalApprovers, t as getOptionalSignalRuntime } from "./runtime-JPrGlV7h.js";
+import { n as sendReactionSignal, t as removeReactionSignal } from "./reaction-runtime-api-BjeDyKcz.js";
 import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/account-id";
+import { kindFromMime } from "openclaw/plugin-sdk/media-runtime";
 import { questionGatewayRuntime } from "openclaw/plugin-sdk/question-gateway-runtime";
 import { parseAgentSessionKey } from "openclaw/plugin-sdk/routing";
 import { resolveReactionLevel } from "openclaw/plugin-sdk/status-helpers";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { markdownToIR, renderMarkdownIRChunksWithinLimit } from "openclaw/plugin-sdk/text-chunking";
+import { FormatCapabilityProfile, markdownToIR, renderMarkdownIRChunksWithinLimit, renderMarkdownWithAttributedRanges } from "openclaw/plugin-sdk/text-chunking";
 import { createChannelApprovalCapability } from "openclaw/plugin-sdk/approval-delivery-runtime";
 import { createLazyChannelApprovalNativeRuntimeAdapter } from "openclaw/plugin-sdk/approval-handler-adapter-runtime";
-import { createChannelApproverDmTargetResolver, createChannelNativeOriginTargetResolver, createNativeApprovalChannelRouteGates, createNativeApprovalForwardingFallbackSuppressor, shouldSuppressLocalNativeExecApprovalPrompt } from "openclaw/plugin-sdk/approval-native-runtime";
+import { createChannelApproverDmTargetResolver, createChannelNativeOriginTargetResolver, createNativeApprovalChannelRouteGates, createNativeApprovalForwardingFallbackSuppressor, createNativeApprovalMessagingTargetResolvers, shouldSuppressLocalNativeExecApprovalPrompt } from "openclaw/plugin-sdk/approval-native-runtime";
 import { buildApprovalReactionPendingContentForRequest } from "openclaw/plugin-sdk/approval-reaction-runtime";
+import { formatMediaPlaceholderText } from "openclaw/plugin-sdk/channel-inbound";
 import { createActionGate, jsonResult, readStringParam, resolveReactionMessageId } from "openclaw/plugin-sdk/channel-actions";
 import { parseStrictNonNegativeInteger } from "openclaw/plugin-sdk/number-runtime";
 import { getExecApprovalReplyMetadata } from "openclaw/plugin-sdk/approval-reply-runtime";
 import { isMessagePresentationInteractiveBlock, normalizeMessagePresentation, renderMessagePresentationFallbackText } from "openclaw/plugin-sdk/interactive-runtime";
 //#region extensions/signal/src/approval-native.ts
 const DEFAULT_APPROVAL_FORWARDING_MODE = "session";
+const { normalizeForwardTarget: normalizeSignalForwardTarget, normalizeTarget: normalizeSignalApprovalTarget, resolveSessionTarget: resolveSessionSignalOriginTarget, resolveTurnSourceTarget: resolveTurnSourceSignalOriginTarget } = createNativeApprovalMessagingTargetResolvers({
+	channel: "signal",
+	normalizeTo: normalizeSignalMessagingTarget
+});
 function isSignalApprovalTransportEnabled(params) {
 	return resolveSignalAccount({
 		cfg: params.cfg,
 		accountId: params.accountId
 	}).enabled;
 }
-function normalizeSignalForwardTarget(target) {
-	if (normalizeLowercaseStringOrEmpty(target.channel) !== "signal") return null;
-	const to = normalizeSignalMessagingTarget(target.to);
-	if (!to) return null;
-	return {
-		to,
-		accountId: normalizeOptionalString(target.accountId),
-		threadId: target.threadId ?? null
-	};
-}
-function resolveTurnSourceSignalOriginTarget(request) {
-	if (normalizeLowercaseStringOrEmpty(request.request.turnSourceChannel) !== "signal") return null;
-	const to = normalizeSignalMessagingTarget(request.request.turnSourceTo ?? "");
-	if (!to) return null;
-	return {
-		to,
-		accountId: normalizeOptionalString(request.request.turnSourceAccountId)
-	};
-}
-function resolveSessionSignalOriginTarget(sessionTarget) {
-	const to = normalizeSignalMessagingTarget(sessionTarget.to);
-	return to ? {
-		to,
-		accountId: normalizeOptionalString(sessionTarget.accountId)
-	} : null;
-}
 const { canApprovalPotentiallyRouteToChannel: canApprovalPotentiallyRouteToSignal, canAnyApprovalPotentiallyRouteToChannel: canAnyApprovalPotentiallyRouteToSignal, isNativeApprovalHandlerConfigured: isSignalNativeApprovalHandlerConfiguredBase, isSessionApprovalEligible: isSignalSessionApprovalEligible, shouldHandleApprovalRequest: shouldHandleSignalApprovalRequest } = createNativeApprovalChannelRouteGates({
 	channel: "signal",
 	defaultForwardingMode: DEFAULT_APPROVAL_FORWARDING_MODE,
@@ -86,13 +67,7 @@ const resolveSignalOriginTargetBase = createChannelNativeOriginTargetResolver({
 	shouldHandleRequest: shouldHandleSignalApprovalRequest,
 	resolveTurnSourceTarget: resolveTurnSourceSignalOriginTarget,
 	resolveSessionTarget: resolveSessionSignalOriginTarget,
-	normalizeTarget: (target) => {
-		const to = normalizeSignalMessagingTarget(target.to);
-		return to ? {
-			...target,
-			to
-		} : null;
-	}
+	normalizeTarget: normalizeSignalApprovalTarget
 });
 function isSignalGroupTarget(to) {
 	return normalizeLowercaseStringOrEmpty(to).startsWith("group:");
@@ -215,184 +190,76 @@ const signalApprovalCapability = createChannelApprovalCapability({
 			approvalKind,
 			request
 		}),
-		load: async () => (await import("./approval-handler.runtime-p8gabljn.js")).signalApprovalNativeRuntime
+		load: async () => (await import("./approval-handler.runtime-C-XYgcxE.js")).signalApprovalNativeRuntime
 	})
 });
 //#endregion
 //#region extensions/signal/src/format.ts
-function normalizeUrlForComparison(url) {
-	let normalized = normalizeLowercaseStringOrEmpty(url);
-	normalized = normalized.replace(/^https?:\/\//, "");
-	normalized = normalized.replace(/^www\./, "");
-	normalized = normalized.replace(/\/+$/, "");
-	return normalized;
-}
-function mapStyle(style) {
-	switch (style) {
-		case "bold": return "BOLD";
-		case "italic": return "ITALIC";
-		case "strikethrough": return "STRIKETHROUGH";
-		case "code":
-		case "code_block": return "MONOSPACE";
-		case "spoiler": return "SPOILER";
-		default: return null;
-	}
-}
-function mergeStyles(styles) {
-	const sorted = [...styles].toSorted((a, b) => {
-		if (a.start !== b.start) return a.start - b.start;
-		if (a.length !== b.length) return a.length - b.length;
-		return a.style.localeCompare(b.style);
-	});
-	const merged = [];
-	for (const style of sorted) {
-		const prev = merged[merged.length - 1];
-		if (prev && prev.style === style.style && style.start <= prev.start + prev.length) {
-			const prevEnd = prev.start + prev.length;
-			prev.length = Math.max(prevEnd, style.start + style.length) - prev.start;
-			continue;
-		}
-		merged.push({ ...style });
-	}
-	return merged;
-}
-function clampStyles(styles, maxLength) {
-	const clamped = [];
-	for (const style of styles) {
-		const start = Math.max(0, Math.min(style.start, maxLength));
-		const length = Math.min(style.start + style.length, maxLength) - start;
-		if (length > 0) clamped.push({
-			start,
-			length,
-			style: style.style
-		});
-	}
-	return clamped;
-}
-function applyInsertionsToStyles(spans, insertions) {
-	if (insertions.length === 0) return spans;
-	const sortedInsertions = [...insertions].toSorted((a, b) => a.pos - b.pos);
-	let updated = spans;
-	let cumulativeShift = 0;
-	for (const insertion of sortedInsertions) {
-		const insertionPos = insertion.pos + cumulativeShift;
-		const next = [];
-		for (const span of updated) {
-			if (span.end <= insertionPos) {
-				next.push(span);
-				continue;
-			}
-			if (span.start >= insertionPos) {
-				next.push({
-					start: span.start + insertion.length,
-					end: span.end + insertion.length,
-					style: span.style
-				});
-				continue;
-			}
-			if (span.start < insertionPos && span.end > insertionPos) {
-				if (insertionPos > span.start) next.push({
-					start: span.start,
-					end: insertionPos,
-					style: span.style
-				});
-				const shiftedStart = insertionPos + insertion.length;
-				const shiftedEnd = span.end + insertion.length;
-				if (shiftedEnd > shiftedStart) next.push({
-					start: shiftedStart,
-					end: shiftedEnd,
-					style: span.style
-				});
-			}
-		}
-		updated = next;
-		cumulativeShift += insertion.length;
+const SIGNAL_STYLE_MAP = {
+	bold: "BOLD",
+	italic: "ITALIC",
+	strikethrough: "STRIKETHROUGH",
+	code: "MONOSPACE",
+	code_block: "MONOSPACE",
+	spoiler: "SPOILER"
+};
+const SIGNAL_FORMAT_PROFILE = FormatCapabilityProfile.define({
+	mechanism: "ranges",
+	constructs: {
+		underline: "strip",
+		codeLanguage: "fallback",
+		linkLabel: "fallback",
+		heading: "fallback",
+		bulletList: "fallback",
+		orderedList: "fallback",
+		taskList: "fallback",
+		table: "fallback",
+		blockquote: "fallback",
+		image: "fallback",
+		mention: "strip"
+	},
+	chunk: {
+		limit: 4e3,
+		unit: "chars"
 	}
-	return updated;
+});
+function stripEquivalentSignalLinks(ir) {
+	const normalize = (value) => normalizeLowercaseStringOrEmpty(value).replace(/^(?:https?:\/\/)?(?:www\.)?/, "").replace(/\/+$/, "");
+	return {
+		...ir,
+		links: ir.links.filter((link) => {
+			const label = ir.text.slice(link.start, link.end).trim();
+			return normalize(label) !== normalize(link.href.trim().replace(/^mailto:/, ""));
+		})
+	};
 }
 function renderSignalText(ir) {
-	const text = ir.text ?? "";
-	if (!text) return {
-		text: "",
-		styles: []
-	};
-	const sortedLinks = [...ir.links].toSorted((a, b) => a.start - b.start);
-	let out = "";
-	let cursor = 0;
-	const insertions = [];
-	for (const link of sortedLinks) {
-		if (link.start < cursor) continue;
-		out += text.slice(cursor, link.end);
-		const href = link.href.trim();
-		const trimmedLabel = text.slice(link.start, link.end).trim();
-		if (href) if (!trimmedLabel) {
-			out += href;
-			insertions.push({
-				pos: link.end,
-				length: href.length
-			});
-		} else {
-			const normalizedLabel = normalizeUrlForComparison(trimmedLabel);
-			let comparableHref = href;
-			if (href.startsWith("mailto:")) comparableHref = href.slice(7);
-			if (normalizedLabel !== normalizeUrlForComparison(comparableHref)) {
-				const addition = ` (${href})`;
-				out += addition;
-				insertions.push({
-					pos: link.end,
-					length: addition.length
-				});
-			}
-		}
-		cursor = link.end;
-	}
-	out += text.slice(cursor);
-	const mappedStyles = ir.styles.map((span) => {
-		const mapped = mapStyle(span.style);
-		if (!mapped) return null;
-		return {
-			start: span.start,
-			end: span.end,
-			style: mapped
-		};
-	}).filter((span) => span !== null);
-	for (const annotation of ir.annotations ?? []) if (annotation.type === "assistant_transcript_role") mappedStyles.push({
-		start: annotation.start,
-		end: annotation.end,
-		style: "MONOSPACE"
-	});
-	const adjusted = applyInsertionsToStyles(mappedStyles, insertions);
-	const trimmedText = out.trimEnd();
-	const trimmedLength = trimmedText.length;
+	const rendered = renderMarkdownWithAttributedRanges(stripEquivalentSignalLinks(ir), {
+		styleMap: SIGNAL_STYLE_MAP,
+		annotationStyleMap: { assistant_transcript_role: "MONOSPACE" },
+		trimEnd: true
+	}, SIGNAL_FORMAT_PROFILE);
 	return {
-		text: trimmedText,
-		styles: mergeStyles(clampStyles(adjusted.map((span) => ({
-			start: span.start,
-			length: span.end - span.start,
-			style: span.style
-		})), trimmedLength))
+		text: rendered.text,
+		styles: rendered.ranges
 	};
 }
-function markdownToSignalText(markdown, options = {}) {
-	return renderSignalText(markdownToIR(markdown ?? "", {
+function markdownToSignalIR(markdown, options) {
+	return markdownToIR(markdown ?? "", {
 		assistantTranscriptRoleHeaders: true,
 		linkify: true,
 		enableSpoilers: true,
-		headingStyle: "bold",
+		headingStyle: "rich",
 		blockquotePrefix: "> ",
 		tableMode: options.tableMode
-	}));
+	});
+}
+function markdownToSignalText(markdown, options = {}) {
+	return renderSignalText(markdownToSignalIR(markdown, options));
 }
 function markdownToSignalTextChunks(markdown, limit, options = {}) {
 	return renderMarkdownIRChunksWithinLimit({
-		ir: markdownToIR(markdown ?? "", {
-			assistantTranscriptRoleHeaders: true,
-			linkify: true,
-			enableSpoilers: true,
-			headingStyle: "bold",
-			blockquotePrefix: "> ",
-			tableMode: options.tableMode
-		}),
+		ir: markdownToSignalIR(markdown, options),
 		limit,
 		assistantTranscriptRoleMessageBoundaries: true,
 		renderChunk: renderSignalText,
@@ -400,6 +267,22 @@ function markdownToSignalTextChunks(markdown, limit, options = {}) {
 	}).map(({ rendered }) => rendered);
 }
 //#endregion
+//#region extensions/signal/src/media-text.ts
+function formatAttachmentKindCount(kind, count) {
+	if (kind === "attachment") return `${count} file${count > 1 ? "s" : ""}`;
+	return `${count} ${kind}${count > 1 ? "s" : ""}`;
+}
+/** Keeps Signal's established multi-attachment text while sharing single-item rendering. */
+function formatSignalMediaText(media) {
+	if (media.length <= 1) return formatMediaPlaceholderText(media);
+	const kindCounts = /* @__PURE__ */ new Map();
+	for (const entry of media) {
+		const kind = entry.kind && entry.kind !== "unknown" ? entry.kind : kindFromMime(entry.contentType) ?? "attachment";
+		kindCounts.set(kind, (kindCounts.get(kind) ?? 0) + 1);
+	}
+	return `[${[...kindCounts.entries()].map(([kind, count]) => formatAttachmentKindCount(kind, count)).join(" + ")} attached]`;
+}
+//#endregion
 //#region extensions/signal/src/reaction-level.ts
 /**
 * Resolve the effective reaction level and its implications for Signal.
@@ -488,17 +371,19 @@ const signalMessageActions = {
 	handleAction: async ({ action, params, cfg, accountId, toolContext }) => {
 		if (action === "send") throw new Error("Send should be handled by outbound, not actions handler.");
 		if (action === "react") {
+			const account = resolveSignalAccount({
+				cfg,
+				accountId
+			});
+			if (!account.enabled) throw new Error(`Signal account "${account.accountId}" is disabled.`);
+			if (!account.configured) throw new Error(`Signal account "${account.accountId}" is not configured.`);
 			const reactionLevelInfo = resolveSignalReactionLevel({
 				cfg,
-				accountId: accountId ?? void 0
+				accountId: account.accountId
 			});
 			if (!reactionLevelInfo.agentReactionsEnabled) throw new Error(`Signal agent reactions disabled (reactionLevel="${reactionLevelInfo.level}"). Set channels.signal.reactionLevel to "minimal" or "extensive" to enable.`);
-			const actionConfig = resolveSignalAccount({
-				cfg,
-				accountId
-			}).config.actions;
-			if (!createActionGate(actionConfig)("reactions")) throw new Error("Signal reactions are disabled via actions.reactions.");
-			const target = resolveSignalReactionTarget(readStringParam(params, "recipient") ?? readStringParam(params, "to", {
+			if (!createActionGate(account.config.actions)("reactions")) throw new Error("Signal reactions are disabled via actions.reactions.");
+			const target = resolveSignalReactionTarget(readStringParam(params, "to", {
 				required: true,
 				label: "recipient (UUID, phone number, or group)"
 			}));
@@ -520,7 +405,7 @@ const signalMessageActions = {
 				if (!emoji) throw new Error("Emoji required to remove reaction.");
 				return await mutateSignalReaction({
 					cfg,
-					accountId: accountId ?? void 0,
+					accountId: account.accountId,
 					target,
 					timestamp,
 					emoji,
@@ -532,7 +417,7 @@ const signalMessageActions = {
 			if (!emoji) throw new Error("Emoji required to add reaction.");
 			return await mutateSignalReaction({
 				cfg,
-				accountId: accountId ?? void 0,
+				accountId: account.accountId,
 				target,
 				timestamp,
 				emoji,
@@ -617,9 +502,11 @@ function resolveReplyContext(record) {
 	const author = normalizeOptionalString(record.author);
 	if (!author) return;
 	const body = normalizeOptionalString(record.body);
+	const media = record.media;
 	return {
 		author,
-		...body ? { body } : {}
+		...body ? { body } : {},
+		...media?.length ? { media } : {}
 	};
 }
 function resolveSourceTimestamp(value) {
@@ -629,7 +516,7 @@ function mergeReplyContext(current, next) {
 	if (!current) return next;
 	if (current.kind === "ambiguous") return current;
 	if (current.author !== next.author) {
-		const { author: _author, body: _body, ...identity } = next;
+		const { author: _author, body: _body, media: _media, ...identity } = next;
 		return {
 			...identity,
 			kind: "ambiguous"
@@ -642,6 +529,10 @@ async function registerSignalReplyContext(params) {
 	const key = buildSignalReplyAuthorStoreKey(params);
 	const author = normalizeOptionalString(params.author);
 	const body = normalizeOptionalString(params.body);
+	const media = params.media?.map((entry) => ({
+		contentType: normalizeOptionalString(entry.contentType),
+		kind: entry.kind ?? void 0
+	}));
 	const conversationKey = normalizeSignalMessagingTarget(params.to);
 	const replyToId = normalizeOptionalString(params.replyToId);
 	const accountKey = normalizeLowercaseStringOrEmpty(normalizeOptionalString(params.accountId) ?? DEFAULT_ACCOUNT_ID);
@@ -652,6 +543,7 @@ async function registerSignalReplyContext(params) {
 		kind: "resolved",
 		author,
 		...body ? { body } : {},
+		...media?.length ? { media } : {},
 		accountId: accountKey,
 		conversationKey,
 		replyToId,
@@ -736,4 +628,25 @@ async function resolveSignalReplyContextWithPersistence(params) {
 	}
 }
 //#endregion
-export { resolveSignalReactionLevel as a, isSignalNativeApprovalHandlerConfigured as c, signalMessageActions as i, shouldSuppressLocalSignalExecApprovalPrompt as l, resolveSignalReplyContextWithPersistence as n, markdownToSignalText as o, materializeSignalPresentationFallback as r, markdownToSignalTextChunks as s, registerSignalReplyContext as t, signalApprovalCapability as u };
+//#region extensions/signal/src/transport-detection.ts
+const DEFAULT_PROBE_TIMEOUT_MS = 1e4;
+async function detectSignalTransport(params) {
+	const url = normalizeSignalTransportUrl(params.url);
+	const timeoutMs = params.timeoutMs ?? DEFAULT_PROBE_TIMEOUT_MS;
+	const probes = params.probeNative && params.probeContainer ? void 0 : await import("./transport-probes.runtime-CV6Qs0Og.js");
+	const probeNative = params.probeNative ?? probes?.nativeCheck;
+	const probeContainer = params.probeContainer ?? probes?.containerCheck;
+	if (!probeNative || !probeContainer) throw new Error("Signal transport probes are unavailable");
+	const [native, container] = await Promise.all([probeNative(url, timeoutMs).catch(() => ({ ok: false })), probeContainer(url, timeoutMs, params.account).catch(() => ({ ok: false }))]);
+	if (native.ok) return {
+		kind: "external-native",
+		url
+	};
+	if (container.ok) return {
+		kind: "container",
+		url
+	};
+	throw new Error(`Signal transport not reachable at ${url}`);
+}
+//#endregion
+export { signalMessageActions as a, markdownToSignalText as c, shouldSuppressLocalSignalExecApprovalPrompt as d, signalApprovalCapability as f, materializeSignalPresentationFallback as i, markdownToSignalTextChunks as l, registerSignalReplyContext as n, resolveSignalReactionLevel as o, resolveSignalReplyContextWithPersistence as r, formatSignalMediaText as s, detectSignalTransport as t, isSignalNativeApprovalHandlerConfigured as u };

package/dist/transport-detection.runtime-D_190UUL.js

@@ -0,0 +1,2 @@
+import { t as detectSignalTransport } from "./transport-detection-Da06-LOL.js";
+export { detectSignalTransport };

package/dist/transport-policy-DxvSMHp9.js

@@ -0,0 +1,99 @@
+import { isIP } from "node:net";
+//#region extensions/signal/src/transport-url.ts
+function normalizeSignalTransportUrl(value) {
+	const trimmed = value.trim();
+	if (!trimmed) throw new Error("Signal transport URL is required");
+	if (/^https?:/i.test(trimmed) && !/^https?:\/\/[^/]/i.test(trimmed)) throw new Error("Signal transport URL has a malformed HTTP scheme");
+	const explicitScheme = /^([a-z][a-z0-9+.-]*):\/\//i.exec(trimmed)?.[1]?.toLowerCase();
+	if (explicitScheme && explicitScheme !== "http" && explicitScheme !== "https") throw new Error(`Signal transport URL unsupported protocol: ${explicitScheme}:`);
+	const parsed = new URL(/^https?:\/\//i.test(trimmed) ? trimmed : `http://${trimmed}`);
+	if (parsed.protocol !== "http:" && parsed.protocol !== "https:") throw new Error(`Signal transport URL unsupported protocol: ${parsed.protocol}`);
+	if (parsed.username || parsed.password) throw new Error("Signal transport URL must not include credentials");
+	const pathname = parsed.pathname === "/" ? "" : parsed.pathname.replace(/\/+$/, "");
+	return `${parsed.protocol}//${parsed.host}${pathname}`;
+}
+function normalizeSignalTransportHost(host) {
+	const trimmedHost = host.trim();
+	const hasOpeningBracket = trimmedHost.startsWith("[");
+	if (hasOpeningBracket !== trimmedHost.endsWith("]")) throw new Error("Signal transport host has mismatched IPv6 brackets");
+	const normalizedHost = hasOpeningBracket ? trimmedHost.slice(1, -1) : trimmedHost;
+	if (!normalizedHost || /[\s/\\?#@]/.test(normalizedHost)) throw new Error("Signal transport host must be a hostname or IP address");
+	if (isIP(normalizedHost) === 0) {
+		const hostname = normalizedHost.endsWith(".") ? normalizedHost.slice(0, -1) : normalizedHost;
+		const labels = hostname.split(".");
+		if (hostname.length > 253 || labels.some((label) => !label || label.length > 63 || !/^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i.test(label))) throw new Error("Signal transport host must be a hostname or IP address");
+	}
+	return normalizedHost;
+}
+function buildSignalTransportHttpUrl(host, port) {
+	const normalizedHost = normalizeSignalTransportHost(host);
+	return normalizeSignalTransportUrl(`http://${normalizedHost.includes(":") ? `[${normalizedHost}]` : normalizedHost}:${port}`);
+}
+//#endregion
+//#region extensions/signal/src/transport-policy.ts
+const DEFAULT_SIGNAL_MANAGED_NATIVE_PORT = 8080;
+const DEFAULT_SIGNAL_MANAGED_NATIVE_HOST = "127.0.0.1";
+const SIGNAL_LOOPBACK_HOST_ALIASES = /* @__PURE__ */ new Set([
+	"localhost",
+	"127.0.0.1",
+	"::1"
+]);
+function normalizeSignalEndpointHost(hostname) {
+	const normalized = hostname.toLowerCase().replace(/^\[|\]$/g, "");
+	return normalized.endsWith(".") ? normalized.slice(0, -1) : normalized;
+}
+function isSignalLocalEndpointHost(hostname) {
+	return hostname === "localhost" || hostname.endsWith(".localhost") || hostname === "::1" || hostname === "::" || hostname === "0.0.0.0" || /^127(?:\.\d{1,3}){3}$/.test(hostname) || /^::ffff:(?:127(?:\.\d{1,3}){3}|7f[0-9a-f]{2}:[0-9a-f]{1,4})$/.test(hostname);
+}
+function isValidSignalManagedNativePort(value) {
+	return Number.isInteger(value) && Number(value) >= 1 && Number(value) <= 65535;
+}
+function allocateSignalManagedNativePort(params) {
+	if (params.preferredPort !== void 0) {
+		if (!isValidSignalManagedNativePort(params.preferredPort)) throw new Error("Signal managed native port must be an integer between 1 and 65535.");
+		if (!params.reservedPorts.has(params.preferredPort)) return params.preferredPort;
+	}
+	let port = DEFAULT_SIGNAL_MANAGED_NATIVE_PORT;
+	while (port <= 65535 && params.reservedPorts.has(port)) port += 1;
+	if (port > 65535) throw new Error("No available Signal managed native port remains.");
+	return port;
+}
+function resolveLocalSignalTransportPort(baseUrl) {
+	try {
+		const parsed = new URL(baseUrl);
+		if (!isSignalLocalEndpointHost(normalizeSignalEndpointHost(parsed.hostname))) return;
+		if (parsed.port) return Number.parseInt(parsed.port, 10);
+		return parsed.protocol === "https:" ? 443 : 80;
+	} catch {
+		return;
+	}
+}
+function isSignalManagedNativeConnectionUrlForBind(transport) {
+	if (transport.kind !== "managed-native" || !transport.url) return false;
+	const connectionUrl = new URL(transport.url);
+	if (connectionUrl.protocol !== "http:") return false;
+	if ((connectionUrl.port ? Number.parseInt(connectionUrl.port, 10) : 80) !== (transport.httpPort ?? 8080)) return false;
+	const connectionHost = normalizeSignalEndpointHost(connectionUrl.hostname);
+	const bindHost = normalizeSignalEndpointHost(transport.httpHost ?? "127.0.0.1");
+	if (connectionHost === bindHost) return true;
+	if (bindHost === "0.0.0.0") return connectionHost === "localhost" || /^127(?:\.\d{1,3}){3}$/.test(connectionHost);
+	if (bindHost === "::") return connectionHost === "localhost" || connectionHost === "::1";
+	return bindHost === "localhost" && SIGNAL_LOOPBACK_HOST_ALIASES.has(connectionHost) || connectionHost === "localhost" && SIGNAL_LOOPBACK_HOST_ALIASES.has(bindHost);
+}
+function assignSignalManagedNativePort(transport, httpPort) {
+	if (!isValidSignalManagedNativePort(httpPort)) throw new Error("Signal managed native port must be an integer between 1 and 65535.");
+	const connectionUrlValue = transport.url;
+	if (!connectionUrlValue || !isSignalManagedNativeConnectionUrlForBind(transport)) return {
+		...transport,
+		httpPort
+	};
+	const connectionUrl = new URL(connectionUrlValue);
+	connectionUrl.port = String(httpPort);
+	return {
+		...transport,
+		url: normalizeSignalTransportUrl(connectionUrl.toString()),
+		httpPort
+	};
+}
+//#endregion
+export { isSignalManagedNativeConnectionUrlForBind as a, buildSignalTransportHttpUrl as c, assignSignalManagedNativePort as i, normalizeSignalTransportHost as l, DEFAULT_SIGNAL_MANAGED_NATIVE_PORT as n, isValidSignalManagedNativePort as o, allocateSignalManagedNativePort as r, resolveLocalSignalTransportPort as s, DEFAULT_SIGNAL_MANAGED_NATIVE_HOST as t, normalizeSignalTransportUrl as u };

package/dist/transport-probes.runtime-CV6Qs0Og.js

@@ -0,0 +1,2 @@
+import { i as containerCheck, t as signalCheck } from "./client-BazXTH7O.js";
+export { containerCheck, signalCheck as nativeCheck };

package/node_modules/ws/lib/receiver.js

@@ -77,6 +77,7 @@ class Receiver extends Writable {
 
     this._totalPayloadLength = 0;
     this._messageLength = 0;
+    this._numFragments = 0;
     this._fragments = [];
 
     this._errored = false;
@@ -500,6 +501,19 @@ class Receiver extends Writable {
       return;
     }
 
+    if (this._maxFragments > 0 && ++this._numFragments > this._maxFragments) {
+      const error = this.createError(
+        RangeError,
+        'Too many message fragments',
+        false,
+        1008,
+        'WS_ERR_TOO_MANY_BUFFERED_PARTS'
+      );
+
+      cb(error);
+      return;
+    }
+
     if (this._compressed) {
       this._state = INFLATING;
       this.decompress(data, cb);
@@ -507,22 +521,6 @@ class Receiver extends Writable {
     }
 
     if (data.length) {
-      if (
-        this._maxFragments > 0 &&
-        this._fragments.length >= this._maxFragments
-      ) {
-        const error = this.createError(
-          RangeError,
-          'Too many message fragments',
-          false,
-          1008,
-          'WS_ERR_TOO_MANY_BUFFERED_PARTS'
-        );
-
-        cb(error);
-        return;
-      }
-
       //
       // This message is not compressed so its length is the sum of the payload
       // length of all fragments.
@@ -562,22 +560,6 @@ class Receiver extends Writable {
           return;
         }
 
-        if (
-          this._maxFragments > 0 &&
-          this._fragments.length >= this._maxFragments
-        ) {
-          const error = this.createError(
-            RangeError,
-            'Too many message fragments',
-            false,
-            1008,
-            'WS_ERR_TOO_MANY_BUFFERED_PARTS'
-          );
-
-          cb(error);
-          return;
-        }
-
         this._fragments.push(buf);
       }
 
@@ -604,6 +586,7 @@ class Receiver extends Writable {
     this._totalPayloadLength = 0;
     this._messageLength = 0;
     this._fragmented = 0;
+    this._numFragments = 0;
     this._fragments = [];
 
     if (this._opcode === 2) {

package/node_modules/ws/lib/websocket-server.js

@@ -43,9 +43,9 @@ class WebSocketServer extends EventEmitter {
    *     called
    * @param {Function} [options.handleProtocols] A hook to handle protocols
    * @param {String} [options.host] The hostname where to bind the server
-   * @param {Number} [options.maxBufferedChunks=1048576] The maximum number of
+   * @param {Number} [options.maxBufferedChunks=262144] The maximum number of
    *     buffered data chunks
-   * @param {Number} [options.maxFragments=131072] The maximum number of message
+   * @param {Number} [options.maxFragments=16384] The maximum number of message
    *     fragments
    * @param {Number} [options.maxPayload=104857600] The maximum allowed message
    *     size
@@ -69,8 +69,8 @@ class WebSocketServer extends EventEmitter {
     options = {
       allowSynchronousEvents: true,
       autoPong: true,
-      maxBufferedChunks: 1024 * 1024,
-      maxFragments: 128 * 1024,
+      maxBufferedChunks: 256 * 1024,
+      maxFragments: 16 * 1024,
       maxPayload: 100 * 1024 * 1024,
       skipUTF8Validation: false,
       perMessageDeflate: false,