@camera.ui/transport 0.0.1

package/dist/race.d.ts

@@ -0,0 +1,23 @@
+import { Endpoint, EndpointMode } from './core/types.js';
+export type TimeoutByModeFn = (mode: EndpointMode) => number;
+export declare const DEFAULT_RACE_TIMEOUT_BY_MODE: Readonly<Record<EndpointMode, number>>;
+export interface RaceCandidate<T> {
+    readonly endpoint: Endpoint;
+    readonly run: (signal: AbortSignal) => Promise<T>;
+}
+export interface RaceFirstOptions {
+    readonly timeoutByMode?: TimeoutByModeFn;
+    readonly shortCircuit?: (err: unknown) => boolean;
+    readonly parentSignal?: AbortSignal;
+}
+export interface RaceFirstResult<T> {
+    readonly endpoint: Endpoint;
+    readonly value: T;
+}
+export declare class RaceFirstError extends Error {
+    readonly endpoint: Endpoint;
+    readonly cause: unknown;
+    readonly kind: 'short-circuit' | 'all-failed' | 'aborted';
+    constructor(message: string, endpoint: Endpoint, cause: unknown, kind: RaceFirstError['kind']);
+}
+export declare function raceFirst<T>(candidates: readonly RaceCandidate<T>[], options?: RaceFirstOptions): Promise<RaceFirstResult<T>>;

package/dist/testing/fakeTransport.d.ts

@@ -0,0 +1,24 @@
+import { ConnectionTarget, TransportSpec, TransportStatus } from '../core/types.js';
+import { Transport, TransportEvent, TransportEventHandler, Unsubscribe } from '../transports/contract.js';
+export interface FakeTransportOptions {
+    readonly spec: TransportSpec;
+    readonly applyDelayMs?: number;
+}
+export declare class FakeTransport implements Transport {
+    readonly spec: TransportSpec;
+    readonly applyCalls: (ConnectionTarget | null)[];
+    private readonly emitter;
+    private readonly applyDelayMs;
+    private currentTarget;
+    private currentStatus;
+    private disposed;
+    constructor(options: FakeTransportOptions);
+    apply(target: ConnectionTarget | null): Promise<void>;
+    health(): TransportStatus;
+    on<E extends TransportEvent>(event: E, handler: TransportEventHandler<E>): Unsubscribe;
+    dispose(): Promise<void>;
+    emitDown(reason: string): void;
+    emitUp(): void;
+    emitAuthError(status?: number): void;
+    get target(): ConnectionTarget | null;
+}

package/dist/testing/index.d.ts

@@ -0,0 +1,2 @@
+export { FakeTransport } from './fakeTransport.js';
+export type { FakeTransportOptions } from './fakeTransport.js';

package/dist/testing.js

@@ -0,0 +1,53 @@
+import { t as TransportEmitter } from "./contract-d-0gfY8v.js";
+//#region src/testing/fakeTransport.ts
+var FakeTransport = class {
+	spec;
+	applyCalls = [];
+	emitter = new TransportEmitter();
+	applyDelayMs;
+	currentTarget = null;
+	currentStatus = { up: false };
+	disposed = false;
+	constructor(options) {
+		this.spec = options.spec;
+		this.applyDelayMs = options.applyDelayMs ?? 0;
+	}
+	async apply(target) {
+		if (this.disposed) throw new Error("disposed");
+		this.applyCalls.push(target);
+		if (this.applyDelayMs > 0) await new Promise((resolve) => setTimeout(resolve, this.applyDelayMs));
+		this.currentTarget = target;
+		this.currentStatus = target ? { up: true } : { up: false };
+		if (target) this.emitter.emit("up", void 0);
+		else this.emitter.emit("down", { reason: "detached" });
+	}
+	health() {
+		return this.currentStatus;
+	}
+	on(event, handler) {
+		return this.emitter.on(event, handler);
+	}
+	async dispose() {
+		this.disposed = true;
+		this.emitter.clear();
+	}
+	emitDown(reason) {
+		this.currentStatus = {
+			up: false,
+			lastError: reason
+		};
+		this.emitter.emit("down", { reason });
+	}
+	emitUp() {
+		this.currentStatus = { up: true };
+		this.emitter.emit("up", void 0);
+	}
+	emitAuthError(status) {
+		this.emitter.emit("auth-error", { status });
+	}
+	get target() {
+		return this.currentTarget;
+	}
+};
+//#endregion
+export { FakeTransport };

package/dist/transports/contract.d.ts

@@ -0,0 +1,29 @@
+import { ConnectionTarget, TransportSpec, TransportStatus } from '../core/types.js';
+export type TransportEvent = 'up' | 'down' | 'auth-error';
+export type TransportEventPayload<E extends TransportEvent> = E extends 'down' ? {
+    readonly reason: string;
+} : E extends 'auth-error' ? {
+    readonly status?: number;
+    readonly message?: string;
+} : void;
+export type TransportEventHandler<E extends TransportEvent> = (payload: TransportEventPayload<E>) => void;
+export type Unsubscribe = () => void;
+export interface Transport {
+    readonly spec: TransportSpec;
+    apply(target: ConnectionTarget | null): Promise<void>;
+    health(): TransportStatus;
+    on<E extends TransportEvent>(event: E, handler: TransportEventHandler<E>): Unsubscribe;
+    dispose(): Promise<void>;
+}
+export interface PerResourceTransport<R = unknown, S = unknown> extends Transport {
+    open(spec: S): R;
+}
+export declare function isSameTarget(a: ConnectionTarget | null, b: ConnectionTarget | null): boolean;
+export declare function isEndpointChange(a: ConnectionTarget | null, b: ConnectionTarget | null): boolean;
+export declare function isTokenOnlyChange(a: ConnectionTarget | null, b: ConnectionTarget | null): boolean;
+export declare class TransportEmitter {
+    private readonly listeners;
+    on<E extends TransportEvent>(event: E, handler: TransportEventHandler<E>): Unsubscribe;
+    emit<E extends TransportEvent>(event: E, payload: TransportEventPayload<E>): void;
+    clear(): void;
+}

package/dist/transports/http.d.ts

@@ -0,0 +1,14 @@
+import { AxiosInstance, AxiosRequestConfig } from 'axios';
+import { TransportSpec } from '../core/types.js';
+import { Transport } from './contract.js';
+export interface HttpTransportOptions {
+    readonly apiPrefix?: string;
+    readonly timeoutMs?: number;
+    readonly targetWaitMs?: number;
+    readonly spec?: Partial<TransportSpec>;
+}
+export interface HttpTransport extends Transport {
+    readonly client: AxiosInstance;
+}
+export declare function createHttpTransport(options?: HttpTransportOptions): HttpTransport;
+export type { AxiosInstance, AxiosRequestConfig };

package/dist/transports/http.js

@@ -0,0 +1,131 @@
+import { n as isEndpointChange, r as isSameTarget, t as TransportEmitter } from "../contract-d-0gfY8v.js";
+import axios from "axios";
+//#region src/transports/http.ts
+var HTTP_SPEC = {
+	id: "http",
+	kind: "request",
+	phaseGating: false
+};
+function createHttpTransport(options = {}) {
+	const spec = {
+		...HTTP_SPEC,
+		...options.spec
+	};
+	const apiPrefix = options.apiPrefix ?? "/api";
+	const targetWaitMs = options.targetWaitMs ?? 15e3;
+	const emitter = new TransportEmitter();
+	let currentTarget = null;
+	let status = { up: false };
+	let disposed = false;
+	const targetWaiters = /* @__PURE__ */ new Set();
+	const client = axios.create({ timeout: options.timeoutMs ?? 3e4 });
+	function waitForTarget(signal) {
+		if (currentTarget) return Promise.resolve();
+		return new Promise((resolve, reject) => {
+			const waiter = {
+				resolve: () => {
+					cleanup();
+					resolve();
+				},
+				reject: (reason) => {
+					cleanup();
+					reject(reason);
+				}
+			};
+			const timer = setTimeout(() => waiter.reject(new axios.Cancel("http-transport: no target")), targetWaitMs);
+			const onAbort = () => waiter.reject(new axios.Cancel("http-transport: aborted"));
+			function cleanup() {
+				clearTimeout(timer);
+				targetWaiters.delete(waiter);
+				signal?.removeEventListener?.("abort", onAbort);
+			}
+			if (signal?.aborted) {
+				waiter.reject(new axios.Cancel("http-transport: aborted"));
+				return;
+			}
+			signal?.addEventListener?.("abort", onAbort);
+			targetWaiters.add(waiter);
+		});
+	}
+	function flushTargetWaiters() {
+		if (!currentTarget) return;
+		for (const waiter of [...targetWaiters]) waiter.resolve();
+	}
+	client.interceptors.request.use(async (config) => {
+		if (!currentTarget) await waitForTarget(config.signal);
+		const target = currentTarget;
+		if (!target) throw new axios.Cancel("http-transport: no target");
+		if (!config.baseURL) config.baseURL = `${target.endpoint.url}${apiPrefix}`;
+		config.headers.set("Authorization", `Bearer ${target.tokens.access}`);
+		if (target.tokens.proxySession) config.headers.set("X-Proxy-Session", target.tokens.proxySession);
+		return config;
+	});
+	client.interceptors.response.use((response) => {
+		if (!status.up) {
+			status = { up: true };
+			emitter.emit("up", void 0);
+		}
+		return response;
+	}, (error) => {
+		if (axios.isCancel(error)) return Promise.reject(error);
+		if (!error.response) {
+			markDown(error.message ?? "network");
+			return Promise.reject(error);
+		}
+		if (error.response.status === 401) emitter.emit("auth-error", {
+			status: 401,
+			message: extractMessage(error)
+		});
+		return Promise.reject(error);
+	});
+	function markDown(reason) {
+		if (status.up || status.lastError !== reason) {
+			status = {
+				up: false,
+				lastError: reason
+			};
+			emitter.emit("down", { reason });
+		}
+	}
+	async function apply(target) {
+		if (disposed) throw new Error("http-transport disposed");
+		if (isSameTarget(currentTarget, target)) return;
+		const endpointChanged = isEndpointChange(currentTarget, target);
+		currentTarget = target;
+		if (!target) {
+			status = { up: false };
+			emitter.emit("down", { reason: "detached" });
+			return;
+		}
+		if (endpointChanged) status = { up: false };
+		flushTargetWaiters();
+	}
+	function health() {
+		return status;
+	}
+	function on(event, handler) {
+		return emitter.on(event, handler);
+	}
+	async function dispose() {
+		disposed = true;
+		currentTarget = null;
+		status = { up: false };
+		for (const waiter of [...targetWaiters]) waiter.reject(new axios.Cancel("http-transport: disposed"));
+		emitter.clear();
+	}
+	return {
+		spec,
+		client,
+		apply,
+		health,
+		on,
+		dispose
+	};
+}
+function extractMessage(error) {
+	const data = error.response?.data;
+	if (data && typeof data === "object" && "message" in data && typeof data.message === "string") return data.message;
+	return error.message;
+}
+//#endregion
+export { createHttpTransport };

package/dist/transports/nativeHttp.d.ts

@@ -0,0 +1,33 @@
+import { AxiosAdapter, AxiosInstance, InternalAxiosRequestConfig, ResponseType } from 'axios';
+export type NativeResponseType = 'text' | 'json' | 'blob' | 'arraybuffer' | 'document';
+export interface NativeHttpRequestInit {
+    url: string;
+    method: string;
+    headers: Record<string, string>;
+    params?: Record<string, string>;
+    data?: unknown;
+    responseType: NativeResponseType;
+    connectTimeout?: number;
+    readTimeout?: number;
+}
+export interface NativeHttpResult {
+    data: unknown;
+    status: number;
+    headers?: Record<string, string>;
+    url?: string;
+}
+export type NativeHttpRequest = (init: NativeHttpRequestInit) => Promise<NativeHttpResult>;
+export interface NativeHttpBinding {
+    readonly request: NativeHttpRequest;
+    readonly extraHeaders?: Record<string, string>;
+}
+export declare function isAbsoluteURL(url: string): boolean;
+export declare function buildFullUrl(config: InternalAxiosRequestConfig): string;
+export declare function isPublicFqdnUrl(url: string): boolean;
+export declare function shouldUseNativeHttp(config: InternalAxiosRequestConfig): boolean;
+export declare function createNativeHttpAdapter(binding: NativeHttpBinding): AxiosAdapter;
+export declare function applyNativeHttp(client: AxiosInstance, opts: {
+    enabled: boolean;
+} & NativeHttpBinding): void;
+export declare function normalizeBody(config: InternalAxiosRequestConfig): unknown;
+export declare function mapResponseType(type?: ResponseType): NativeResponseType;

package/dist/transports/nativeHttp.js

@@ -0,0 +1,119 @@
+import axios, { AxiosError, AxiosHeaders, CanceledError } from "axios";
+//#region src/transports/nativeHttp.ts
+function isAbsoluteURL(url) {
+	return /^([a-z][a-z\d+\-.]*:)?\/\//i.test(url);
+}
+function buildFullUrl(config) {
+	const url = config.url ?? "";
+	const base = config.baseURL ?? "";
+	if (base && !isAbsoluteURL(url)) return `${base.replace(/\/+$/, "")}/${url.replace(/^\/+/, "")}`;
+	return url;
+}
+function isPublicFqdnUrl(url) {
+	let host;
+	try {
+		host = new URL(url).hostname;
+	} catch {
+		return false;
+	}
+	if (!host || host === "localhost" || host.endsWith(".local")) return false;
+	if (host.includes(":")) return false;
+	if (/^\d{1,3}(?:\.\d{1,3}){3}$/.test(host)) return false;
+	return host.includes(".");
+}
+function shouldUseNativeHttp(config) {
+	return !config.withCredentials && isPublicFqdnUrl(buildFullUrl(config));
+}
+function createNativeHttpAdapter(binding) {
+	return async (config) => {
+		throwIfAborted(config.signal);
+		const headers = flattenHeaders(config.headers);
+		if (binding.extraHeaders) Object.assign(headers, binding.extraHeaders);
+		const timeout = typeof config.timeout === "number" && config.timeout > 0 ? config.timeout : void 0;
+		const pending = binding.request({
+			url: buildFullUrl(config),
+			method: (config.method ?? "get").toUpperCase(),
+			headers,
+			params: normalizeParams(config.params),
+			data: normalizeBody(config),
+			responseType: mapResponseType(config.responseType),
+			connectTimeout: timeout,
+			readTimeout: timeout
+		});
+		let res;
+		try {
+			res = await raceAbort(pending, config.signal);
+		} catch (err) {
+			if (err instanceof CanceledError) throw err;
+			throw new AxiosError(err instanceof Error ? err.message : "Network Error", AxiosError.ERR_NETWORK, config, pending);
+		}
+		const response = {
+			data: res.data,
+			status: res.status,
+			statusText: "",
+			headers: AxiosHeaders.from(res.headers ?? {}),
+			config,
+			request: pending
+		};
+		if (!config.validateStatus || config.validateStatus(res.status)) return response;
+		throw new AxiosError(`Request failed with status code ${res.status}`, res.status >= 500 ? AxiosError.ERR_BAD_RESPONSE : AxiosError.ERR_BAD_REQUEST, config, pending, response);
+	};
+}
+function applyNativeHttp(client, opts) {
+	if (!opts.enabled) return;
+	const fallback = axios.getAdapter(client.defaults.adapter ?? axios.defaults.adapter);
+	const native = createNativeHttpAdapter(opts);
+	client.defaults.adapter = (config) => shouldUseNativeHttp(config) ? native(config) : fallback(config);
+}
+function throwIfAborted(signal) {
+	if (signal?.aborted) throw new CanceledError("canceled");
+}
+function raceAbort(pending, signal) {
+	if (!signal || typeof signal.addEventListener !== "function") return pending;
+	if (signal.aborted) return Promise.reject(new CanceledError("canceled"));
+	return new Promise((resolve, reject) => {
+		const onAbort = () => reject(new CanceledError("canceled"));
+		signal.addEventListener("abort", onAbort, { once: true });
+		const cleanup = () => signal.removeEventListener?.("abort", onAbort);
+		pending.then((value) => {
+			cleanup();
+			resolve(value);
+		}, (err) => {
+			cleanup();
+			reject(err);
+		});
+	});
+}
+function flattenHeaders(headers) {
+	const out = {};
+	if (!headers) return out;
+	const json = AxiosHeaders.from(headers).toJSON();
+	for (const [key, value] of Object.entries(json)) {
+		if (value == null) continue;
+		out[key] = Array.isArray(value) ? value.join(", ") : String(value);
+	}
+	return out;
+}
+function normalizeParams(params) {
+	if (!params || typeof params !== "object") return void 0;
+	const out = {};
+	for (const [key, value] of Object.entries(params)) if (value != null) out[key] = String(value);
+	return out;
+}
+function normalizeBody(config) {
+	const data = config.data;
+	if (typeof data !== "string") return data;
+	if (String(AxiosHeaders.from(config.headers).get("Content-Type") ?? "").includes("application/json")) try {
+		return JSON.parse(data);
+	} catch {}
+	return data;
+}
+function mapResponseType(type) {
+	switch (type) {
+		case "blob": return "blob";
+		case "arraybuffer": return "arraybuffer";
+		default: return "text";
+	}
+}
+//#endregion
+export { applyNativeHttp, buildFullUrl, createNativeHttpAdapter, isAbsoluteURL, isPublicFqdnUrl, mapResponseType, normalizeBody, shouldUseNativeHttp };

package/dist/transports/nats.d.ts

@@ -0,0 +1,25 @@
+import { RPCClient } from '@camera.ui/rpc';
+import { TransportSpec } from '../core/types.js';
+import { Transport, Unsubscribe } from './contract.js';
+export interface NatsTransportOptions {
+    readonly spec?: Partial<TransportSpec>;
+    readonly proxyPath?: string;
+    readonly clientName?: string;
+    readonly natsUser?: string;
+    readonly natsPassword?: string;
+    readonly reconnectTimeWait?: number;
+    readonly reconnectionDelayMax?: number;
+    readonly reconnectionRandomizationFactor?: number;
+    readonly timeout?: number;
+    readonly pingInterval?: number;
+    readonly pingTimeout?: number;
+    readonly maxPingOut?: number;
+}
+export type NatsClientListener = (client: RPCClient | null) => void;
+export interface NatsTransport extends Transport {
+    getClient(): RPCClient | null;
+    subscribeClient(listener: NatsClientListener): Unsubscribe;
+    probeAlive(timeoutMs?: number): Promise<void>;
+    forceReconnect(): Promise<void>;
+}
+export declare function createNatsTransport(options?: NatsTransportOptions): NatsTransport;

package/dist/transports/nats.js

@@ -0,0 +1,225 @@
+import { n as isEndpointChange, r as isSameTarget, t as TransportEmitter } from "../contract-d-0gfY8v.js";
+import { createRPCClient } from "@camera.ui/rpc";
+//#region src/transports/nats.ts
+var NATS_SPEC = {
+	id: "nats",
+	kind: "persistent",
+	phaseGating: true,
+	graceMs: 4e3
+};
+function createNatsTransport(options = {}) {
+	const spec = {
+		...NATS_SPEC,
+		...options.spec
+	};
+	const proxyPath = options.proxyPath ?? "/api/proxy";
+	const clientName = options.clientName ?? "@camera.ui/transport/nats";
+	const natsUser = options.natsUser ?? "secret";
+	const natsPassword = options.natsPassword ?? "secret";
+	const reconnectTimeWait = options.reconnectTimeWait ?? 1e3;
+	const reconnectionDelayMax = options.reconnectionDelayMax ?? 5e3;
+	const reconnectionRandomizationFactor = options.reconnectionRandomizationFactor ?? .5;
+	const timeout = options.timeout ?? 1e4;
+	const pingInterval = options.pingInterval ?? 25e3;
+	const pingTimeout = options.pingTimeout ?? 2e4;
+	const maxPingOut = options.maxPingOut ?? 1;
+	const emitter = new TransportEmitter();
+	const clientListeners = /* @__PURE__ */ new Set();
+	let proxy = null;
+	let currentTarget = null;
+	let status = { up: false };
+	let statusAbort = null;
+	let disposed = false;
+	function buildServers(target) {
+		const url = new URL(target.endpoint.url);
+		const wsProtocol = url.protocol === "https:" ? "wss:" : "ws:";
+		const port = url.port || (url.protocol === "https:" ? "443" : "80");
+		const params = new URLSearchParams({ token: target.tokens.access });
+		if (target.tokens.proxySession) params.set("session", target.tokens.proxySession);
+		return [`${wsProtocol}//${url.hostname}:${port}${proxyPath}?${params.toString()}`];
+	}
+	function notifyClient() {
+		const next = status.up ? proxy : null;
+		for (const fn of [...clientListeners]) try {
+			fn(next);
+		} catch {}
+	}
+	function markUp() {
+		if (status.up) return;
+		status = { up: true };
+		emitter.emit("up", void 0);
+	}
+	function markDown(reason) {
+		if (!status.up && status.lastError === reason) return;
+		status = {
+			up: false,
+			lastError: reason
+		};
+		emitter.emit("down", { reason });
+	}
+	function stopStatusMonitor() {
+		statusAbort?.abort();
+		statusAbort = null;
+	}
+	function startStatusMonitor(p) {
+		stopStatusMonitor();
+		const abort = new AbortController();
+		statusAbort = abort;
+		(async () => {
+			const iter = p.status();
+			if (!iter) return;
+			for await (const event of iter) {
+				if (abort.signal.aborted) break;
+				switch (event.type) {
+					case "reconnect":
+						markUp();
+						notifyClient();
+						break;
+					case "disconnect":
+						markDown("disconnect");
+						notifyClient();
+						break;
+					case "staleConnection":
+						markDown("staleConnection");
+						notifyClient();
+						break;
+					case "error":
+						handleErrorEvent(event);
+						break;
+				}
+			}
+		})().catch(() => {});
+	}
+	function handleErrorEvent(event) {
+		const message = stringifyError(event.data);
+		const lower = message.toLowerCase();
+		if (lower.includes("auth") || lower.includes("401") || lower.includes("forbidden") || lower.includes("403")) {
+			emitter.emit("auth-error", { message });
+			return;
+		}
+		markDown(message);
+	}
+	async function rebuildClient(target) {
+		stopStatusMonitor();
+		if (proxy) {
+			try {
+				proxy.abortClose();
+			} catch {}
+			proxy = null;
+			notifyClient();
+		}
+		const next = createRPCClient({
+			servers: buildServers(target),
+			name: clientName,
+			auth: {
+				user: natsUser,
+				password: natsPassword
+			},
+			reconnect: true,
+			maxReconnectAttempts: -1,
+			reconnectTimeWait,
+			reconnectionDelayMax,
+			reconnectionRandomizationFactor,
+			timeout,
+			pingInterval,
+			pingTimeout,
+			maxPingOut,
+			ignoreAuthErrorAbort: true
+		});
+		try {
+			await next.connect();
+		} catch (err) {
+			try {
+				next.abortClose();
+			} catch {}
+			markDown(err instanceof Error ? err.message : String(err));
+			throw err;
+		}
+		proxy = next;
+		markUp();
+		notifyClient();
+		startStatusMonitor(next);
+	}
+	async function apply(target) {
+		if (disposed) throw new Error("nats-transport disposed");
+		if (isSameTarget(currentTarget, target)) return;
+		const endpointChanged = isEndpointChange(currentTarget, target);
+		currentTarget = target;
+		if (!target) {
+			stopStatusMonitor();
+			if (proxy) {
+				try {
+					proxy.abortClose();
+				} catch {}
+				proxy = null;
+				notifyClient();
+			}
+			markDown("detached");
+			return;
+		}
+		if (endpointChanged || !proxy) {
+			await rebuildClient(target);
+			return;
+		}
+		const newServers = buildServers(target);
+		proxy.setServers(newServers);
+	}
+	function health() {
+		return status;
+	}
+	function on(event, handler) {
+		return emitter.on(event, handler);
+	}
+	async function dispose() {
+		disposed = true;
+		stopStatusMonitor();
+		if (proxy) {
+			try {
+				proxy.abortClose();
+			} catch {}
+			proxy = null;
+			notifyClient();
+		}
+		clientListeners.clear();
+		status = { up: false };
+		emitter.clear();
+	}
+	function getClient() {
+		return proxy;
+	}
+	function subscribeClient(listener) {
+		clientListeners.add(listener);
+		listener(proxy);
+		return () => clientListeners.delete(listener);
+	}
+	async function probeAlive(timeoutMs = 5e3) {
+		if (!proxy) throw new Error("nats-transport: no client");
+		await proxy.flush(timeoutMs);
+	}
+	async function forceReconnect() {
+		if (!proxy) return;
+		await proxy.forceReconnect();
+	}
+	return {
+		spec,
+		apply,
+		health,
+		on,
+		dispose,
+		getClient,
+		subscribeClient,
+		probeAlive,
+		forceReconnect
+	};
+}
+function stringifyError(value) {
+	if (value instanceof Error) return value.message;
+	if (typeof value === "string") return value;
+	try {
+		return JSON.stringify(value);
+	} catch {
+		return String(value);
+	}
+}
+//#endregion
+export { createNatsTransport };