devframe 0.8.2 → 0.9.0-beta.2

package/dist/client/index.mjs

@@ -1,11 +1,9 @@
 import { t as hash } from "../hash-KtDZYXDN.mjs";
 import { colors } from "../utils/colors.mjs";
 import { createEventEmitter } from "../utils/events.mjs";
-import { t as createSharedState } from "../shared-state-6kHolYZy.mjs";
+import { t as createSharedState } from "../shared-state-fRRbRUtD.mjs";
 import { i as structuredCloneStringify, n as structuredCloneParse, t as structuredCloneDeserialize } from "../structured-clone-CgtQ61SA.mjs";
 import { createStreamReader, createStreamSink } from "../utils/streaming-channel.mjs";
-import { promiseWithResolver } from "../utils/promise.mjs";
-import { isQualifiedName, qualifyName } from "../utils/scope.mjs";
 import { defineDiagnostics } from "nostics";
 import { ansiFormatter } from "nostics/formatters/ansi";
 import { withBase, withProtocol } from "ufo";
@@ -18,6 +16,13 @@ const DEVFRAME_CONNECTION_META_FILENAME = "__connection.json";
 * connection from another JavaScript realm.
 */
 const DEVFRAME_CONNECTION_KEY = "__DEVFRAME_CONNECTION__";
+/**
+* Request header carrying the SSE session id on every RPC `POST`. The
+* server mints the id as the stream's first event (`event: session`);
+* the client echoes it here so the POST joins that stream's birpc
+* channel. Mirrors birpc's own SSE helpers for wire compatibility.
+*/
+const DEVFRAME_SSE_SESSION_HEADER = "x-birpc-session";
 const DEVFRAME_RPC_DUMP_MANIFEST_FILENAME = "__rpc-dump/index.json";
 /**
 * Page-URL **fragment** parameter carrying a one-time authentication code (OTP)
@@ -43,6 +48,45 @@ const DEVFRAME_VIEWER_ORIGIN_QUERY_PARAM = "devframe_viewer_origin";
 /** Token that authorizes an external viewer origin registration. */
 const DEVFRAME_VIEWER_ORIGIN_TOKEN_QUERY_PARAM = "devframe_viewer_origin_token";
 //#endregion
+//#region src/rpc/cache.ts
+/**
+* @experimental API is expected to change.
+*/
+var RpcCacheManager = class {
+	cacheMap = /* @__PURE__ */ new Map();
+	options;
+	keySerializer;
+	constructor(options) {
+		this.options = options;
+		this.keySerializer = options.keySerializer || ((args) => hash(args));
+	}
+	updateOptions(options) {
+		this.options = {
+			...this.options,
+			...options
+		};
+	}
+	cached(m, a) {
+		const methodCache = this.cacheMap.get(m);
+		if (methodCache) return methodCache.get(this.keySerializer(a));
+	}
+	has(m, a) {
+		return this.cacheMap.get(m)?.has(this.keySerializer(a)) ?? false;
+	}
+	apply(req, res) {
+		const methodCache = this.cacheMap.get(req.m) || /* @__PURE__ */ new Map();
+		methodCache.set(this.keySerializer(req.a), res);
+		this.cacheMap.set(req.m, methodCache);
+	}
+	validate(m) {
+		return this.options.functions.includes(m);
+	}
+	clear(fn) {
+		if (fn) this.cacheMap.delete(fn);
+		else this.cacheMap.clear();
+	}
+};
+//#endregion
 //#region src/utils/diagnostics-reporter.ts
 const formatAnsi = ansiFormatter(colors);
 function devframeReporter(d, { method = "warn" } = {}) {
@@ -87,26 +131,6 @@ const diagnostics = defineDiagnostics({
 	}
 });
 //#endregion
-//#region src/rpc/dump/error.ts
-/**
-* Inverse of {@link serializeDumpError}: rebuild a thrown `Error` from
-* the plain object stored in a dump record. Preserves `cause`, restores
-* the original `name`, and re-attaches any custom own properties.
-*/
-function reviveDumpError(stored) {
-	const cause = stored.cause instanceof Error ? stored.cause : isPlainErrorShape(stored.cause) ? reviveDumpError(stored.cause) : stored.cause;
-	const error = cause !== void 0 ? new Error(stored.message, { cause }) : new Error(stored.message);
-	error.name = stored.name;
-	for (const key of Object.keys(stored)) {
-		if (key === "name" || key === "message" || key === "cause") continue;
-		error[key] = stored[key];
-	}
-	return error;
-}
-function isPlainErrorShape(value) {
-	return typeof value === "object" && value !== null && typeof value.message === "string" && typeof value.name === "string";
-}
-//#endregion
 //#region src/rpc/validate-io.ts
 /**
 * Run a single [Standard Schema](https://standardschema.dev) validator,
@@ -215,45 +239,6 @@ async function getRpcHandler(definition, context) {
 	return validating;
 }
 //#endregion
-//#region src/rpc/cache.ts
-/**
-* @experimental API is expected to change.
-*/
-var RpcCacheManager = class {
-	cacheMap = /* @__PURE__ */ new Map();
-	options;
-	keySerializer;
-	constructor(options) {
-		this.options = options;
-		this.keySerializer = options.keySerializer || ((args) => hash(args));
-	}
-	updateOptions(options) {
-		this.options = {
-			...this.options,
-			...options
-		};
-	}
-	cached(m, a) {
-		const methodCache = this.cacheMap.get(m);
-		if (methodCache) return methodCache.get(this.keySerializer(a));
-	}
-	has(m, a) {
-		return this.cacheMap.get(m)?.has(this.keySerializer(a)) ?? false;
-	}
-	apply(req, res) {
-		const methodCache = this.cacheMap.get(req.m) || /* @__PURE__ */ new Map();
-		methodCache.set(this.keySerializer(req.a), res);
-		this.cacheMap.set(req.m, methodCache);
-	}
-	validate(m) {
-		return this.options.functions.includes(m);
-	}
-	clear(fn) {
-		if (fn) this.cacheMap.delete(fn);
-		else this.cacheMap.clear();
-	}
-};
-//#endregion
 //#region src/rpc/collector.ts
 var RpcFunctionsCollectorBase = class {
 	context;
@@ -706,269 +691,189 @@ function createRpcSharedStateClientHost(rpc) {
 	};
 }
 //#endregion
-//#region src/client/static-rpc.ts
-function isStaticEntry(value) {
-	return typeof value === "object" && value !== null && value.type === "static" && typeof value.path === "string";
-}
-function isQueryEntry(value) {
-	return typeof value === "object" && value !== null && value.type === "query" && typeof value.records === "object" && value.records !== null;
-}
-function isRecord(value) {
-	return typeof value === "object" && value !== null && ("output" in value || "error" in value);
-}
-function resolveRecordOutput(record) {
-	if (record.error) throw reviveDumpError(record.error);
-	return record.output;
-}
-function hasMeaningfulArgs(args) {
-	return args.some((arg) => arg !== null && arg !== void 0);
-}
-function unwrapEnvelope(raw) {
-	if (raw !== null && typeof raw === "object" && "serialization" in raw && "data" in raw) return raw.data;
-	return raw;
+//#region src/rpc/wire-codec.ts
+const EMPTY_WIRE_DEFS = /* @__PURE__ */ new Map();
+/**
+* Build the per-connection wire codec every live transport (WS server, WS
+* client, SSE server, SSE client) shares: per-method dispatch between strict
+* JSON (methods declared `jsonSerializable: true`) and `s:`-prefixed
+* structured-clone (everything else, including all error envelopes), with a
+* request-id → method map so a response independently picks the same
+* encoder as its request. One codec per connection — request-id spaces
+* don't collide across connections.
+*
+* @internal
+* implementations; not part of the stable public API.
+*/
+function createRpcWireCodec(definitions = EMPTY_WIRE_DEFS) {
+	const pendingRequestMethods = /* @__PURE__ */ new Map();
+	return {
+		serialize: (msg) => {
+			let method;
+			if (msg.t === "q") method = msg.m;
+			else {
+				method = pendingRequestMethods.get(msg.i);
+				pendingRequestMethods.delete(msg.i);
+			}
+			if (!(msg.t === "s" && "e" in msg) && !!method && definitions.get(method)?.jsonSerializable === true) return strictJsonStringify(msg, method ?? "");
+			return `s:${structuredCloneStringify(msg)}`;
+		},
+		deserialize: (raw) => {
+			const msg = raw.startsWith("s:") ? structuredCloneParse(raw.slice(2)) : JSON.parse(raw);
+			if (msg.t === "q" && msg.i && msg.m) pendingRequestMethods.set(msg.i, msg.m);
+			return msg;
+		}
+	};
 }
-function createStaticRpcCaller(manifest, fetchJson) {
-	const staticCache = /* @__PURE__ */ new Map();
-	const queryRecordCache = /* @__PURE__ */ new Map();
-	function reviveIfStructuredClone(value, serialization) {
-		if (serialization === "structured-clone" && Array.isArray(value)) return structuredCloneDeserialize(value);
-		return value;
-	}
-	function decode(raw, serialization) {
-		return reviveIfStructuredClone(unwrapEnvelope(raw), serialization);
-	}
-	async function loadStatic(entry) {
-		if (!staticCache.has(entry.path)) staticCache.set(entry.path, fetchJson(entry.path).then((raw) => decode(raw, entry.serialization)));
-		const data = await staticCache.get(entry.path);
-		if (isRecord(data)) return resolveRecordOutput(data);
-		return data;
+//#endregion
+//#region src/rpc/transports/sse-client.ts
+function NOOP$1() {}
+/**
+* Build a birpc `ChannelOptions` object backed by an SSE stream (server →
+* client) and HTTP `POST` (client → server) — the WebSocket-free counterpart
+* to `createWsRpcChannel`, wire-compatible with `attachSseRpcTransport`.
+*
+* The stream is consumed via `fetch` streaming (not `EventSource`), so it
+* works in browsers and server runtimes alike. The server's first frame
+* (`event: session`) carries the session id; every `POST` echoes it in the
+* `x-birpc-session` header. A response to a client-initiated request comes
+* back in the `POST`'s own body and is re-injected into the channel; a
+* dropped stream terminates the channel — there is no reconnect, matching
+* the WS channel's closed-is-done semantics.
+*/
+function createSseRpcChannel(options) {
+	const { onConnected = NOOP$1, onError = NOOP$1, onDisconnected = NOOP$1, definitions, fetch: fetchImpl = globalThis.fetch.bind(globalThis) } = options;
+	let url = options.url;
+	if (options.authToken) url = `${url}${url.includes("?") ? "&" : "?"}${DEVFRAME_AUTH_TOKEN_QUERY_PARAM}=${encodeURIComponent(options.authToken)}`;
+	const codec = createRpcWireCodec(definitions);
+	const abort = new AbortController();
+	let closed = false;
+	let onMessage;
+	let activeReader;
+	let resolveSession;
+	let rejectSession;
+	const sessionReady = new Promise((resolve, reject) => {
+		resolveSession = resolve;
+		rejectSession = reject;
+	});
+	sessionReady.catch(() => {});
+	function fail(error) {
+		if (closed) return;
+		closed = true;
+		rejectSession(error);
+		onError(error);
+		onDisconnected();
 	}
-	async function loadQueryRecord(path, serialization) {
-		if (!queryRecordCache.has(path)) queryRecordCache.set(path, fetchJson(path).then((raw) => decode(raw, serialization)));
-		return await queryRecordCache.get(path);
+	function end() {
+		if (closed) return;
+		closed = true;
+		rejectSession(/* @__PURE__ */ new Error("Devframe SSE stream closed"));
+		onDisconnected();
 	}
-	async function call(functionName, args) {
-		if (!(functionName in manifest)) throw new Error(`[devframe-rpc] Function "${functionName}" not found in dump store`);
-		const entry = manifest[functionName];
-		if (isStaticEntry(entry)) {
-			if (hasMeaningfulArgs(args)) throw new Error(`[devframe-rpc] No dump match for "${functionName}" with args: ${JSON.stringify(args)}`);
-			return await loadStatic(entry);
+	function dispatch(event, data) {
+		if (event === "session") {
+			resolveSession(data);
+			onConnected();
+			return;
 		}
-		if (isQueryEntry(entry)) {
-			const argsHash = hash(args);
-			const recordPath = entry.records[argsHash];
-			if (recordPath) return resolveRecordOutput(await loadQueryRecord(recordPath, entry.serialization));
-			if (entry.fallback) return resolveRecordOutput(await loadQueryRecord(entry.fallback, entry.serialization));
-			throw new Error(`[devframe-rpc] No dump match for "${functionName}" with args: ${JSON.stringify(args)}`);
+		onMessage?.(data);
+	}
+	/** Parse the SSE byte stream frame by frame and dispatch each event. */
+	async function consume(stream) {
+		const reader = stream.getReader();
+		activeReader = reader;
+		const decoder = new TextDecoder();
+		let buffer = "";
+		for (;;) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			buffer += decoder.decode(value, { stream: true });
+			for (;;) {
+				const boundary = buffer.search(/\n\n|\r\n\r\n/);
+				if (boundary < 0) break;
+				const frame = buffer.slice(0, boundary);
+				buffer = buffer.slice(boundary + (buffer[boundary] === "\r" ? 4 : 2));
+				let event = "message";
+				const data = [];
+				for (const rawLine of frame.split(/\r?\n/)) {
+					if (rawLine.startsWith(":")) continue;
+					if (rawLine.startsWith("event:")) event = rawLine.slice(6).trimStart();
+					else if (rawLine.startsWith("data:")) data.push(rawLine.slice(5).replace(/^ /, ""));
+				}
+				if (data.length > 0) dispatch(event, data.join("\n"));
+			}
 		}
-		if (!hasMeaningfulArgs(args)) return entry;
-		throw new Error(`[devframe-rpc] No dump match for "${functionName}" with args: ${JSON.stringify(args)}`);
+		end();
 	}
+	(async () => {
+		try {
+			const response = await fetchImpl(url, {
+				headers: { accept: "text/event-stream" },
+				signal: abort.signal
+			});
+			if (!response.ok || !response.body) throw new Error(`Devframe SSE stream request failed: ${response.status}`);
+			await consume(response.body);
+		} catch (error) {
+			if (abort.signal.aborted) {
+				end();
+				return;
+			}
+			fail(error instanceof Error ? error : new Error(String(error)));
+		}
+	})();
 	return {
-		call: async (functionName, args) => await call(functionName, args),
-		callOptional: async (functionName, args) => {
-			if (!(functionName in manifest)) return void 0;
-			return await call(functionName, args);
+		close: () => {
+			closed = true;
+			abort.abort();
+			activeReader?.cancel().catch(() => {});
 		},
-		callEvent: async (_functionName, _args) => {}
+		on: (handler) => {
+			onMessage = handler;
+		},
+		post: async (data) => {
+			let sessionId;
+			try {
+				sessionId = await sessionReady;
+			} catch {
+				return;
+			}
+			if (closed) {
+				onError(/* @__PURE__ */ new Error("Devframe SSE channel is closed; message dropped"));
+				return;
+			}
+			try {
+				const response = await fetchImpl(url, {
+					method: "POST",
+					headers: {
+						"content-type": "text/plain; charset=utf-8",
+						[DEVFRAME_SSE_SESSION_HEADER]: sessionId
+					},
+					body: data
+				});
+				if (response.status === 200) {
+					const body = await response.text();
+					if (body) onMessage?.(body);
+					return;
+				}
+				if (!response.ok) throw new Error(`Devframe SSE POST failed: ${response.status}`);
+			} catch (error) {
+				onError(error instanceof Error ? error : new Error(String(error)));
+			}
+		},
+		serialize: codec.serialize,
+		deserialize: codec.deserialize
 	};
 }
 //#endregion
-//#region src/client/rpc-static.ts
-async function createStaticRpcClientMode(options) {
-	const staticCaller = createStaticRpcCaller(await options.fetchJsonFromBases(DEVFRAME_RPC_DUMP_MANIFEST_FILENAME), options.fetchJsonFromBases);
-	return {
-		isTrusted: true,
-		status: "connected",
-		connectionError: null,
-		requestTrust: async () => true,
-		requestTrustWithToken: async () => true,
-		requestTrustWithCode: async () => null,
-		ensureTrusted: async () => true,
-		call: (...args) => staticCaller.call(args[0], args.slice(1)),
-		callEvent: (...args) => staticCaller.callEvent(args[0], args.slice(1)),
-		callOptional: (...args) => staticCaller.callOptional(args[0], args.slice(1))
-	};
-}
-//#endregion
-//#region src/client/rpc-streaming.ts
-const STREAM_KEY_SEPARATOR = "";
-function streamKey(channel, id) {
-	return `${channel}${STREAM_KEY_SEPARATOR}${id}`;
-}
-/**
-* Client-side streaming host. Mirrors `createRpcSharedStateClientHost`:
-* registers the two `:chunk` / `:end` event handlers once, then per-stream
-* state lives in a `Map<streamKey, StreamReader>`.
-*/
-function createRpcStreamingClientHost(rpc) {
-	const readers = /* @__PURE__ */ new Map();
-	const uploads = /* @__PURE__ */ new Map();
-	rpc.client.register({
-		name: "devframe:streaming:chunk",
-		type: "event",
-		handler(channel, id, seq, chunk) {
-			readers.get(streamKey(channel, id))?._push(seq, chunk);
-		}
-	});
-	rpc.client.register({
-		name: "devframe:streaming:end",
-		type: "event",
-		handler(channel, id, error) {
-			const key = streamKey(channel, id);
-			const reader = readers.get(key);
-			if (!reader) return;
-			reader._end(error);
-			readers.delete(key);
-		}
-	});
-	rpc.client.register({
-		name: "devframe:streaming:upload-cancel",
-		type: "event",
-		handler(channel, id) {
-			const key = streamKey(channel, id);
-			const sink = uploads.get(key);
-			if (!sink) return;
-			sink.abort("server cancelled upload");
-			uploads.delete(key);
-		}
-	});
-	rpc.events.on("rpc:is-trusted:updated", (isTrusted) => {
-		if (!isTrusted) return;
-		for (const [key, reader] of readers) {
-			if (reader.cancelled || reader.done) continue;
-			const sepIdx = key.indexOf(STREAM_KEY_SEPARATOR);
-			if (sepIdx < 0) continue;
-			const channel = key.slice(0, sepIdx);
-			const id = key.slice(sepIdx + 1);
-			rpc.callEvent("devframe:streaming:subscribe", channel, id, { afterSeq: reader.lastSeenSeq });
-		}
-	});
-	function subscribe(channel, id, options = {}) {
-		const key = streamKey(channel, id);
-		const existing = readers.get(key);
-		if (existing) return existing;
-		const reader = createStreamReader({
-			id,
-			highWaterMark: options.highWaterMark,
-			onOverflow(dropped) {
-				console.warn(`[devframe] DF0029: Stream "${channel}#${id}" dropped ${dropped} chunk(s) after exceeding the client high-water mark.`);
-			},
-			onCancel() {
-				rpc.callEvent("devframe:streaming:cancel", channel, id);
-				readers.delete(key);
-			}
-		});
-		readers.set(key, reader);
-		if (rpc.isTrusted) rpc.callEvent("devframe:streaming:subscribe", channel, id, { afterSeq: 0 });
-		else {
-			const off = rpc.events.on("rpc:is-trusted:updated", (trusted) => {
-				if (trusted) {
-					off();
-					if (readers.has(key) && !reader.cancelled && !reader.done) rpc.callEvent("devframe:streaming:subscribe", channel, id, { afterSeq: reader.lastSeenSeq });
-				}
-			});
-		}
-		return reader;
-	}
-	function upload(channel, id) {
-		const key = streamKey(channel, id);
-		const existing = uploads.get(key);
-		if (existing) return existing;
-		const sink = createStreamSink({ id });
-		sink.events.on("chunk", (seq, chunk) => {
-			rpc.callEvent("devframe:streaming:upload-chunk", channel, id, seq, chunk);
-		});
-		sink.events.on("end", (error) => {
-			rpc.callEvent("devframe:streaming:upload-end", channel, id, error);
-			uploads.delete(key);
-		});
-		uploads.set(key, sink);
-		return sink;
-	}
-	return {
-		subscribe,
-		upload
-	};
-}
-//#endregion
-//#region src/rpc/client.ts
-function createRpcClient(functions, options) {
-	const { channel, rpcOptions = {} } = options;
-	return createBirpc(functions, {
-		...channel,
-		timeout: -1,
-		...rpcOptions,
-		proxify: false
-	});
-}
-//#endregion
-//#region src/rpc/transports/ws-client.ts
-function NOOP() {}
-const EMPTY_DEFS = /* @__PURE__ */ new Map();
-/**
-* Build a birpc `ChannelOptions` object backed by a browser `WebSocket`.
-* Pass the result straight to `createRpcClient`'s `channel` option.
-*/
-function createWsRpcChannel(options) {
-	let url = options.url;
-	if (options.authToken) url = `${url}?${DEVFRAME_AUTH_TOKEN_QUERY_PARAM}=${encodeURIComponent(options.authToken)}`;
-	const ws = new WebSocket(url);
-	const { onConnected = NOOP, onError = NOOP, onDisconnected = NOOP, definitions = EMPTY_DEFS } = options;
-	ws.addEventListener("open", (e) => {
-		onConnected(e);
-	});
-	ws.addEventListener("error", (e) => {
-		const _e = e instanceof Error ? e : new Error(e.type);
-		onError(_e);
-	});
-	ws.addEventListener("close", (e) => {
-		onDisconnected(e);
-	});
-	const pendingRequestMethods = /* @__PURE__ */ new Map();
-	return {
-		on: (handler) => {
-			ws.addEventListener("message", (e) => {
-				handler(e.data);
-			});
-		},
-		post: (data) => {
-			if (ws.readyState === WebSocket.OPEN) {
-				ws.send(data);
-				return;
-			}
-			if (ws.readyState === WebSocket.CONNECTING) {
-				const onOpen = () => {
-					cleanup();
-					if (ws.readyState === WebSocket.OPEN) ws.send(data);
-				};
-				const onClose = () => cleanup();
-				function cleanup() {
-					ws.removeEventListener("open", onOpen);
-					ws.removeEventListener("close", onClose);
-				}
-				ws.addEventListener("open", onOpen);
-				ws.addEventListener("close", onClose);
-				return;
-			}
-			onError(/* @__PURE__ */ new Error("Devframe WebSocket is not open; message dropped"));
-		},
-		serialize: (msg) => {
-			let method;
-			if (msg.t === "q") method = msg.m;
-			else {
-				method = pendingRequestMethods.get(msg.i);
-				pendingRequestMethods.delete(msg.i);
-			}
-			if (!(msg.t === "s" && "e" in msg) && !!method && definitions.get(method)?.jsonSerializable === true) return strictJsonStringify(msg, method ?? "");
-			return `s:${structuredCloneStringify(msg)}`;
-		},
-		deserialize: (raw) => {
-			const msg = raw.startsWith("s:") ? structuredCloneParse(raw.slice(2)) : JSON.parse(raw);
-			if (msg.t === "q" && msg.i && msg.m) pendingRequestMethods.set(msg.i, msg.m);
-			return msg;
-		}
-	};
+//#region src/rpc/client.ts
+function createRpcClient(functions, options) {
+	const { channel, rpcOptions = {} } = options;
+	return createBirpc(functions, {
+		...channel,
+		timeout: -1,
+		...rpcOptions,
+		proxify: false
+	});
 }
 //#endregion
 //#region ../../node_modules/.pnpm/ua-parser-modern@0.1.1/node_modules/ua-parser-modern/dist/index.mjs
@@ -2133,54 +2038,32 @@ function parseUA(uastringOrExtensions, extensions) {
 	};
 }
 //#endregion
-//#region src/client/rpc-ws.ts
+//#region src/utils/promise.ts
+function promiseWithResolver() {
+	let resolve;
+	let reject;
+	return {
+		promise: new Promise((_resolve, _reject) => {
+			resolve = _resolve;
+			reject = _reject;
+		}),
+		resolve,
+		reject
+	};
+}
+//#endregion
+//#region src/client/rpc-live.ts
 /**
-* Resolve a {@link ConnectionMeta.websocket} descriptor into a concrete
-* `ws(s)://` URL.
-*
-* The object / relative-path forms connect to the page's own origin (only the
-* `http`→`ws` protocol swap is applied), resolving the path against where
-* `__connection.json` was loaded. This is deliberately host-agnostic so the
-* connection survives a reverse proxy that changes the domain or port — the
-* client trusts its own location, never a server-baked hostname. An explicit
-* `port`/`host` (or a full `ws(s)://` URL string) opts into a cross-origin
-* endpoint, e.g. a side-car server on its own port.
+* The transport-independent half of a live RPC client mode — connection
+* status, pending-call guarding, and the trust handshake — shared by the
+* WebSocket and SSE modes. Each transport supplies only its channel.
 */
-function resolveWsUrl(websocket, metaBaseUrl, loc) {
-	const base = (() => {
-		try {
-			return new URL(metaBaseUrl, loc.href);
-		} catch {
-			return new URL(loc.href);
-		}
-	})();
-	const wsProtocol = base.protocol === "https:" ? "wss:" : "ws:";
-	if (websocket && typeof websocket === "object") {
-		if (websocket.host != null || websocket.port != null) {
-			const host = websocket.host ?? `${base.hostname}:${websocket.port}`;
-			const target = new URL(websocket.path ?? "/", `${wsProtocol}//${host}`);
-			target.protocol = wsProtocol;
-			return target.href;
-		}
-		const target = new URL(websocket.path ?? "", base);
-		target.protocol = wsProtocol;
-		return target.href;
-	}
-	if (typeof websocket === "number") return `${wsProtocol}//${base.hostname}:${websocket}`;
-	const str = websocket ?? "";
-	if (/^wss?:\/\//i.test(str)) return str;
-	if (/^https?:\/\//i.test(str)) return withProtocol(str, /^https/i.test(str) ? "wss://" : "ws://");
-	const target = new URL(str, base);
-	target.protocol = wsProtocol;
-	return target.href;
-}
-function createWsRpcClientMode(options) {
-	const { authToken, connectionMeta, metaBaseUrl, events, clientRpc, rpcOptions = {}, wsOptions = {}, callTimeout = 0 } = options;
+function createLiveRpcClientMode(options) {
+	const { transport, authToken, connectionMeta, events, clientRpc, rpcOptions = {}, callTimeout = 0 } = options;
 	let isTrusted = false;
 	let status = "connecting";
 	let connectionError = null;
 	const trustedPromise = promiseWithResolver();
-	const url = resolveWsUrl(connectionMeta.websocket, metaBaseUrl ?? "./", location);
 	function setStatus(next, error = null) {
 		if (error) connectionError = error;
 		else if (next === "connected") connectionError = null;
@@ -2236,27 +2119,20 @@ function createWsRpcClientMode(options) {
 	}
 	const definitions = /* @__PURE__ */ new Map();
 	for (const name of connectionMeta.jsonSerializableMethods ?? []) definitions.set(name, { jsonSerializable: true });
+	const channel = options.createChannel({
+		definitions,
+		onError(error) {
+			setStatus("error", error);
+			events.emit("connection:error", error);
+			rejectAllPending(new DevframeConnectionError("connection", "[devframe] Connection to the devframe server failed", { cause: error }));
+		},
+		onDisconnected() {
+			if (status !== "error") setStatus("disconnected");
+			rejectAllPending(new DevframeConnectionError("connection", "[devframe] Disconnected from the devframe server", { cause: connectionError ?? void 0 }));
+		}
+	});
 	const serverRpc = createRpcClient(clientRpc.functions, {
-		channel: createWsRpcChannel({
-			url,
-			authToken,
-			definitions,
-			...wsOptions,
-			onConnected(event) {
-				wsOptions.onConnected?.(event);
-			},
-			onError(error) {
-				setStatus("error", error);
-				events.emit("connection:error", error);
-				rejectAllPending(new DevframeConnectionError("connection", "[devframe] Connection to the devframe server failed", { cause: error }));
-				wsOptions.onError?.(error);
-			},
-			onDisconnected(event) {
-				if (status !== "error") setStatus("disconnected");
-				rejectAllPending(new DevframeConnectionError("connection", "[devframe] Disconnected from the devframe server", { cause: connectionError ?? void 0 }));
-				wsOptions.onDisconnected?.(event);
-			}
-		}),
+		channel,
 		rpcOptions
 	});
 	clientRpc.register({
@@ -2334,6 +2210,7 @@ function createWsRpcClientMode(options) {
 		return isTrusted;
 	}
 	return {
+		transport,
 		get isTrusted() {
 			return isTrusted;
 		},
@@ -2372,39 +2249,462 @@ function createWsRpcClientMode(options) {
 				return Promise.reject(failFast);
 			}
 			return guardCall(serverRpc.$callOptional(...args), method);
+		},
+		close: () => {
+			channel.close();
 		}
 	};
 }
 //#endregion
-//#region src/client/settings.ts
-function createClientSettingsStore(rpc, namespace, scope) {
-	const stateKey = `devframe:settings:${scope}:${namespace}`;
-	let statePromise;
-	function store() {
-		if (!statePromise) statePromise = rpc.sharedState.get(stateKey, { initialValue: {} });
-		return statePromise;
-	}
-	return {
-		async get(key) {
-			return (await store()).value()[key];
-		},
-		async set(key, value) {
-			(await store()).mutate((draft) => {
-				draft[key] = value;
-			});
-		},
-		async delete(key) {
-			(await store()).mutate((draft) => {
-				delete draft[key];
-			});
-		},
-		async all() {
-			return (await store()).value();
-		},
-		async onChange(fn) {
-			return (await store()).on("updated", (full) => fn(full));
+//#region src/client/rpc-sse.ts
+/**
+* Resolve a {@link ConnectionMeta.sse} descriptor into a concrete
+* `http(s)://` URL, with the same proxy-safe rules as `resolveWsUrl`: the
+* object / relative-path forms resolve against where `__connection.json`
+* was loaded (the client trusts its own location, never a server-baked
+* hostname), while an explicit `port`/`host` (or a full `http(s)://` URL
+* string) opts into a cross-origin endpoint.
+*/
+function resolveSseUrl(sse, metaBaseUrl, loc) {
+	const base = (() => {
+		try {
+			return new URL(metaBaseUrl, loc.href);
+		} catch {
+			return new URL(loc.href);
 		}
-	};
+	})();
+	if (sse && typeof sse === "object") {
+		if (sse.host != null || sse.port != null) {
+			const host = sse.host ?? `${base.hostname}:${sse.port}`;
+			return new URL(sse.path ?? "/", `${base.protocol}//${host}`).href;
+		}
+		return new URL(sse.path ?? "", base).href;
+	}
+	const str = sse ?? "";
+	if (/^https?:\/\//i.test(str)) return str;
+	return new URL(str, base).href;
+}
+/**
+* The SSE-backed live client mode — picked by `connectDevframe` when the
+* server advertises SSE as its primary transport (`backend: 'sse'`) or when
+* the caller pins `transport: 'sse'`. Same status machine, call guarding,
+* and trust handshake as the WebSocket mode, over `createSseRpcChannel`.
+*/
+function createSseRpcClientMode(options) {
+	const { authToken, connectionMeta, metaBaseUrl, events, clientRpc, rpcOptions = {}, sseOptions = {}, callTimeout = 0 } = options;
+	const url = resolveSseUrl(connectionMeta.sse, metaBaseUrl ?? "./", location);
+	return createLiveRpcClientMode({
+		transport: "sse",
+		authToken,
+		connectionMeta,
+		events,
+		clientRpc,
+		rpcOptions,
+		callTimeout,
+		createChannel: (handlers) => createSseRpcChannel({
+			url,
+			authToken,
+			definitions: handlers.definitions,
+			...sseOptions,
+			onConnected() {
+				sseOptions.onConnected?.();
+			},
+			onError(error) {
+				handlers.onError(error);
+				sseOptions.onError?.(error);
+			},
+			onDisconnected() {
+				handlers.onDisconnected();
+				sseOptions.onDisconnected?.();
+			}
+		})
+	});
+}
+//#endregion
+//#region src/rpc/dump/error.ts
+/**
+* Inverse of {@link serializeDumpError}: rebuild a thrown `Error` from
+* the plain object stored in a dump record. Preserves `cause`, restores
+* the original `name`, and re-attaches any custom own properties.
+*/
+function reviveDumpError(stored) {
+	const cause = stored.cause instanceof Error ? stored.cause : isPlainErrorShape(stored.cause) ? reviveDumpError(stored.cause) : stored.cause;
+	const error = cause !== void 0 ? new Error(stored.message, { cause }) : new Error(stored.message);
+	error.name = stored.name;
+	for (const key of Object.keys(stored)) {
+		if (key === "name" || key === "message" || key === "cause") continue;
+		error[key] = stored[key];
+	}
+	return error;
+}
+function isPlainErrorShape(value) {
+	return typeof value === "object" && value !== null && typeof value.message === "string" && typeof value.name === "string";
+}
+//#endregion
+//#region src/client/static-rpc.ts
+function isStaticEntry(value) {
+	return typeof value === "object" && value !== null && value.type === "static" && typeof value.path === "string";
+}
+function isQueryEntry(value) {
+	return typeof value === "object" && value !== null && value.type === "query" && typeof value.records === "object" && value.records !== null;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && ("output" in value || "error" in value);
+}
+function resolveRecordOutput(record) {
+	if (record.error) throw reviveDumpError(record.error);
+	return record.output;
+}
+function hasMeaningfulArgs(args) {
+	return args.some((arg) => arg !== null && arg !== void 0);
+}
+function unwrapEnvelope(raw) {
+	if (raw !== null && typeof raw === "object" && "serialization" in raw && "data" in raw) return raw.data;
+	return raw;
+}
+function createStaticRpcCaller(manifest, fetchJson) {
+	const staticCache = /* @__PURE__ */ new Map();
+	const queryRecordCache = /* @__PURE__ */ new Map();
+	function reviveIfStructuredClone(value, serialization) {
+		if (serialization === "structured-clone" && Array.isArray(value)) return structuredCloneDeserialize(value);
+		return value;
+	}
+	function decode(raw, serialization) {
+		return reviveIfStructuredClone(unwrapEnvelope(raw), serialization);
+	}
+	async function loadStatic(entry) {
+		if (!staticCache.has(entry.path)) staticCache.set(entry.path, fetchJson(entry.path).then((raw) => decode(raw, entry.serialization)));
+		const data = await staticCache.get(entry.path);
+		if (isRecord(data)) return resolveRecordOutput(data);
+		return data;
+	}
+	async function loadQueryRecord(path, serialization) {
+		if (!queryRecordCache.has(path)) queryRecordCache.set(path, fetchJson(path).then((raw) => decode(raw, serialization)));
+		return await queryRecordCache.get(path);
+	}
+	async function call(functionName, args) {
+		if (!(functionName in manifest)) throw new Error(`[devframe-rpc] Function "${functionName}" not found in dump store`);
+		const entry = manifest[functionName];
+		if (isStaticEntry(entry)) {
+			if (hasMeaningfulArgs(args)) throw new Error(`[devframe-rpc] No dump match for "${functionName}" with args: ${JSON.stringify(args)}`);
+			return await loadStatic(entry);
+		}
+		if (isQueryEntry(entry)) {
+			const argsHash = hash(args);
+			const recordPath = entry.records[argsHash];
+			if (recordPath) return resolveRecordOutput(await loadQueryRecord(recordPath, entry.serialization));
+			if (entry.fallback) return resolveRecordOutput(await loadQueryRecord(entry.fallback, entry.serialization));
+			throw new Error(`[devframe-rpc] No dump match for "${functionName}" with args: ${JSON.stringify(args)}`);
+		}
+		if (!hasMeaningfulArgs(args)) return entry;
+		throw new Error(`[devframe-rpc] No dump match for "${functionName}" with args: ${JSON.stringify(args)}`);
+	}
+	return {
+		call: async (functionName, args) => await call(functionName, args),
+		callOptional: async (functionName, args) => {
+			if (!(functionName in manifest)) return void 0;
+			return await call(functionName, args);
+		},
+		callEvent: async (_functionName, _args) => {}
+	};
+}
+//#endregion
+//#region src/client/rpc-static.ts
+async function createStaticRpcClientMode(options) {
+	const staticCaller = createStaticRpcCaller(await options.fetchJsonFromBases(DEVFRAME_RPC_DUMP_MANIFEST_FILENAME), options.fetchJsonFromBases);
+	return {
+		transport: "static",
+		isTrusted: true,
+		status: "connected",
+		connectionError: null,
+		requestTrust: async () => true,
+		requestTrustWithToken: async () => true,
+		requestTrustWithCode: async () => null,
+		ensureTrusted: async () => true,
+		call: (...args) => staticCaller.call(args[0], args.slice(1)),
+		callEvent: (...args) => staticCaller.callEvent(args[0], args.slice(1)),
+		callOptional: (...args) => staticCaller.callOptional(args[0], args.slice(1)),
+		close: () => {}
+	};
+}
+//#endregion
+//#region src/client/rpc-streaming.ts
+const STREAM_KEY_SEPARATOR = "";
+function streamKey(channel, id) {
+	return `${channel}${STREAM_KEY_SEPARATOR}${id}`;
+}
+/**
+* Client-side streaming host. Mirrors `createRpcSharedStateClientHost`:
+* registers the two `:chunk` / `:end` event handlers once, then per-stream
+* state lives in a `Map<streamKey, StreamReader>`.
+*/
+function createRpcStreamingClientHost(rpc) {
+	const readers = /* @__PURE__ */ new Map();
+	const uploads = /* @__PURE__ */ new Map();
+	rpc.client.register({
+		name: "devframe:streaming:chunk",
+		type: "event",
+		handler(channel, id, seq, chunk) {
+			readers.get(streamKey(channel, id))?._push(seq, chunk);
+		}
+	});
+	rpc.client.register({
+		name: "devframe:streaming:end",
+		type: "event",
+		handler(channel, id, error) {
+			const key = streamKey(channel, id);
+			const reader = readers.get(key);
+			if (!reader) return;
+			reader._end(error);
+			readers.delete(key);
+		}
+	});
+	rpc.client.register({
+		name: "devframe:streaming:upload-cancel",
+		type: "event",
+		handler(channel, id) {
+			const key = streamKey(channel, id);
+			const sink = uploads.get(key);
+			if (!sink) return;
+			sink.abort("server cancelled upload");
+			uploads.delete(key);
+		}
+	});
+	rpc.events.on("rpc:is-trusted:updated", (isTrusted) => {
+		if (!isTrusted) return;
+		for (const [key, reader] of readers) {
+			if (reader.cancelled || reader.done) continue;
+			const sepIdx = key.indexOf(STREAM_KEY_SEPARATOR);
+			if (sepIdx < 0) continue;
+			const channel = key.slice(0, sepIdx);
+			const id = key.slice(sepIdx + 1);
+			rpc.callEvent("devframe:streaming:subscribe", channel, id, { afterSeq: reader.lastSeenSeq });
+		}
+	});
+	function subscribe(channel, id, options = {}) {
+		const key = streamKey(channel, id);
+		const existing = readers.get(key);
+		if (existing) return existing;
+		const reader = createStreamReader({
+			id,
+			highWaterMark: options.highWaterMark,
+			onOverflow(dropped) {
+				console.warn(`[devframe] DF0029: Stream "${channel}#${id}" dropped ${dropped} chunk(s) after exceeding the client high-water mark.`);
+			},
+			onCancel() {
+				rpc.callEvent("devframe:streaming:cancel", channel, id);
+				readers.delete(key);
+			}
+		});
+		readers.set(key, reader);
+		if (rpc.isTrusted) rpc.callEvent("devframe:streaming:subscribe", channel, id, { afterSeq: 0 });
+		else {
+			const off = rpc.events.on("rpc:is-trusted:updated", (trusted) => {
+				if (trusted) {
+					off();
+					if (readers.has(key) && !reader.cancelled && !reader.done) rpc.callEvent("devframe:streaming:subscribe", channel, id, { afterSeq: reader.lastSeenSeq });
+				}
+			});
+		}
+		return reader;
+	}
+	function upload(channel, id) {
+		const key = streamKey(channel, id);
+		const existing = uploads.get(key);
+		if (existing) return existing;
+		const sink = createStreamSink({ id });
+		sink.events.on("chunk", (seq, chunk) => {
+			rpc.callEvent("devframe:streaming:upload-chunk", channel, id, seq, chunk);
+		});
+		sink.events.on("end", (error) => {
+			rpc.callEvent("devframe:streaming:upload-end", channel, id, error);
+			uploads.delete(key);
+		});
+		uploads.set(key, sink);
+		return sink;
+	}
+	return {
+		subscribe,
+		upload
+	};
+}
+//#endregion
+//#region src/rpc/transports/ws-client.ts
+function NOOP() {}
+const EMPTY_DEFS = /* @__PURE__ */ new Map();
+/**
+* Build a birpc `ChannelOptions` object backed by a browser `WebSocket`.
+* Pass the result straight to `createRpcClient`'s `channel` option.
+*
+* Also returns `close()`, closing the underlying socket — mirroring the server transport's
+* existing `WsRpcTransport.close()`. `birpc`'s own `ChannelOptions` has no teardown of its own.
+*/
+function createWsRpcChannel(options) {
+	let url = options.url;
+	if (options.authToken) url = `${url}?${DEVFRAME_AUTH_TOKEN_QUERY_PARAM}=${encodeURIComponent(options.authToken)}`;
+	const ws = new WebSocket(url);
+	const { onConnected = NOOP, onError = NOOP, onDisconnected = NOOP, definitions = EMPTY_DEFS } = options;
+	ws.addEventListener("open", (e) => {
+		onConnected(e);
+	});
+	ws.addEventListener("error", (e) => {
+		const _e = e instanceof Error ? e : new Error(e.type);
+		onError(_e);
+	});
+	ws.addEventListener("close", (e) => {
+		onDisconnected(e);
+	});
+	const codec = createRpcWireCodec(definitions);
+	return {
+		close: () => {
+			ws.close();
+		},
+		on: (handler) => {
+			ws.addEventListener("message", (e) => {
+				handler(e.data);
+			});
+		},
+		post: (data) => {
+			if (ws.readyState === WebSocket.OPEN) {
+				ws.send(data);
+				return;
+			}
+			if (ws.readyState === WebSocket.CONNECTING) {
+				const onOpen = () => {
+					cleanup();
+					if (ws.readyState === WebSocket.OPEN) ws.send(data);
+				};
+				const onClose = () => cleanup();
+				function cleanup() {
+					ws.removeEventListener("open", onOpen);
+					ws.removeEventListener("close", onClose);
+				}
+				ws.addEventListener("open", onOpen);
+				ws.addEventListener("close", onClose);
+				return;
+			}
+			onError(/* @__PURE__ */ new Error("Devframe WebSocket is not open; message dropped"));
+		},
+		serialize: codec.serialize,
+		deserialize: codec.deserialize
+	};
+}
+//#endregion
+//#region src/client/rpc-ws.ts
+/**
+* Resolve a {@link ConnectionMeta.websocket} descriptor into a concrete
+* `ws(s)://` URL.
+*
+* The object / relative-path forms connect to the page's own origin (only the
+* `http`→`ws` protocol swap is applied), resolving the path against where
+* `__connection.json` was loaded. This is deliberately host-agnostic so the
+* connection survives a reverse proxy that changes the domain or port — the
+* client trusts its own location, never a server-baked hostname. An explicit
+* `port`/`host` (or a full `ws(s)://` URL string) opts into a cross-origin
+* endpoint, e.g. a side-car server on its own port.
+*/
+function resolveWsUrl(websocket, metaBaseUrl, loc) {
+	const base = (() => {
+		try {
+			return new URL(metaBaseUrl, loc.href);
+		} catch {
+			return new URL(loc.href);
+		}
+	})();
+	const wsProtocol = base.protocol === "https:" ? "wss:" : "ws:";
+	if (websocket && typeof websocket === "object") {
+		if (websocket.host != null || websocket.port != null) {
+			const host = websocket.host ?? `${base.hostname}:${websocket.port}`;
+			const target = new URL(websocket.path ?? "/", `${wsProtocol}//${host}`);
+			target.protocol = wsProtocol;
+			return target.href;
+		}
+		const target = new URL(websocket.path ?? "", base);
+		target.protocol = wsProtocol;
+		return target.href;
+	}
+	if (typeof websocket === "number") return `${wsProtocol}//${base.hostname}:${websocket}`;
+	const str = websocket ?? "";
+	if (/^wss?:\/\//i.test(str)) return str;
+	if (/^https?:\/\//i.test(str)) return withProtocol(str, /^https/i.test(str) ? "wss://" : "ws://");
+	const target = new URL(str, base);
+	target.protocol = wsProtocol;
+	return target.href;
+}
+function createWsRpcClientMode(options) {
+	const { authToken, connectionMeta, metaBaseUrl, events, clientRpc, rpcOptions = {}, wsOptions = {}, callTimeout = 0 } = options;
+	const url = resolveWsUrl(connectionMeta.websocket, metaBaseUrl ?? "./", location);
+	return createLiveRpcClientMode({
+		transport: "websocket",
+		authToken,
+		connectionMeta,
+		events,
+		clientRpc,
+		rpcOptions,
+		callTimeout,
+		createChannel: (handlers) => createWsRpcChannel({
+			url,
+			authToken,
+			definitions: handlers.definitions,
+			...wsOptions,
+			onConnected(event) {
+				wsOptions.onConnected?.(event);
+			},
+			onError(error) {
+				handlers.onError(error);
+				wsOptions.onError?.(error);
+			},
+			onDisconnected(event) {
+				handlers.onDisconnected();
+				wsOptions.onDisconnected?.(event);
+			}
+		})
+	});
+}
+//#endregion
+//#region src/utils/scope.ts
+/** Whether a name is already namespaced (contains a `:` separator). */
+function isQualifiedName(name) {
+	return name.includes(":");
+}
+/**
+* Prefix a bare name with `<namespace>:`. Names that already contain a
+* `:` are returned unchanged, so callers can reference another scope's
+* ids explicitly (e.g. `ctx.rpc.call('other-plugin:fn')`).
+*/
+function qualifyName(namespace, name) {
+	return isQualifiedName(name) ? name : `${namespace}:${name}`;
+}
+//#endregion
+//#region src/client/settings.ts
+function createClientSettingsStore(rpc, namespace, scope) {
+	const stateKey = `devframe:settings:${scope}:${namespace}`;
+	let statePromise;
+	function store() {
+		if (!statePromise) statePromise = rpc.sharedState.get(stateKey, { initialValue: {} });
+		return statePromise;
+	}
+	return {
+		async get(key) {
+			return (await store()).value()[key];
+		},
+		async set(key, value) {
+			(await store()).mutate((draft) => {
+				draft[key] = value;
+			});
+		},
+		async delete(key) {
+			(await store()).mutate((draft) => {
+				delete draft[key];
+			});
+		},
+		async all() {
+			return (await store()).value();
+		},
+		async onChange(fn) {
+			return (await store()).on("updated", (full) => fn(full));
+		}
+	};
 }
 /**
 * Build the client-side `settings` surface for a scope namespace. Mirrors
@@ -2451,6 +2751,30 @@ function createScopedClientContext(rpc, namespace) {
 }
 //#endregion
 //#region src/client/rpc.ts
+/**
+* Resolve the requested `transport` option against what the server
+* advertises. `'auto'` trusts the advertisement — the server's declared
+* primary (`backend`), preferring the WebSocket when both endpoints are
+* present; an explicit `'websocket'` / `'sse'` pins that transport and
+* throws when the server doesn't advertise it.
+*/
+function resolveClientTransport(requested, meta) {
+	if (meta.backend === "static") return "static";
+	const hasWebsocket = meta.websocket !== void 0;
+	const hasSse = meta.sse !== void 0;
+	if (requested === "websocket") {
+		if (!hasWebsocket) throw new Error("[devframe] transport: 'websocket' was requested, but this server does not advertise a WebSocket endpoint");
+		return "websocket";
+	}
+	if (requested === "sse") {
+		if (!hasSse) throw new Error("[devframe] transport: 'sse' was requested, but this server does not advertise an SSE endpoint");
+		return "sse";
+	}
+	if (meta.backend === "sse" && hasSse) return "sse";
+	if (hasWebsocket) return "websocket";
+	if (hasSse) return "sse";
+	throw new Error("[devframe] This server advertises no RPC transport (backend \"none\") — nothing to connect to. Enable the WebSocket or SSE endpoint on the server, or use its static/MCP surfaces instead.");
+}
 async function getDevframeRpcClient(options = {}) {
 	const { baseURL = "./", rpcOptions = {}, cacheOptions = false } = options;
 	const events = createEventEmitter();
@@ -2480,7 +2804,7 @@ async function getDevframeRpcClient(options = {}) {
 		}
 		throw new Error(`Failed to load ${path} from ${candidates.join(", ")}`, { cause: errors });
 	}
-	const mode = connectionMeta.backend === "static" ? await createStaticRpcClientMode({ fetchJsonFromBases }) : createWsRpcClientMode({
+	const liveModeOptions = {
 		authToken,
 		connectionMeta,
 		metaBaseUrl,
@@ -2497,7 +2821,14 @@ async function getDevframeRpcClient(options = {}) {
 					cacheManager.apply(req, res);
 				} else await next(req);
 			}
-		},
+		}
+	};
+	const transport = resolveClientTransport(options.transport ?? "auto", connectionMeta);
+	const mode = transport === "static" ? await createStaticRpcClientMode({ fetchJsonFromBases }) : transport === "sse" ? createSseRpcClientMode({
+		...liveModeOptions,
+		sseOptions: options.sseOptions
+	}) : createWsRpcClientMode({
+		...liveModeOptions,
 		wsOptions: options.wsOptions
 	});
 	let authChannel;
@@ -2523,6 +2854,9 @@ async function getDevframeRpcClient(options = {}) {
 		get connectionError() {
 			return mode.connectionError;
 		},
+		get transport() {
+			return mode.transport ?? transport;
+		},
 		get connection() {
 			return connection;
 		},
@@ -2560,7 +2894,8 @@ async function getDevframeRpcClient(options = {}) {
 		sharedState: void 0,
 		streaming: void 0,
 		cacheManager,
-		scope: void 0
+		scope: void 0,
+		close: () => mode.close?.()
 	};
 	rpc.sharedState = createRpcSharedStateClientHost(rpc);
 	rpc.streaming = createRpcStreamingClientHost(rpc);
@@ -2614,4 +2949,4 @@ async function getDevframeRpcClient(options = {}) {
 //#region src/client/index.ts
 const connectDevframe = getDevframeRpcClient;
 //#endregion
-export { DevframeConnectionError, authenticateWithUrlOtp, connectDevframe, consumeOtpFromUrl, createClientSettings, createRpcStreamingClientHost, createScopedClientContext, getDevframeConnection, getDevframeRpcClient, isCallableStatus, readOtpFromUrl, registerDevframeViewerOrigin, resolveWsUrl, setupDevframeConnection };
+export { DevframeConnectionError, authenticateWithUrlOtp, connectDevframe, consumeOtpFromUrl, createClientSettings, createRpcStreamingClientHost, createScopedClientContext, getDevframeConnection, getDevframeRpcClient, isCallableStatus, readOtpFromUrl, registerDevframeViewerOrigin, resolveClientTransport, resolveSseUrl, resolveWsUrl, setupDevframeConnection };