@openclaw/signal 2026.7.2-beta.2 → 2026.7.2-beta.4

package/dist/{client-adapter-aEM0kGhC.js → client-yjbwtufN.js}

@@ -1,5 +1,5 @@
 import { detectMime, parseMediaContentLength } from "openclaw/plugin-sdk/media-runtime";
-import { asDateTimestampMs, parseStrictNonNegativeInteger, resolveExpiresAtMsFromDurationMs, resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
+import { parseStrictNonNegativeInteger, resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
 import nodePath from "node:path";
 import { resolveFetch } from "openclaw/plugin-sdk/fetch-runtime";
 import { readResponseTextPrefix, readResponseWithLimit } from "openclaw/plugin-sdk/response-limit-runtime";
@@ -18,7 +18,7 @@ import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 * This is a separate implementation from client.ts (native signal-cli)
 * to keep the two modes cleanly isolated.
 */
-const DEFAULT_TIMEOUT_MS$2 = 1e4;
+const DEFAULT_TIMEOUT_MS$1 = 1e4;
 const DEFAULT_ATTACHMENT_RESPONSE_MAX_BYTES = 1048576;
 const SIGNAL_REST_ERROR_RESPONSE_MAX_BYTES = 16 * 1024;
 const SIGNAL_REST_SUCCESS_RESPONSE_MAX_BYTES = 16 * 1024 * 1024;
@@ -42,21 +42,43 @@ function normalizeBaseUrl$1(url) {
 	const pathname = parsed.pathname === "/" ? "" : parsed.pathname.replace(/\/+$/, "");
 	return `${parsed.protocol}//${parsed.host}${pathname}`;
 }
-async function fetchWithTimeout(url, init, timeoutMs) {
-	const fetchImpl = resolveFetch();
-	if (!fetchImpl) throw new Error("fetch is not available");
-	const safeTimeoutMs = resolveTimerTimeoutMs(timeoutMs, DEFAULT_TIMEOUT_MS$2);
+var SignalRestTimeoutError = class extends Error {
+	constructor() {
+		super("Signal REST request timed out");
+		this.name = "SignalRestTimeoutError";
+	}
+};
+function signalRestRequestTimeoutError() {
+	return new SignalRestTimeoutError();
+}
+/** Keep one absolute deadline across headers and every bounded body reader. */
+async function withSignalRestDeadline(timeoutMs, run) {
+	const safeTimeoutMs = resolveTimerTimeoutMs(timeoutMs, DEFAULT_TIMEOUT_MS$1);
+	const deadlineAtMs = Date.now() + safeTimeoutMs;
 	const controller = new AbortController();
-	const timer = setTimeout(() => controller.abort(), safeTimeoutMs);
+	const timer = setTimeout(() => controller.abort(signalRestRequestTimeoutError()), safeTimeoutMs);
+	timer.unref?.();
 	try {
-		return await fetchImpl(url, {
-			...init,
-			signal: controller.signal
+		return await run({
+			signal: controller.signal,
+			timeoutMs: () => {
+				const remainingMs = deadlineAtMs - Date.now();
+				if (remainingMs <= 0) throw signalRestRequestTimeoutError();
+				return Math.max(1, Math.min(safeTimeoutMs, remainingMs));
+			}
 		});
 	} finally {
 		clearTimeout(timer);
 	}
 }
+async function fetchWithTimeout(url, init, timeoutMs) {
+	const fetchImpl = resolveFetch();
+	if (!fetchImpl) throw new Error("fetch is not available");
+	return await withSignalRestDeadline(timeoutMs, async ({ signal }) => fetchImpl(url, {
+		...init,
+		signal
+	}));
+}
 function normalizeMaxResponseBytes(value) {
 	if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) return DEFAULT_ATTACHMENT_RESPONSE_MAX_BYTES;
 	return Math.floor(value);
@@ -70,26 +92,32 @@ function signalRestIdleTimeoutError({ chunkTimeoutMs }) {
 function signalAttachmentIdleTimeoutError({ chunkTimeoutMs }) {
 	return /* @__PURE__ */ new Error(`Signal REST attachment response body stalled after ${chunkTimeoutMs}ms`);
 }
-async function readSignalRestText(res, bodyIdleTimeoutMs) {
+async function readSignalRestText(res, bodyIdleTimeoutMs, bodyTimeoutMs) {
 	const bytes = await readResponseWithLimit(res, SIGNAL_REST_SUCCESS_RESPONSE_MAX_BYTES, {
 		chunkTimeoutMs: bodyIdleTimeoutMs,
 		onIdleTimeout: signalRestIdleTimeoutError,
+		timeoutMs: bodyTimeoutMs,
+		onTimeout: signalRestRequestTimeoutError,
 		onOverflow: ({ maxBytes }) => /* @__PURE__ */ new Error(`Signal REST: text response exceeds ${maxBytes} bytes`)
 	});
 	return new TextDecoder().decode(bytes);
 }
-async function readSignalRestErrorText(res, bodyIdleTimeoutMs) {
+async function readSignalRestErrorText(res, bodyIdleTimeoutMs, bodyTimeoutMs) {
 	return (await readResponseTextPrefix(res, SIGNAL_REST_ERROR_RESPONSE_MAX_BYTES, {
 		chunkTimeoutMs: bodyIdleTimeoutMs,
-		onIdleTimeout: signalRestIdleTimeoutError
+		onIdleTimeout: signalRestIdleTimeoutError,
+		timeoutMs: bodyTimeoutMs,
+		onTimeout: signalRestRequestTimeoutError
 	})).text;
 }
-async function readCappedResponseBuffer(res, maxResponseBytes, bodyIdleTimeoutMs) {
+async function readCappedResponseBuffer(res, maxResponseBytes, bodyIdleTimeoutMs, bodyTimeoutMs) {
 	const contentLength = readContentLength(res);
 	if (contentLength !== void 0 && contentLength > maxResponseBytes) throw new Error("Signal REST attachment exceeded size limit");
 	return await readResponseWithLimit(res, maxResponseBytes, {
 		chunkTimeoutMs: bodyIdleTimeoutMs,
 		onIdleTimeout: signalAttachmentIdleTimeoutError,
+		timeoutMs: bodyTimeoutMs,
+		onTimeout: signalRestRequestTimeoutError,
 		onOverflow: () => /* @__PURE__ */ new Error("Signal REST attachment exceeded size limit")
 	});
 }
@@ -99,7 +127,7 @@ async function releaseUnreadResponseBody(res) {
 /**
 * Check if bbernhard container REST API is available.
 */
-async function containerCheck(baseUrl, timeoutMs = DEFAULT_TIMEOUT_MS$2, account) {
+async function containerCheck(baseUrl, timeoutMs = DEFAULT_TIMEOUT_MS$1, account) {
 	const normalized = normalizeBaseUrl$1(baseUrl);
 	let res;
 	try {
@@ -129,7 +157,7 @@ async function containerCheck(baseUrl, timeoutMs = DEFAULT_TIMEOUT_MS$2, account
 function containerReceiveCheck(normalizedBaseUrl, account, timeoutMs) {
 	const wsUrl = `${normalizedBaseUrl.replace(/^http/, "ws")}/v1/receive/${encodeURIComponent(account)}`;
 	return new Promise((resolve) => {
-		const safeTimeoutMs = resolveTimerTimeoutMs(timeoutMs, DEFAULT_TIMEOUT_MS$2);
+		const safeTimeoutMs = resolveTimerTimeoutMs(timeoutMs, DEFAULT_TIMEOUT_MS$1);
 		let settled = false;
 		let ws;
 		const timer = setTimeout(() => {
@@ -200,37 +228,57 @@ async function containerRestRequest(endpoint, opts, method = "GET", body) {
 		headers: { "Content-Type": "application/json" }
 	};
 	if (body) init.body = JSON.stringify(body);
-	const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS$2;
-	const bodyIdleTimeoutMs = resolveTimerTimeoutMs(timeoutMs, DEFAULT_TIMEOUT_MS$2);
-	const res = await fetchWithTimeout(url, init, timeoutMs);
-	if (res.status === 204) return;
-	if (!res.ok) {
-		const errorText = await readSignalRestErrorText(res, bodyIdleTimeoutMs).catch(() => "");
-		throw new Error(`Signal REST ${res.status}: ${errorText || res.statusText}`);
-	}
-	const text = await readSignalRestText(res, bodyIdleTimeoutMs);
-	if (!text) return;
-	try {
-		return JSON.parse(text);
-	} catch {
-		throw new Error("Signal REST returned malformed JSON");
-	}
+	const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS$1;
+	const bodyIdleTimeoutMs = resolveTimerTimeoutMs(timeoutMs, DEFAULT_TIMEOUT_MS$1);
+	const fetchImpl = resolveFetch();
+	if (!fetchImpl) throw new Error("fetch is not available");
+	return await withSignalRestDeadline(timeoutMs, async ({ signal, timeoutMs: bodyTimeoutMs }) => {
+		const res = await fetchImpl(url, {
+			...init,
+			signal
+		});
+		if (res.status === 204) return;
+		if (!res.ok) {
+			let errorText = "";
+			try {
+				errorText = await readSignalRestErrorText(res, bodyIdleTimeoutMs, bodyTimeoutMs);
+			} catch (error) {
+				if (error instanceof SignalRestTimeoutError) throw error;
+			}
+			throw new Error(`Signal REST ${res.status}: ${errorText || res.statusText}`);
+		}
+		const text = await readSignalRestText(res, bodyIdleTimeoutMs, bodyTimeoutMs);
+		if (!text) return;
+		try {
+			return JSON.parse(text);
+		} catch {
+			throw new Error("Signal REST returned malformed JSON");
+		}
+	});
 }
 /**
 * Fetch attachment binary from bbernhard container.
 */
 async function containerFetchAttachment(attachmentId, opts) {
 	const url = `${normalizeBaseUrl$1(opts.baseUrl)}/v1/attachments/${encodeURIComponent(attachmentId)}`;
-	let res;
-	try {
-		const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS$2;
-		const bodyIdleTimeoutMs = resolveTimerTimeoutMs(timeoutMs, DEFAULT_TIMEOUT_MS$2);
-		res = await fetchWithTimeout(url, { method: "GET" }, timeoutMs);
-		if (!res.ok) return null;
-		return await readCappedResponseBuffer(res, normalizeMaxResponseBytes(opts.maxResponseBytes), bodyIdleTimeoutMs);
-	} finally {
-		await releaseUnreadResponseBody(res);
-	}
+	const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS$1;
+	const bodyIdleTimeoutMs = resolveTimerTimeoutMs(timeoutMs, DEFAULT_TIMEOUT_MS$1);
+	const fetchImpl = resolveFetch();
+	if (!fetchImpl) throw new Error("fetch is not available");
+	return await withSignalRestDeadline(timeoutMs, async ({ signal, timeoutMs: bodyTimeoutMs }) => {
+		let res;
+		try {
+			const fetched = await fetchImpl(url, {
+				method: "GET",
+				signal
+			});
+			res = fetched;
+			if (!fetched.ok) return null;
+			return await readCappedResponseBuffer(fetched, normalizeMaxResponseBytes(opts.maxResponseBytes), bodyIdleTimeoutMs, bodyTimeoutMs);
+		} finally {
+			await releaseUnreadResponseBody(res);
+		}
+	});
 }
 /**
 * Stream messages using WebSocket from bbernhard container.
@@ -246,16 +294,27 @@ async function streamContainerEvents(params) {
 	log(`[signal-ws] connecting to ${redactedWsUrl}`);
 	return new Promise((resolve, reject) => {
 		let ws;
-		let resolved = false;
+		let settled = false;
+		let eventChain = Promise.resolve();
 		let abortHandler;
 		const cleanup = () => {
-			if (resolved) return;
-			resolved = true;
 			if (abortHandler) {
 				params.abortSignal?.removeEventListener("abort", abortHandler);
 				abortHandler = void 0;
 			}
 		};
+		const resolveOnce = () => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			resolve();
+		};
+		const rejectOnce = (error) => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			reject(toLintErrorObject$1(error, "Signal WebSocket receive handler failed"));
+		};
 		try {
 			ws = new WebSocket(wsUrl, {
 				maxPayload: WS_MAX_PAYLOAD,
@@ -270,10 +329,20 @@ async function streamContainerEvents(params) {
 			log("[signal-ws] connected");
 		});
 		ws.on("message", (data) => {
+			if (settled) return;
 			try {
 				const text = data.toString();
 				const envelope = JSON.parse(text);
-				if (envelope) params.onEvent(envelope);
+				if (envelope) {
+					eventChain = eventChain.then(async () => {
+						await params.onEvent(envelope);
+					});
+					eventChain.catch((err) => {
+						logError(`[signal-ws] receive handler failed: ${err instanceof Error ? err.message : String(err)}`);
+						rejectOnce(err);
+						ws.close();
+					});
+				}
 			} catch (err) {
 				logError(`[signal-ws] parse error: ${err instanceof Error ? err.message : String(err)}`);
 			}
@@ -284,8 +353,7 @@ async function streamContainerEvents(params) {
 		ws.on("close", (code, reason) => {
 			const reasonStr = reason?.toString() || "no reason";
 			log(`[signal-ws] closed (code=${code}, reason=${reasonStr})`);
-			cleanup();
-			resolve();
+			eventChain.then(resolveOnce, rejectOnce);
 		});
 		ws.on("ping", () => {
 			log("[signal-ws] ping received");
@@ -296,9 +364,8 @@ async function streamContainerEvents(params) {
 		if (params.abortSignal) {
 			abortHandler = () => {
 				log("[signal-ws] aborted, closing connection");
-				cleanup();
 				ws.close();
-				resolve();
+				resolveOnce();
 			};
 			params.abortSignal.addEventListener("abort", abortHandler, { once: true });
 		}
@@ -576,7 +643,7 @@ function toLintErrorObject$1(value, fallbackMessage) {
 }
 //#endregion
 //#region extensions/signal/src/client.ts
-const DEFAULT_TIMEOUT_MS$1 = 1e4;
+const DEFAULT_TIMEOUT_MS = 1e4;
 const DEFAULT_SIGNAL_HTTP_RESPONSE_MAX_BYTES = 1048576;
 const MAX_SIGNAL_SSE_BUFFER_BYTES = 1048576;
 const MAX_SIGNAL_SSE_EVENT_DATA_BYTES = 1048576;
@@ -597,7 +664,11 @@ function parseSignalBaseUrl(url) {
 	return parsed;
 }
 function resolveSignalEndpointUrl(baseUrl, pathname) {
-	return new URL(pathname, parseSignalBaseUrl(baseUrl));
+	const parsed = parseSignalBaseUrl(baseUrl);
+	parsed.pathname = `${parsed.pathname.endsWith("/") ? parsed.pathname : `${parsed.pathname}/`}${pathname.replace(/^\/+/, "")}`;
+	parsed.search = "";
+	parsed.hash = "";
+	return parsed;
 }
 function parseSignalRpcResponse(text, status) {
 	let parsed;
@@ -621,11 +692,11 @@ function normalizeSignalHttpResponseMaxBytes(value) {
 }
 function normalizeSignalSseTimeoutMs(timeoutMs) {
 	if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) return null;
-	return resolveTimerTimeoutMs(timeoutMs, DEFAULT_TIMEOUT_MS$1);
+	return resolveTimerTimeoutMs(timeoutMs, DEFAULT_TIMEOUT_MS);
 }
 function requestSignalHttpText(url, options) {
 	assertSignalHttpProtocol(url, "HTTP");
-	const timeoutMs = resolveTimerTimeoutMs(options.timeoutMs, DEFAULT_TIMEOUT_MS$1);
+	const timeoutMs = resolveTimerTimeoutMs(options.timeoutMs, DEFAULT_TIMEOUT_MS);
 	const client = url.protocol === "https:" ? https : http;
 	return new Promise((resolve, reject) => {
 		let settled = false;
@@ -685,7 +756,7 @@ function requestSignalHttpText(url, options) {
 		request.end();
 	});
 }
-async function signalRpcRequest$1(method, params, opts) {
+async function signalRpcRequest(method, params, opts) {
 	const id = generateSecureUuid();
 	const body = JSON.stringify({
 		jsonrpc: "2.0",
@@ -700,7 +771,7 @@ async function signalRpcRequest$1(method, params, opts) {
 			"Content-Length": String(Buffer$1.byteLength(body))
 		},
 		body,
-		timeoutMs: opts.timeoutMs ?? DEFAULT_TIMEOUT_MS$1,
+		timeoutMs: opts.timeoutMs ?? DEFAULT_TIMEOUT_MS,
 		maxResponseBytes: opts.maxResponseBytes
 	});
 	if (res.status === 201) return;
@@ -713,7 +784,7 @@ async function signalRpcRequest$1(method, params, opts) {
 	}
 	return parsed.result;
 }
-async function signalCheck$1(baseUrl, timeoutMs = DEFAULT_TIMEOUT_MS$1) {
+async function signalCheck(baseUrl, timeoutMs = DEFAULT_TIMEOUT_MS) {
 	try {
 		const res = await requestSignalHttpText(resolveSignalEndpointUrl(baseUrl, "/api/v1/check"), {
 			method: "GET",
@@ -737,7 +808,7 @@ async function signalCheck$1(baseUrl, timeoutMs = DEFAULT_TIMEOUT_MS$1) {
 		};
 	}
 }
-function openSignalEventStream(url, abortSignal, timeoutMs = DEFAULT_TIMEOUT_MS$1) {
+function openSignalEventStream(url, abortSignal, timeoutMs = DEFAULT_TIMEOUT_MS) {
 	assertSignalHttpProtocol(url, "SSE");
 	if (abortSignal?.aborted) throw createSignalSseAbortError();
 	const client = url.protocol === "https:" ? https : http;
@@ -796,18 +867,18 @@ function openSignalEventStream(url, abortSignal, timeoutMs = DEFAULT_TIMEOUT_MS$
 		request.end();
 	});
 }
-async function streamSignalEvents$1(params) {
+async function streamSignalEvents(params) {
 	const url = resolveSignalEndpointUrl(params.baseUrl, "/api/v1/events");
 	if (params.account) url.searchParams.set("account", params.account);
-	const { response, cleanup } = await openSignalEventStream(url, params.abortSignal, params.timeoutMs ?? DEFAULT_TIMEOUT_MS$1);
+	const { response, cleanup } = await openSignalEventStream(url, params.abortSignal, params.timeoutMs ?? DEFAULT_TIMEOUT_MS);
 	const decoder = new TextDecoder();
 	let buffer = "";
 	let bufferedBytes = 0;
 	let currentEvent = {};
 	let currentEventDataBytes = 0;
-	const flushEvent = () => {
+	const flushEvent = async () => {
 		if (!currentEvent.data && !currentEvent.event && !currentEvent.id) return;
-		params.onEvent({
+		await params.onEvent({
 			event: currentEvent.event,
 			data: currentEvent.data,
 			id: currentEvent.id
@@ -815,9 +886,9 @@ async function streamSignalEvents$1(params) {
 		currentEvent = {};
 		currentEventDataBytes = 0;
 	};
-	const processLine = (line) => {
+	const processLine = async (line) => {
 		if (line === "") {
-			flushEvent();
+			await flushEvent();
 			return;
 		}
 		if (line.startsWith(":")) return;
@@ -834,13 +905,13 @@ async function streamSignalEvents$1(params) {
 			currentEvent.data = currentEvent.data ? `${currentEvent.data}${segment}` : segment;
 		} else if (field === "id") currentEvent.id = value;
 	};
-	const drainCompleteLines = () => {
+	const drainCompleteLines = async () => {
 		let lineEnd = buffer.indexOf("\n");
 		while (lineEnd !== -1) {
 			let line = buffer.slice(0, lineEnd);
 			buffer = buffer.slice(lineEnd + 1);
 			if (line.endsWith("\r")) line = line.slice(0, -1);
-			processLine(line);
+			await processLine(line);
 			lineEnd = buffer.indexOf("\n");
 		}
 		bufferedBytes = Buffer$1.byteLength(buffer, "utf8");
@@ -851,7 +922,7 @@ async function streamSignalEvents$1(params) {
 			bufferedBytes += value.byteLength;
 			if (bufferedBytes > MAX_SIGNAL_SSE_BUFFER_BYTES) throw new Error("Signal SSE buffer exceeded size limit");
 			buffer += decoder.decode(value, { stream: true });
-			drainCompleteLines();
+			await drainCompleteLines();
 		}
 		const tail = decoder.decode();
 		if (tail) {
@@ -859,11 +930,11 @@ async function streamSignalEvents$1(params) {
 			bufferedBytes = Buffer$1.byteLength(buffer, "utf8");
 		}
 		if (bufferedBytes > MAX_SIGNAL_SSE_BUFFER_BYTES) throw new Error("Signal SSE buffer exceeded size limit");
-		drainCompleteLines();
+		await drainCompleteLines();
 	} finally {
 		cleanup();
 	}
-	flushEvent();
+	await flushEvent();
 }
 function toLintErrorObject(value, fallbackMessage) {
 	if (value instanceof Error) return value;
@@ -873,145 +944,4 @@ function toLintErrorObject(value, fallbackMessage) {
 	return error;
 }
 //#endregion
-//#region extensions/signal/src/client-adapter.ts
-/**
-* Signal client adapter - unified interface for both native signal-cli and bbernhard container.
-*
-* This adapter provides a single API that routes to the appropriate implementation
-* based on the configured API mode. Exports mirror client.ts names so consumers
-* only need to change their import path.
-*/
-const DEFAULT_TIMEOUT_MS = 1e4;
-const MODE_CACHE_TTL_MS = 3e4;
-const NATIVE_PREFERENCE_GRACE_MS = 50;
-const detectedModeCache = /* @__PURE__ */ new Map();
-function resolveConfiguredApiMode(configured) {
-	if (configured === "native" || configured === "container") return configured;
-	return "auto";
-}
-function formatErrorMessage$1(error) {
-	return error instanceof Error ? error.message : String(error);
-}
-function resolveAutoProbeTimeoutMs(timeoutMs) {
-	return typeof timeoutMs === "number" && Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : DEFAULT_TIMEOUT_MS;
-}
-function waitForNativePreferenceGrace(nativeResultPromise) {
-	return new Promise((resolve) => {
-		const timer = setTimeout(() => resolve({ ok: false }), NATIVE_PREFERENCE_GRACE_MS);
-		timer.unref?.();
-		nativeResultPromise.then((result) => {
-			clearTimeout(timer);
-			resolve(result);
-		});
-	});
-}
-async function resolveAutoApiMode(baseUrl, timeoutMs = DEFAULT_TIMEOUT_MS, options = {}) {
-	const rawNow = Date.now();
-	const now = asDateTimestampMs(rawNow);
-	const cached = detectedModeCache.get(baseUrl);
-	if (cached) if (now !== void 0 && cached.expiresAt > now) {
-		if (cached.mode !== "container" || !options.requireContainerReceive || Boolean(options.account?.trim()) && cached.receiveAccount === options.account?.trim()) return cached.mode;
-	} else detectedModeCache.delete(baseUrl);
-	const detected = await detectSignalApiMode(baseUrl, timeoutMs, options);
-	const expiresAt = resolveExpiresAtMsFromDurationMs(MODE_CACHE_TTL_MS, { nowMs: rawNow });
-	if (expiresAt !== void 0) detectedModeCache.set(baseUrl, {
-		mode: detected,
-		expiresAt,
-		...detected === "container" && options.requireContainerReceive && options.account ? { receiveAccount: options.account } : {}
-	});
-	return detected;
-}
-async function resolveApiModeForOperation(params) {
-	const configured = resolveConfiguredApiMode(params.apiMode);
-	if (configured === "native" || configured === "container") return configured;
-	return resolveAutoApiMode(params.baseUrl, params.timeoutMs ?? DEFAULT_TIMEOUT_MS, {
-		account: params.account,
-		requireContainerReceive: params.requireContainerReceive
-	});
-}
-/**
-* Detect which Signal API mode is available by probing endpoints.
-* Native wins when both APIs are healthy because it preserves the richer JSON-RPC contract.
-*/
-async function detectSignalApiMode(baseUrl, timeoutMs = DEFAULT_TIMEOUT_MS, options = {}) {
-	const containerAccount = options.requireContainerReceive ? options.account?.trim() : void 0;
-	const nativeResultPromise = signalCheck$1(baseUrl, timeoutMs).catch(() => ({ ok: false }));
-	const containerResultPromise = containerAccount ? containerCheck(baseUrl, timeoutMs, containerAccount).catch(() => ({ ok: false })) : options.requireContainerReceive ? Promise.resolve({ ok: false }) : containerCheck(baseUrl, timeoutMs).catch(() => ({ ok: false }));
-	const nativeHealthyPromise = nativeResultPromise.then((result) => {
-		if (result.ok) return "native";
-		throw new Error("native not ok");
-	});
-	const containerHealthyPromise = containerResultPromise.then((result) => {
-		if (result.ok) return "container";
-		throw new Error("container not ok");
-	});
-	try {
-		if (await Promise.any([nativeHealthyPromise, containerHealthyPromise]) === "native") return "native";
-		return (await waitForNativePreferenceGrace(nativeResultPromise)).ok ? "native" : "container";
-	} catch {
-		throw new Error(`Signal API not reachable at ${baseUrl}`);
-	}
-}
-/**
-* Drop-in replacement for native signalRpcRequest.
-* Routes to native JSON-RPC or container REST based on config.
-*/
-async function signalRpcRequest(method, params, opts) {
-	if (await resolveApiModeForOperation({
-		baseUrl: opts.baseUrl,
-		accountId: opts.accountId,
-		account: typeof params?.account === "string" ? params.account : void 0,
-		timeoutMs: opts.timeoutMs,
-		apiMode: opts.apiMode
-	}) === "native") return signalRpcRequest$1(method, params, opts);
-	return containerRpcRequest(method, params, opts);
-}
-/**
-* Drop-in replacement for native signalCheck.
-*/
-async function signalCheck(baseUrl, timeoutMs = DEFAULT_TIMEOUT_MS, options = {}) {
-	const configured = resolveConfiguredApiMode(options.apiMode);
-	const mode = configured === "auto" ? await resolveAutoApiMode(baseUrl, timeoutMs).catch((error) => {
-		return {
-			ok: false,
-			status: null,
-			error: formatErrorMessage$1(error)
-		};
-	}) : configured;
-	if (typeof mode !== "string") return mode;
-	if (mode === "container") return containerCheck(baseUrl, timeoutMs);
-	return signalCheck$1(baseUrl, timeoutMs);
-}
-/**
-* Drop-in replacement for native streamSignalEvents.
-* Container mode uses WebSocket; native uses SSE.
-*/
-async function streamSignalEvents(params) {
-	if (await resolveApiModeForOperation({
-		baseUrl: params.baseUrl,
-		accountId: params.accountId,
-		account: params.account,
-		requireContainerReceive: true,
-		timeoutMs: resolveAutoProbeTimeoutMs(params.timeoutMs),
-		apiMode: params.apiMode
-	}) === "container") return streamContainerEvents({
-		baseUrl: params.baseUrl,
-		account: params.account,
-		abortSignal: params.abortSignal,
-		timeoutMs: params.timeoutMs,
-		onEvent: (event) => params.onEvent({
-			event: "receive",
-			data: JSON.stringify(event)
-		}),
-		logger: params.logger
-	});
-	return streamSignalEvents$1({
-		baseUrl: params.baseUrl,
-		account: params.account,
-		abortSignal: params.abortSignal,
-		timeoutMs: params.timeoutMs,
-		onEvent: (event) => params.onEvent(event)
-	});
-}
-//#endregion
-export { signalRpcRequest as n, streamSignalEvents as r, signalCheck as t };
+export { containerRpcRequest as a, containerCheck as i, signalRpcRequest as n, streamContainerEvents as o, streamSignalEvents as r, signalCheck as t };