devframe 0.9.20 → 0.10.0

package/dist/{dev-BdKKOH8S.mjs → dev-DM1mIlgi.mjs}

@@ -1,17 +1,15 @@
-import { t as resolveClientAssets } from "./client-assets-DNdhagGm.mjs";
 import { DEVFRAME_CONNECTION_META_FILENAME } from "./constants.mjs";
-import { t as diagnostics } from "./diagnostics-DZA6KQ_Z.mjs";
-import { t as createHostContext } from "./context-BLXXjoBW.mjs";
-import { t as resolveStaticAssetsSource } from "./remote-assets-D0StJVLp.mjs";
-import { a as resolveMcpConfig, i as resolveDevServerPort, n as normalizeBasePath, r as resolveBasePath, s as importRuntimeModule, t as loadAutoMcpAdapter } from "./_shared-U8D-xzrp.mjs";
+import { t as diagnostics } from "./diagnostics-Cx4_VjlG.mjs";
+import { t as createHostContext } from "./context-C141q8H4.mjs";
+import { t as resolveStaticAssetsSource } from "./remote-assets-B9MeWmW6.mjs";
+import { a as resolveMcpConfig, c as joinURL, d as withoutLeadingSlash, i as resolveDevServerPort, l as withBase, n as normalizeBasePath, r as resolveBasePath, s as importAgenticMcp, t as loadAutoMcpAdapter } from "./_shared-B2PZsp-J.mjs";
 import { t as createH3DevframeHost } from "./host-h3-BROI6SQ4.mjs";
-import { i as normalizeHttpServerUrl, n as resolveInstanceRegister, t as createInstanceShell } from "./instance-shell-yfrM3_vK.mjs";
+import { i as normalizeHttpServerUrl, n as resolveInstanceRegister, t as createInstanceShell } from "./instance-shell-wC2sfEU_.mjs";
 import { open } from "./utils/open.mjs";
 import { mountStaticHandler } from "./utils/serve-static.mjs";
 import { resolve } from "pathe";
 import { createServer } from "node:http";
 import process from "node:process";
-import { joinURL, withBase, withoutLeadingSlash } from "ufo";
 import { H3, toNodeHandler } from "h3";
 //#region src/adapters/initiate.ts
 const INSTANCE_INTERNALS = /* @__PURE__ */ new WeakMap();
@@ -38,7 +36,7 @@ function getInstanceInternals(handler) {
 */
 function initDevframe(def, options) {
 	const base = normalizeBasePath(options.base);
-	const distDir = options.distDir === false ? void 0 : options.distDir ?? resolveClientAssets(def);
+	const distDir = options.distDir === false ? void 0 : options.distDir ?? def.clientAssets;
 	const app = options.app ?? new H3();
 	const host = options.host ?? def.cli?.host ?? "localhost";
 	const shell = createInstanceShell({
@@ -88,7 +86,7 @@ function initDevframe(def, options) {
 			for (const input of def.services ?? []) context.services.install(input, { resolveFrom: def.importMetaUrl });
 			await context.services.ready();
 			await def.setup(context, setupInfo);
-			const mcp = await mountMcpRoute(app, context, def, base, options.mcp ?? def.cli?.mcp ?? "auto");
+			const mcp = await mountMcpRoute(app, context, def, base, options.mcp ?? "auto");
 			return {
 				context,
 				...mcp?.meta ? { mcp: mcp.meta } : {},
@@ -119,11 +117,14 @@ function initDevframe(def, options) {
 }
 /**
 * Mount the route-based MCP server at `<base>__mcp`, before the SPA static
-* catch-all so the exact route wins. The MCP SDK is pulled in dynamically
-* only when the route mounts, keeping it out of consumer bundles: `'auto'`
-* mounts once `setup()` left a non-empty agent surface (an empty surface
-* loads no MCP code); an explicit setting mounts unconditionally. The
-* resolved config is origin-only unless it opts into a bearer/callback.
+* catch-all so the exact route wins. The adapter (from the optional
+* `@devframes/agentic` peer) is pulled in dynamically only when the route
+* mounts, keeping it and the MCP SDK out of consumer bundles: `'auto'`
+* mounts once `setup()` left a non-empty agent surface AND the peer is
+* installed (an empty surface loads no MCP code; a non-empty one without the
+* peer warns once and mounts nothing); an explicit setting mounts
+* unconditionally, throwing DF0079 when the peer is absent. The resolved
+* config is origin-only unless it opts into a bearer/callback.
 */
 async function mountMcpRoute(app, context, def, base, setting) {
 	let module;
@@ -134,16 +135,7 @@ async function mountMcpRoute(app, context, def, base, setting) {
 	} else config = resolveMcpConfig(setting);
 	if (!config) return void 0;
 	const route = withoutLeadingSlash(config.path ?? "__mcp");
-	if (!module) try {
-		module = await importRuntimeModule("devframe/adapters/mcp");
-	} catch (error) {
-		const reason = error instanceof Error ? error.message : String(error);
-		throw diagnostics.DF0017({
-			transport: "http",
-			reason,
-			cause: error
-		});
-	}
+	module ??= await importAgenticMcp();
 	const mounted = module.mountMcpHttp(app, context, joinURL(base, route), {
 		serverName: `${def.id} (devframe)`,
 		serverVersion: def.version ?? "0.0.0",

package/dist/{diagnostics-DZA6KQ_Z.mjs → diagnostics-Cx4_VjlG.mjs}

@@ -68,8 +68,8 @@ const diagnostics = defineDiagnostics({
 			fix: "Discovery tooling (`devframe connect`) will not see this instance. Check that the registry directory is writable, point `DEVFRAME_INSTANCES_DIR` at a writable directory, or set `DEVFRAME_DISABLE_INSTANCE_REGISTRY=1` to opt out of registration."
 		},
 		DF0046: {
-			why: (p) => `\`devframe connect\` requires the optional peer dependency @modelcontextprotocol/client: ${p.reason}`,
-			fix: "Install it next to devframe (e.g. `npm install @modelcontextprotocol/client`) and run `devframe connect` again."
+			why: (p) => `\`devframe connect\` requires the optional peer dependency @devframes/agentic: ${p.reason}`,
+			fix: "Install it next to devframe (e.g. `npm install @devframes/agentic`) and run `devframe connect` again."
 		},
 		DF0047: {
 			why: (p) => `Agent tool "${p.id}" is hidden from the MCP surface: its wire name "${p.name}" collides with the tool "${p.existing}".`,
@@ -89,7 +89,7 @@ const diagnostics = defineDiagnostics({
 		},
 		DF0051: {
 			why: (p) => `The devframe instance on port ${p.port} has no MCP endpoint.`,
-			fix: "Restart the instance with the --mcp flag (or set `cli.mcp: true` on its definition) to expose its tools, then list instances again."
+			fix: "Restart the instance with the --mcp flag to expose its tools, then list instances again."
 		},
 		DF0052: {
 			why: (p) => `Failed to listen on ${p.host}:${p.port}: ${p.reason}`,
@@ -174,6 +174,14 @@ const diagnostics = defineDiagnostics({
 		DF0076: {
 			why: (p) => `\`attach\` / \`handleUpgrade\` drive a raw \`node:http\` upgrade into crossws's Node adapter, which refuses to run on ${p.runtime}.`,
 			fix: "On Bun/Deno, serve the advertised `__ws` route from `Bun.serve` / `Deno.serve` with `attachBunWsTransport` / `attachDenoWsTransport` (see the hub-deno example), or connect over the SSE endpoint instead."
+		},
+		DF0078: {
+			why: "This devframe exposes agent tools, but the MCP endpoint stays off: the optional peer \"@devframes/agentic\" is not installed.",
+			fix: "Install `@devframes/agentic` next to devframe to serve the MCP endpoint, or set `mcp: false` to opt out silently."
+		},
+		DF0079: {
+			why: (p) => `The \`mcp\` option is enabled, but the optional peer "@devframes/agentic" could not be loaded: ${p.reason}`,
+			fix: "Install `@devframes/agentic` next to devframe (the MCP adapter and the MCP SDK live there), or remove the explicit `mcp` setting."
 		}
 	}
 });

package/dist/dist-Bw3EbMj4.mjs

@@ -0,0 +1,305 @@
+import { colors } from "./utils/colors.mjs";
+import { defineDiagnostics } from "nostics";
+import { ansiFormatter } from "nostics/formatters/ansi";
+//#region src/events.ts
+/**
+* Centralized registry of the core devframe event names: the node-side host
+* bus events, the client RPC connection events, and the server→client
+* broadcast notifications, so these names live in one place instead of
+* scattered string literals.
+*
+* **Keep this in sync with [`docs/content/8.references/3.events.md`](../../../docs/content/8.references/3.events.md)**
+* (the "Core devframe events" section): every name here appears in that page's
+* tables, and every name there resolves to an entry here. Add, rename, or
+* remove a name in both places in the same change, and reference
+* `DEVFRAME_EVENTS.*` from call sites instead of re-typing a literal.
+*
+* This map covers **notifications** (events, broadcasts). The request/response
+* RPC endpoints of the shared-state, streaming, and auth-handshake protocols
+* (`devframe:rpc:server-state:*`, `devframe:streaming:subscribe`,
+* `anonymous:devframe:auth`, …) are defined at their handlers and typed in
+* `types/rpc-augments.ts`; they aren't events and stay out of this map.
+*
+* The `EventEmitter` maps (`RpcClientEvents`, `DevframeAgentHostEvents`) and the
+* `DevframeRpcClientFunctions` augmentation declare these names as type-level
+* keys (a literal is unavoidable in a type position); those declarations mirror
+* this map and move with it.
+*/
+const DEVFRAME_EVENTS = {
+	/**
+	* Node-side host `EventEmitter` events. The agent host (`ctx.agent.events`)
+	* emits these as its tool/resource surface changes; protocol adapters (e.g.
+	* MCP) subscribe to re-publish their manifest.
+	*/
+	bus: {
+		agentManifestChanged: "agent:manifest:changed",
+		agentToolRegistered: "agent:tool:registered",
+		agentToolUnregistered: "agent:tool:unregistered",
+		agentResourceRegistered: "agent:resource:registered",
+		agentResourceUnregistered: "agent:resource:unregistered"
+	},
+	/**
+	* Client-side RPC connection `EventEmitter` events (`rpc.events`) a UI
+	* subscribes to for connection lifecycle and error surfacing.
+	*/
+	client: {
+		isTrustedUpdated: "rpc:is-trusted:updated",
+		error: "rpc:error",
+		connectionStatus: "connection:status",
+		connectionError: "connection:error"
+	},
+	/**
+	* Broadcast notifications the server pushes to clients (server → client),
+	* `devframe:` prefix. The paired request methods (subscribe/get/set/…) are
+	* RPC endpoints, not events, and are omitted deliberately.
+	*/
+	broadcast: {
+		authRevoked: "devframe:auth:revoked",
+		clientStateUpdated: "devframe:rpc:client-state:updated",
+		clientStatePatch: "devframe:rpc:client-state:patch",
+		streamingChunk: "devframe:streaming:chunk",
+		streamingEnd: "devframe:streaming:end",
+		streamingUploadCancel: "devframe:streaming:upload-cancel"
+	},
+	/**
+	* In-page channel notifications the page script pushes to its panels
+	* (page script → panel), `devframe:` prefix. The paired request methods
+	* (`devframe:in-page:page-state:subscribe`/`set`/`patch`) are call
+	* endpoints, not events, and are defined at their handlers
+	* (`in-page-channel/state.ts`).
+	*/
+	inPageChannel: {
+		panelStateUpdated: "devframe:in-page:panel-state:updated",
+		panelStatePatch: "devframe:in-page:panel-state:patch"
+	},
+	/** `postMessage` channels the runtime posts across window boundaries. */
+	postMessage: {
+		remoteAssetsError: "devframe:remote-assets-error",
+		inPageChannel: "devframe:in-page-channel"
+	}
+};
+//#endregion
+//#region src/utils/nostics.ts
+const formatAnsi = ansiFormatter(colors);
+/**
+* The reporter every {@link defineDiagnostics} call below wires in ahead of
+* any caller-supplied ones: prints the diagnostic through devframe's own
+* ANSI colors via `console[method]` (default `'warn'`).
+*/
+function devframeReporter(d, { method = "warn" } = {}) {
+	console[method](formatAnsi(d));
+}
+/**
+* Drop-in replacement for `nostics`'s `defineDiagnostics()` with devframe's
+* ANSI console reporter pre-wired ahead of any `reporters` passed in. Every
+* `diagnostics.ts` in devframe core, `@devframes/hub`, `@devframes/json-render`,
+* and the built-in plugins defines its codes through this instead of
+* `nostics`'s own `defineDiagnostics`; the reporter registration lives
+* here, once, so none of them need to build their own reporter (`colors`,
+* `ansiFormatter`) or take a direct dependency on `nostics` themselves.
+*/
+function defineDiagnostics$1(options) {
+	return defineDiagnostics({
+		...options,
+		reporters: [devframeReporter, ...options.reporters ?? []]
+	});
+}
+//#endregion
+//#region ../../node_modules/.pnpm/birpc@4.2.0/node_modules/birpc/dist/index.mjs
+function createPromiseWithResolvers() {
+	let resolve;
+	let reject;
+	return {
+		promise: new Promise((res, rej) => {
+			resolve = res;
+			reject = rej;
+		}),
+		resolve,
+		reject
+	};
+}
+const random = Math.random.bind(Math);
+const urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+function nanoid(size = 21) {
+	let id = "";
+	let i = size;
+	while (i--) id += urlAlphabet[random() * 64 | 0];
+	return id;
+}
+const DEFAULT_TIMEOUT = 6e4;
+const defaultSerialize = (i) => i;
+const defaultDeserialize = defaultSerialize;
+const { clearTimeout, setTimeout } = globalThis;
+function createBirpc($functions, options) {
+	const { post, on, off = () => {}, eventNames = [], serialize = defaultSerialize, deserialize = defaultDeserialize, resolver, bind = "rpc", timeout = DEFAULT_TIMEOUT, proxify = true } = options;
+	let $closed = false;
+	const _rpcPromiseMap = /* @__PURE__ */ new Map();
+	let _promiseInit;
+	let rpc;
+	async function _call(method, args, event, optional) {
+		if ($closed) throw new Error(`[birpc] rpc is closed, cannot call "${method}"`);
+		const req = {
+			m: method,
+			a: args,
+			t: "q"
+		};
+		if (optional) req.o = true;
+		const send = async (_req) => post(serialize(_req));
+		if (event) {
+			await send(req);
+			return;
+		}
+		if (_promiseInit) try {
+			await _promiseInit;
+		} finally {
+			_promiseInit = void 0;
+		}
+		let { promise, resolve, reject } = createPromiseWithResolvers();
+		const id = nanoid();
+		req.i = id;
+		let timeoutId;
+		async function handler(newReq = req) {
+			if (timeout >= 0) {
+				timeoutId = setTimeout(() => {
+					try {
+						if (options.onTimeoutError?.call(rpc, method, args) !== true) throw new Error(`[birpc] timeout on calling "${method}"`);
+					} catch (e) {
+						reject(e);
+					}
+					_rpcPromiseMap.delete(id);
+				}, timeout);
+				if (typeof timeoutId === "object") timeoutId = timeoutId.unref?.();
+			}
+			_rpcPromiseMap.set(id, {
+				resolve,
+				reject,
+				timeoutId,
+				method
+			});
+			await send(newReq);
+			return promise;
+		}
+		try {
+			if (options.onRequest) await options.onRequest.call(rpc, req, handler, resolve);
+			else await handler();
+		} catch (e) {
+			if (options.onGeneralError?.call(rpc, e) !== true) throw e;
+			return;
+		} finally {
+			clearTimeout(timeoutId);
+			_rpcPromiseMap.delete(id);
+		}
+		return promise;
+	}
+	const builtinMethods = {
+		$call: (method, ...args) => _call(method, args, false),
+		$callOptional: (method, ...args) => _call(method, args, false, true),
+		$callEvent: (method, ...args) => _call(method, args, true),
+		$callRaw: (options) => _call(options.method, options.args, options.event, options.optional),
+		$rejectPendingCalls,
+		get $closed() {
+			return $closed;
+		},
+		get $meta() {
+			return options.meta;
+		},
+		$close,
+		$functions
+	};
+	if (proxify) rpc = new Proxy({}, { get(_, method) {
+		if (Object.hasOwn(builtinMethods, method)) return builtinMethods[method];
+		if (method === "then" && !eventNames.includes("then") && !("then" in $functions)) return void 0;
+		const sendEvent = (...args) => _call(method, args, true);
+		if (eventNames.includes(method)) {
+			sendEvent.asEvent = sendEvent;
+			return sendEvent;
+		}
+		const sendCall = (...args) => _call(method, args, false);
+		sendCall.asEvent = sendEvent;
+		return sendCall;
+	} });
+	else rpc = builtinMethods;
+	function $close(customError) {
+		$closed = true;
+		_rpcPromiseMap.forEach(({ reject, method }) => {
+			const error = /* @__PURE__ */ new Error(`[birpc] rpc is closed, cannot call "${method}"`);
+			if (customError) {
+				customError.cause ??= error;
+				return reject(customError);
+			}
+			reject(error);
+		});
+		_rpcPromiseMap.clear();
+		off(onMessage);
+	}
+	function $rejectPendingCalls(handler) {
+		const handlerResults = Array.from(_rpcPromiseMap.values()).map(({ method, reject }) => {
+			if (!handler) return reject(/* @__PURE__ */ new Error(`[birpc]: rejected pending call "${method}".`));
+			return handler({
+				method,
+				reject
+			});
+		});
+		_rpcPromiseMap.clear();
+		return handlerResults;
+	}
+	async function onMessage(data, ...extra) {
+		let msg;
+		try {
+			msg = deserialize(data);
+		} catch (e) {
+			if (options.onGeneralError?.call(rpc, e) !== true) throw e;
+			return;
+		}
+		if (msg.t === "q") {
+			const { m: method, a: args, o: optional } = msg;
+			let result, error;
+			let fn = await (resolver ? resolver.call(rpc, method, $functions[method]) : $functions[method]);
+			if (optional) fn ||= () => void 0;
+			if (!fn) error = /* @__PURE__ */ new Error(`[birpc] function "${method}" not found`);
+			else try {
+				result = await fn.apply(bind === "rpc" ? rpc : $functions, args);
+			} catch (e) {
+				error = e;
+			}
+			if (msg.i) {
+				if (error && options.onFunctionError) {
+					if (options.onFunctionError.call(rpc, error, method, args) === true) return;
+				}
+				if (!error) try {
+					await post(serialize({
+						t: "s",
+						i: msg.i,
+						r: result
+					}), ...extra);
+					return;
+				} catch (e) {
+					error = e;
+					if (options.onGeneralError?.call(rpc, e, method, args) !== true) throw e;
+				}
+				try {
+					await post(serialize({
+						t: "s",
+						i: msg.i,
+						e: error
+					}), ...extra);
+				} catch (e) {
+					if (options.onGeneralError?.call(rpc, e, method, args) !== true) throw e;
+				}
+			}
+		} else {
+			const { i: ack, r: result, e: error } = msg;
+			const promise = _rpcPromiseMap.get(ack);
+			if (promise) {
+				clearTimeout(promise.timeoutId);
+				if (error) promise.reject(error);
+				else promise.resolve(result);
+			}
+			_rpcPromiseMap.delete(ack);
+		}
+	}
+	_promiseInit = on(onMessage);
+	return rpc;
+}
+//#endregion
+export { defineDiagnostics$1 as n, DEVFRAME_EVENTS as r, createBirpc as t };

package/dist/dist-CO98PBnQ.mjs

@@ -0,0 +1,265 @@
+//#region ../../node_modules/.pnpm/birpc@4.2.0/node_modules/birpc/dist/index.mjs
+function createPromiseWithResolvers() {
+	let resolve;
+	let reject;
+	return {
+		promise: new Promise((res, rej) => {
+			resolve = res;
+			reject = rej;
+		}),
+		resolve,
+		reject
+	};
+}
+const _cacheMap = /* @__PURE__ */ new WeakMap();
+function cachedMap(items, fn) {
+	return items.map((i) => {
+		let r = _cacheMap.get(i);
+		if (!r) {
+			r = fn(i);
+			_cacheMap.set(i, r);
+		}
+		return r;
+	});
+}
+const random = Math.random.bind(Math);
+const urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+function nanoid(size = 21) {
+	let id = "";
+	let i = size;
+	while (i--) id += urlAlphabet[random() * 64 | 0];
+	return id;
+}
+const DEFAULT_TIMEOUT = 6e4;
+const defaultSerialize = (i) => i;
+const defaultDeserialize = defaultSerialize;
+const { clearTimeout, setTimeout } = globalThis;
+function createBirpc($functions, options) {
+	const { post, on, off = () => {}, eventNames = [], serialize = defaultSerialize, deserialize = defaultDeserialize, resolver, bind = "rpc", timeout = DEFAULT_TIMEOUT, proxify = true } = options;
+	let $closed = false;
+	const _rpcPromiseMap = /* @__PURE__ */ new Map();
+	let _promiseInit;
+	let rpc;
+	async function _call(method, args, event, optional) {
+		if ($closed) throw new Error(`[birpc] rpc is closed, cannot call "${method}"`);
+		const req = {
+			m: method,
+			a: args,
+			t: "q"
+		};
+		if (optional) req.o = true;
+		const send = async (_req) => post(serialize(_req));
+		if (event) {
+			await send(req);
+			return;
+		}
+		if (_promiseInit) try {
+			await _promiseInit;
+		} finally {
+			_promiseInit = void 0;
+		}
+		let { promise, resolve, reject } = createPromiseWithResolvers();
+		const id = nanoid();
+		req.i = id;
+		let timeoutId;
+		async function handler(newReq = req) {
+			if (timeout >= 0) {
+				timeoutId = setTimeout(() => {
+					try {
+						if (options.onTimeoutError?.call(rpc, method, args) !== true) throw new Error(`[birpc] timeout on calling "${method}"`);
+					} catch (e) {
+						reject(e);
+					}
+					_rpcPromiseMap.delete(id);
+				}, timeout);
+				if (typeof timeoutId === "object") timeoutId = timeoutId.unref?.();
+			}
+			_rpcPromiseMap.set(id, {
+				resolve,
+				reject,
+				timeoutId,
+				method
+			});
+			await send(newReq);
+			return promise;
+		}
+		try {
+			if (options.onRequest) await options.onRequest.call(rpc, req, handler, resolve);
+			else await handler();
+		} catch (e) {
+			if (options.onGeneralError?.call(rpc, e) !== true) throw e;
+			return;
+		} finally {
+			clearTimeout(timeoutId);
+			_rpcPromiseMap.delete(id);
+		}
+		return promise;
+	}
+	const builtinMethods = {
+		$call: (method, ...args) => _call(method, args, false),
+		$callOptional: (method, ...args) => _call(method, args, false, true),
+		$callEvent: (method, ...args) => _call(method, args, true),
+		$callRaw: (options) => _call(options.method, options.args, options.event, options.optional),
+		$rejectPendingCalls,
+		get $closed() {
+			return $closed;
+		},
+		get $meta() {
+			return options.meta;
+		},
+		$close,
+		$functions
+	};
+	if (proxify) rpc = new Proxy({}, { get(_, method) {
+		if (Object.hasOwn(builtinMethods, method)) return builtinMethods[method];
+		if (method === "then" && !eventNames.includes("then") && !("then" in $functions)) return void 0;
+		const sendEvent = (...args) => _call(method, args, true);
+		if (eventNames.includes(method)) {
+			sendEvent.asEvent = sendEvent;
+			return sendEvent;
+		}
+		const sendCall = (...args) => _call(method, args, false);
+		sendCall.asEvent = sendEvent;
+		return sendCall;
+	} });
+	else rpc = builtinMethods;
+	function $close(customError) {
+		$closed = true;
+		_rpcPromiseMap.forEach(({ reject, method }) => {
+			const error = /* @__PURE__ */ new Error(`[birpc] rpc is closed, cannot call "${method}"`);
+			if (customError) {
+				customError.cause ??= error;
+				return reject(customError);
+			}
+			reject(error);
+		});
+		_rpcPromiseMap.clear();
+		off(onMessage);
+	}
+	function $rejectPendingCalls(handler) {
+		const handlerResults = Array.from(_rpcPromiseMap.values()).map(({ method, reject }) => {
+			if (!handler) return reject(/* @__PURE__ */ new Error(`[birpc]: rejected pending call "${method}".`));
+			return handler({
+				method,
+				reject
+			});
+		});
+		_rpcPromiseMap.clear();
+		return handlerResults;
+	}
+	async function onMessage(data, ...extra) {
+		let msg;
+		try {
+			msg = deserialize(data);
+		} catch (e) {
+			if (options.onGeneralError?.call(rpc, e) !== true) throw e;
+			return;
+		}
+		if (msg.t === "q") {
+			const { m: method, a: args, o: optional } = msg;
+			let result, error;
+			let fn = await (resolver ? resolver.call(rpc, method, $functions[method]) : $functions[method]);
+			if (optional) fn ||= () => void 0;
+			if (!fn) error = /* @__PURE__ */ new Error(`[birpc] function "${method}" not found`);
+			else try {
+				result = await fn.apply(bind === "rpc" ? rpc : $functions, args);
+			} catch (e) {
+				error = e;
+			}
+			if (msg.i) {
+				if (error && options.onFunctionError) {
+					if (options.onFunctionError.call(rpc, error, method, args) === true) return;
+				}
+				if (!error) try {
+					await post(serialize({
+						t: "s",
+						i: msg.i,
+						r: result
+					}), ...extra);
+					return;
+				} catch (e) {
+					error = e;
+					if (options.onGeneralError?.call(rpc, e, method, args) !== true) throw e;
+				}
+				try {
+					await post(serialize({
+						t: "s",
+						i: msg.i,
+						e: error
+					}), ...extra);
+				} catch (e) {
+					if (options.onGeneralError?.call(rpc, e, method, args) !== true) throw e;
+				}
+			}
+		} else {
+			const { i: ack, r: result, e: error } = msg;
+			const promise = _rpcPromiseMap.get(ack);
+			if (promise) {
+				clearTimeout(promise.timeoutId);
+				if (error) promise.reject(error);
+				else promise.resolve(result);
+			}
+			_rpcPromiseMap.delete(ack);
+		}
+	}
+	_promiseInit = on(onMessage);
+	return rpc;
+}
+function createBirpcGroup(functions, channels, options = {}) {
+	const { proxify = true } = options;
+	const getChannels = () => typeof channels === "function" ? channels() : channels;
+	const getClients = (channels = getChannels()) => cachedMap(channels, (s) => createBirpc(functions, {
+		...options,
+		...s
+	}));
+	function _boardcast(options) {
+		const clients = getClients();
+		return Promise.all(clients.map((c) => c.$callRaw(options)));
+	}
+	const broadcastBuiltin = {
+		$call: (method, ...args) => _boardcast({
+			method,
+			args,
+			event: false
+		}),
+		$callOptional: (method, ...args) => _boardcast({
+			method,
+			args,
+			event: false,
+			optional: true
+		}),
+		$callEvent: (method, ...args) => _boardcast({
+			method,
+			args,
+			event: true
+		}),
+		$callRaw: (options) => _boardcast(options)
+	};
+	const broadcastProxy = proxify ? new Proxy({}, { get(_, method) {
+		if (Object.hasOwn(broadcastBuiltin, method)) return broadcastBuiltin[method];
+		const callbacks = getClients().map((c) => c[method]);
+		const sendCall = (...args) => {
+			return Promise.all(callbacks.map((i) => i(...args)));
+		};
+		sendCall.asEvent = async (...args) => {
+			await Promise.all(callbacks.map((i) => i.asEvent(...args)));
+		};
+		return sendCall;
+	} }) : broadcastBuiltin;
+	function updateChannels(fn) {
+		const channels = getChannels();
+		fn?.(channels);
+		return getClients(channels);
+	}
+	getClients();
+	return {
+		get clients() {
+			return getClients();
+		},
+		functions,
+		updateChannels,
+		broadcast: broadcastProxy
+	};
+}
+//#endregion
+export { createBirpcGroup as n, createBirpc as t };