devframe 0.1.21 → 0.2.0

package/dist/hash-CIBte1yS.mjs

@@ -0,0 +1,263 @@
+//#region ../../node_modules/.pnpm/ohash@2.0.11/node_modules/ohash/dist/shared/ohash.D__AXeF1.mjs
+function serialize(o) {
+	return typeof o == "string" ? `'${o}'` : new c().serialize(o);
+}
+const c = /* @__PURE__ */ function() {
+	class o {
+		#t = /* @__PURE__ */ new Map();
+		compare(t, r) {
+			const e = typeof t, n = typeof r;
+			return e === "string" && n === "string" ? t.localeCompare(r) : e === "number" && n === "number" ? t - r : String.prototype.localeCompare.call(this.serialize(t, true), this.serialize(r, true));
+		}
+		serialize(t, r) {
+			if (t === null) return "null";
+			switch (typeof t) {
+				case "string": return r ? t : `'${t}'`;
+				case "bigint": return `${t}n`;
+				case "object": return this.$object(t);
+				case "function": return this.$function(t);
+			}
+			return String(t);
+		}
+		serializeObject(t) {
+			const r = Object.prototype.toString.call(t);
+			if (r !== "[object Object]") return this.serializeBuiltInType(r.length < 10 ? `unknown:${r}` : r.slice(8, -1), t);
+			const e = t.constructor, n = e === Object || e === void 0 ? "" : e.name;
+			if (n !== "" && globalThis[n] === e) return this.serializeBuiltInType(n, t);
+			if (typeof t.toJSON == "function") {
+				const i = t.toJSON();
+				return n + (i !== null && typeof i == "object" ? this.$object(i) : `(${this.serialize(i)})`);
+			}
+			return this.serializeObjectEntries(n, Object.entries(t));
+		}
+		serializeBuiltInType(t, r) {
+			const e = this["$" + t];
+			if (e) return e.call(this, r);
+			if (typeof r?.entries == "function") return this.serializeObjectEntries(t, r.entries());
+			throw new Error(`Cannot serialize ${t}`);
+		}
+		serializeObjectEntries(t, r) {
+			const e = Array.from(r).sort((i, a) => this.compare(i[0], a[0]));
+			let n = `${t}{`;
+			for (let i = 0; i < e.length; i++) {
+				const [a, l] = e[i];
+				n += `${this.serialize(a, true)}:${this.serialize(l)}`, i < e.length - 1 && (n += ",");
+			}
+			return n + "}";
+		}
+		$object(t) {
+			let r = this.#t.get(t);
+			return r === void 0 && (this.#t.set(t, `#${this.#t.size}`), r = this.serializeObject(t), this.#t.set(t, r)), r;
+		}
+		$function(t) {
+			const r = Function.prototype.toString.call(t);
+			return r.slice(-15) === "[native code] }" ? `${t.name || ""}()[native]` : `${t.name}(${t.length})${r.replace(/\s*\n\s*/g, "")}`;
+		}
+		$Array(t) {
+			let r = "[";
+			for (let e = 0; e < t.length; e++) r += this.serialize(t[e]), e < t.length - 1 && (r += ",");
+			return r + "]";
+		}
+		$Date(t) {
+			try {
+				return `Date(${t.toISOString()})`;
+			} catch {
+				return "Date(null)";
+			}
+		}
+		$ArrayBuffer(t) {
+			return `ArrayBuffer[${new Uint8Array(t).join(",")}]`;
+		}
+		$Set(t) {
+			return `Set${this.$Array(Array.from(t).sort((r, e) => this.compare(r, e)))}`;
+		}
+		$Map(t) {
+			return this.serializeObjectEntries("Map", t.entries());
+		}
+	}
+	for (const s of [
+		"Error",
+		"RegExp",
+		"URL"
+	]) o.prototype["$" + s] = function(t) {
+		return `${s}(${t})`;
+	};
+	for (const s of [
+		"Int8Array",
+		"Uint8Array",
+		"Uint8ClampedArray",
+		"Int16Array",
+		"Uint16Array",
+		"Int32Array",
+		"Uint32Array",
+		"Float32Array",
+		"Float64Array"
+	]) o.prototype["$" + s] = function(t) {
+		return `${s}[${t.join(",")}]`;
+	};
+	for (const s of ["BigInt64Array", "BigUint64Array"]) o.prototype["$" + s] = function(t) {
+		return `${s}[${t.join("n,")}${t.length > 0 ? "n" : ""}]`;
+	};
+	return o;
+}();
+//#endregion
+//#region ../../node_modules/.pnpm/ohash@2.0.11/node_modules/ohash/dist/crypto/js/index.mjs
+const z = [
+	1779033703,
+	-1150833019,
+	1013904242,
+	-1521486534,
+	1359893119,
+	-1694144372,
+	528734635,
+	1541459225
+], R = [
+	1116352408,
+	1899447441,
+	-1245643825,
+	-373957723,
+	961987163,
+	1508970993,
+	-1841331548,
+	-1424204075,
+	-670586216,
+	310598401,
+	607225278,
+	1426881987,
+	1925078388,
+	-2132889090,
+	-1680079193,
+	-1046744716,
+	-459576895,
+	-272742522,
+	264347078,
+	604807628,
+	770255983,
+	1249150122,
+	1555081692,
+	1996064986,
+	-1740746414,
+	-1473132947,
+	-1341970488,
+	-1084653625,
+	-958395405,
+	-710438585,
+	113926993,
+	338241895,
+	666307205,
+	773529912,
+	1294757372,
+	1396182291,
+	1695183700,
+	1986661051,
+	-2117940946,
+	-1838011259,
+	-1564481375,
+	-1474664885,
+	-1035236496,
+	-949202525,
+	-778901479,
+	-694614492,
+	-200395387,
+	275423344,
+	430227734,
+	506948616,
+	659060556,
+	883997877,
+	958139571,
+	1322822218,
+	1537002063,
+	1747873779,
+	1955562222,
+	2024104815,
+	-2067236844,
+	-1933114872,
+	-1866530822,
+	-1538233109,
+	-1090935817,
+	-965641998
+], S = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_", r = [];
+var k = class {
+	_data = new l();
+	_hash = new l([...z]);
+	_nDataBytes = 0;
+	_minBufferSize = 0;
+	finalize(e) {
+		e && this._append(e);
+		const s = this._nDataBytes * 8, t = this._data.sigBytes * 8;
+		return this._data.words[t >>> 5] |= 128 << 24 - t % 32, this._data.words[(t + 64 >>> 9 << 4) + 14] = Math.floor(s / 4294967296), this._data.words[(t + 64 >>> 9 << 4) + 15] = s, this._data.sigBytes = this._data.words.length * 4, this._process(), this._hash;
+	}
+	_doProcessBlock(e, s) {
+		const t = this._hash.words;
+		let i = t[0], o = t[1], a = t[2], c = t[3], h = t[4], g = t[5], f = t[6], y = t[7];
+		for (let n = 0; n < 64; n++) {
+			if (n < 16) r[n] = e[s + n] | 0;
+			else {
+				const d = r[n - 15], j = (d << 25 | d >>> 7) ^ (d << 14 | d >>> 18) ^ d >>> 3, B = r[n - 2], x = (B << 15 | B >>> 17) ^ (B << 13 | B >>> 19) ^ B >>> 10;
+				r[n] = j + r[n - 7] + x + r[n - 16];
+			}
+			const m = h & g ^ ~h & f, p = i & o ^ i & a ^ o & a, u = (i << 30 | i >>> 2) ^ (i << 19 | i >>> 13) ^ (i << 10 | i >>> 22), b = (h << 26 | h >>> 6) ^ (h << 21 | h >>> 11) ^ (h << 7 | h >>> 25), w = y + b + m + R[n] + r[n], M = u + p;
+			y = f, f = g, g = h, h = c + w | 0, c = a, a = o, o = i, i = w + M | 0;
+		}
+		t[0] = t[0] + i | 0, t[1] = t[1] + o | 0, t[2] = t[2] + a | 0, t[3] = t[3] + c | 0, t[4] = t[4] + h | 0, t[5] = t[5] + g | 0, t[6] = t[6] + f | 0, t[7] = t[7] + y | 0;
+	}
+	_append(e) {
+		typeof e == "string" && (e = l.fromUtf8(e)), this._data.concat(e), this._nDataBytes += e.sigBytes;
+	}
+	_process(e) {
+		let s, t = this._data.sigBytes / 64;
+		e ? t = Math.ceil(t) : t = Math.max((t | 0) - this._minBufferSize, 0);
+		const i = t * 16, o = Math.min(i * 4, this._data.sigBytes);
+		if (i) {
+			for (let a = 0; a < i; a += 16) this._doProcessBlock(this._data.words, a);
+			s = this._data.words.splice(0, i), this._data.sigBytes -= o;
+		}
+		return new l(s, o);
+	}
+};
+var l = class l {
+	words;
+	sigBytes;
+	constructor(e, s) {
+		e = this.words = e || [], this.sigBytes = s === void 0 ? e.length * 4 : s;
+	}
+	static fromUtf8(e) {
+		const s = unescape(encodeURIComponent(e)), t = s.length, i = [];
+		for (let o = 0; o < t; o++) i[o >>> 2] |= (s.charCodeAt(o) & 255) << 24 - o % 4 * 8;
+		return new l(i, t);
+	}
+	toBase64() {
+		const e = [];
+		for (let s = 0; s < this.sigBytes; s += 3) {
+			const t = this.words[s >>> 2] >>> 24 - s % 4 * 8 & 255, i = this.words[s + 1 >>> 2] >>> 24 - (s + 1) % 4 * 8 & 255, o = this.words[s + 2 >>> 2] >>> 24 - (s + 2) % 4 * 8 & 255, a = t << 16 | i << 8 | o;
+			for (let c = 0; c < 4 && s * 8 + c * 6 < this.sigBytes * 8; c++) e.push(S.charAt(a >>> 6 * (3 - c) & 63));
+		}
+		return e.join("");
+	}
+	concat(e) {
+		if (this.words[this.sigBytes >>> 2] &= 4294967295 << 32 - this.sigBytes % 4 * 8, this.words.length = Math.ceil(this.sigBytes / 4), this.sigBytes % 4) for (let s = 0; s < e.sigBytes; s++) {
+			const t = e.words[s >>> 2] >>> 24 - s % 4 * 8 & 255;
+			this.words[this.sigBytes + s >>> 2] |= t << 24 - (this.sigBytes + s) % 4 * 8;
+		}
+		else for (let s = 0; s < e.sigBytes; s += 4) this.words[this.sigBytes + s >>> 2] = e.words[s >>> 2];
+		this.sigBytes += e.sigBytes;
+	}
+};
+function digest(_) {
+	return new k().finalize(_).toBase64();
+}
+//#endregion
+//#region ../../node_modules/.pnpm/ohash@2.0.11/node_modules/ohash/dist/index.mjs
+function hash$1(input) {
+	return digest(serialize(input));
+}
+//#endregion
+//#region src/utils/hash.ts
+/**
+* Stable, deterministic hash of any structured-cloneable value.
+*/
+function hash(value) {
+	return hash$1(value);
+}
+//#endregion
+export { hash as t };

package/dist/helpers/vite.d.mts

@@ -0,0 +1,65 @@
+import { r as DevframeDefinition } from "../devframe-R5Ex5K5L.mjs";
+
+//#region src/helpers/vite.d.ts
+interface ViteDevBridgeOptions {
+  /**
+   * Mount base. Defaults to `def.basePath ?? '/__<id>/'` for this hosted
+   * adapter — the devframe shares the origin with the host Vite app.
+   *
+   * Relative spellings like `'./'` (common for base-agnostic Nuxt builds)
+   * are normalized to absolute paths so they compose with Vite's connect
+   * router.
+   */
+  base?: string;
+  /**
+   * Dev-time middleware mode. When set, the host app owns the SPA and
+   * devframe spins up a separate RPC + WS server on a resolved port,
+   * registering Vite middleware at `<base>__connection.json` so the
+   * host-served SPA can discover the WS endpoint.
+   *
+   *  - `false` (default) — static-mount the SPA at `base` with SPA
+   *    fallback. No RPC server is started.
+   *  - `true` — bridge mode with all defaults (port from
+   *    {@link resolveDevServerPort}, host from `def.cli?.host`).
+   *  - object — bridge mode with explicit overrides.
+   */
+  devMiddleware?: boolean | {
+    /** Override the bridge port. Default: {@link resolveDevServerPort}. */port?: number; /** Override the bridge bind host. Default: `def.cli?.host ?? 'localhost'`. */
+    host?: string; /** Flag bag forwarded to `def.setup(ctx, { flags })`. */
+    flags?: Record<string, unknown>;
+  };
+}
+interface DevframeVitePlugin {
+  name: string;
+  apply: 'serve';
+  configureServer: (server: {
+    middlewares: {
+      use: (path: string, handler: any) => void;
+    };
+    httpServer?: {
+      once: (event: 'close', cb: () => void) => void;
+    } | null;
+  }) => void | Promise<void>;
+  closeBundle?: () => void | Promise<void>;
+}
+/**
+ * Bridge a devframe into an existing Vite dev server. Returns a Vite
+ * plugin with two modes, picked via `options.devMiddleware`:
+ *
+ *   - **static-mount mode** (default) — mounts `def.cli.distDir` at
+ *     `options.base` with SPA fallback enabled. No RPC server is started.
+ *
+ *   - **bridge mode** (`devMiddleware: true | {…}`) — skips the static
+ *     mount; the host app owns the SPA. Devframe starts a separate
+ *     RPC + WS dev server (via {@link createDevServer} in bridge mode)
+ *     and registers Vite middleware at `<base>__connection.json` so the
+ *     host-served SPA can discover the WS endpoint via
+ *     {@link connectDevframe}.
+ *
+ * Use bridge mode when integrating with frameworks that own the SPA
+ * (Nuxt, Astro, SolidStart, plain Vite apps). For the all-in-one
+ * `dev` / `build` / `mcp` shell, reach for {@link createCli} instead.
+ */
+declare function viteDevBridge(d: DevframeDefinition, options?: ViteDevBridgeOptions): DevframeVitePlugin;
+//#endregion
+export { DevframeVitePlugin, ViteDevBridgeOptions, viteDevBridge };

package/dist/helpers/vite.mjs

@@ -0,0 +1,94 @@
+import { n as logger } from "../diagnostics-Cg9ycFIM.mjs";
+import { DEVTOOLS_CONNECTION_META_FILENAME } from "../constants.mjs";
+import { n as resolveBasePath } from "../_shared-BrKv3CYt.mjs";
+import { serveStaticNodeMiddleware } from "../utils/serve-static.mjs";
+import { n as resolveDevServerPort, t as createDevServer } from "../dev-CewNNE2R.mjs";
+import { resolve } from "pathe";
+//#region src/helpers/vite.ts
+/**
+* Bridge a devframe into an existing Vite dev server. Returns a Vite
+* plugin with two modes, picked via `options.devMiddleware`:
+*
+*   - **static-mount mode** (default) — mounts `def.cli.distDir` at
+*     `options.base` with SPA fallback enabled. No RPC server is started.
+*
+*   - **bridge mode** (`devMiddleware: true | {…}`) — skips the static
+*     mount; the host app owns the SPA. Devframe starts a separate
+*     RPC + WS dev server (via {@link createDevServer} in bridge mode)
+*     and registers Vite middleware at `<base>__connection.json` so the
+*     host-served SPA can discover the WS endpoint via
+*     {@link connectDevframe}.
+*
+* Use bridge mode when integrating with frameworks that own the SPA
+* (Nuxt, Astro, SolidStart, plain Vite apps). For the all-in-one
+* `dev` / `build` / `mcp` shell, reach for {@link createCli} instead.
+*/
+function viteDevBridge(d, options = {}) {
+	const base = normalizeMountBase(options.base ?? resolveBasePath(d, "hosted"));
+	if (!options.devMiddleware) {
+		const distDir = d.cli?.distDir;
+		return {
+			name: `devframe:${d.id}`,
+			apply: "serve",
+			configureServer(server) {
+				if (!distDir) return;
+				server.middlewares.use(base, serveStaticNodeMiddleware(resolve(distDir)));
+			}
+		};
+	}
+	const mw = options.devMiddleware === true ? {} : options.devMiddleware;
+	let started;
+	return {
+		name: `devframe:${d.id}`,
+		apply: "serve",
+		async configureServer(server) {
+			await started?.close().catch(() => {});
+			started = void 0;
+			let port;
+			try {
+				port = mw.port ?? await resolveDevServerPort(d, { host: mw.host });
+				started = await createDevServer(d, {
+					host: mw.host,
+					port,
+					flags: mw.flags,
+					openBrowser: false
+				});
+			} catch (e) {
+				logger.DF0033({
+					id: d.id,
+					reason: String(e)
+				}, { cause: e }).log();
+				return;
+			}
+			const metaPath = `${base}${DEVTOOLS_CONNECTION_META_FILENAME}`;
+			server.middlewares.use(metaPath, (_req, res) => {
+				res.setHeader("Content-Type", "application/json");
+				res.end(JSON.stringify({
+					backend: "websocket",
+					websocket: port
+				}));
+			});
+			server.httpServer?.once("close", () => {
+				started?.close().catch(() => {});
+			});
+		},
+		async closeBundle() {
+			await started?.close().catch(() => {});
+			started = void 0;
+		}
+	};
+}
+/**
+* Make `base` safe for `server.middlewares.use(path, …)`. Vite's connect
+* router matches by absolute URL prefix, so relative spellings like
+* `'./'` (commonly used for base-agnostic Nuxt builds) need to be
+* converted to `/` first.
+*/
+function normalizeMountBase(base) {
+	let out = base.replace(/^\.\/?/, "/");
+	if (!out.startsWith("/")) out = `/${out}`;
+	if (!out.endsWith("/")) out = `${out}/`;
+	return out.replace(/\/+/g, "/");
+}
+//#endregion
+export { viteDevBridge };

package/dist/{human-id-BLoGo_e5.mjs → human-id-adtUWQLr.mjs}

@@ -1,5 +1,4 @@
-//#region \0rolldown/runtime.js
-var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+import { t as __commonJSMin } from "./chunk-e9Ob2GDo.mjs";
 //#endregion
 //#region src/utils/human-id.ts
 var import_dist = (/* @__PURE__ */ __commonJSMin(((exports) => {
@@ -839,5 +838,15 @@ var import_dist = (/* @__PURE__ */ __commonJSMin(((exports) => {
 	exports.minLength = minLength;
 	exports.default = humanId;
 })))();
+/**
+* Generate a human-readable, lowercase, dash-separated random ID
+* (e.g. `bright-orange-tiger`).
+*/
+function humanId() {
+	return (0, import_dist.humanId)({
+		separator: "-",
+		capitalize: false
+	});
+}
 //#endregion
-export { import_dist as t };
+export { humanId as t };

package/dist/{index-CuLRIMto.d.mts → index-DB2Ie0Or.d.mts}

@@ -1,5 +1,4 @@
-import { C as RpcReturnSchema, S as RpcFunctionsCollector, b as RpcFunctionSetupResult, c as RpcDumpClientOptions, g as RpcFunctionDefinitionAny, h as RpcFunctionDefinition, i as RpcArgsSchema, l as RpcDumpCollectionOptions, n as BirpcReturn, o as RpcDefinitionsToFunctions, p as RpcDumpStore, x as RpcFunctionType } from "./types-C5OVe4AC.mjs";
-import { deserialize as structuredCloneDeserialize, parse as structuredCloneParse, serialize as structuredCloneSerialize, stringify as structuredCloneStringify } from "structured-clone-es";
+import { C as RpcReturnSchema, S as RpcFunctionsCollector, b as RpcFunctionSetupResult, c as RpcDumpClientOptions, g as RpcFunctionDefinitionAny, h as RpcFunctionDefinition, i as RpcArgsSchema, l as RpcDumpCollectionOptions, n as BirpcReturn, o as RpcDefinitionsToFunctions, p as RpcDumpStore, x as RpcFunctionType } from "./types-4rdUEi2R.mjs";
 
 //#region src/rpc/cache.d.ts
 interface RpcCacheOptions {
@@ -137,4 +136,4 @@ declare function validateDefinitions(definitions: readonly RpcFunctionDefinition
  */
 declare function validateDefinition(definition: RpcFunctionDefinitionAny): void;
 //#endregion
-export { RpcCacheManager as _, structuredCloneDeserialize as a, structuredCloneStringify as c, createClientFromDump as d, dumpFunctions as f, RpcFunctionsCollectorBase as g, defineRpcFunction as h, strictJsonStringify as i, getRpcHandler as l, createDefineWrapperWithContext as m, validateDefinitions as n, structuredCloneParse as o, getDefinitionsWithDumps as p, STRUCTURED_CLONE_PREFIX as r, structuredCloneSerialize as s, validateDefinition as t, getRpcResolvedSetupResult as u, RpcCacheOptions as v };
+export { getRpcHandler as a, dumpFunctions as c, defineRpcFunction as d, RpcFunctionsCollectorBase as f, strictJsonStringify as i, getDefinitionsWithDumps as l, RpcCacheOptions as m, validateDefinitions as n, getRpcResolvedSetupResult as o, RpcCacheManager as p, STRUCTURED_CLONE_PREFIX as r, createClientFromDump as s, validateDefinition as t, createDefineWrapperWithContext as u };

package/dist/index.d.mts

@@ -1,9 +1,8 @@
-import { $ as AgentHandle, B as EntriesToObject, G as DevToolsRpcSharedStates, H as Thenable, J as JsonRenderer, K as JsonRenderElement, Q as DevToolsDiagnosticsLogger, U as DevToolsRpcClientFunctions, V as PartialWithoutId, W as DevToolsRpcServerFunctions, X as DevToolsDiagnosticsDefinition, Y as DevToolsHost, Z as DevToolsDiagnosticsHost, _ as RpcStreamingChannel, a as DevtoolRuntime, at as AgentToolInput, c as defineDevtool, ct as EventEmitter, d as DevToolsNodeContext, et as AgentManifest, f as DevToolsNodeRpcSession, g as RpcSharedStateHost, h as RpcSharedStateGetOptions, i as DevtoolDeploymentKind, it as AgentTool, l as ConnectionMeta, lt as EventUnsubscribe, m as RpcFunctionsHost, n as DevtoolCliOptions, nt as AgentResourceContent, o as DevtoolSetupInfo, ot as DevToolsAgentHost, p as RpcBroadcastOptions, q as JsonRenderSpec, r as DevtoolDefinition, rt as AgentResourceInput, s as DevtoolSpaOptions, st as DevToolsAgentHostEvents, t as DevtoolBrowserContext, tt as AgentResource, u as DevToolsCapabilities, ut as EventsMap, v as RpcStreamingChannelOptions, y as RpcStreamingHost, z as DevToolsViewHost } from "./devtool-CNvLs2_Y.mjs";
-import { C as RpcReturnSchema, h as RpcFunctionDefinition, i as RpcArgsSchema, m as RpcFunctionAgentOptions, x as RpcFunctionType } from "./types-C5OVe4AC.mjs";
-import { t as DevToolsNodeRpcSessionMeta } from "./ws-server-C7LnhOHi.mjs";
+import { $ as AgentResourceContent, B as EntriesToObject, G as DevToolsRpcSharedStates, H as Thenable, J as DevToolsDiagnosticsHost, K as DevToolsHost, Q as AgentResource, U as DevToolsRpcClientFunctions, V as PartialWithoutId, W as DevToolsRpcServerFunctions, X as AgentHandle, Y as DevToolsDiagnosticsLogger, Z as AgentManifest, _ as RpcStreamingChannel, a as DevframeRuntime, at as EventEmitter, c as defineDevframe, d as DevToolsNodeContext, et as AgentResourceInput, f as DevToolsNodeRpcSession, g as RpcSharedStateHost, h as RpcSharedStateGetOptions, i as DevframeDeploymentKind, it as DevToolsAgentHostEvents, l as ConnectionMeta, m as RpcFunctionsHost, n as DevframeCliOptions, nt as AgentToolInput, o as DevframeSetupInfo, ot as EventUnsubscribe, p as RpcBroadcastOptions, q as DevToolsDiagnosticsDefinition, r as DevframeDefinition, rt as DevToolsAgentHost, s as DevframeSpaOptions, st as EventsMap, t as DevframeBrowserContext, tt as AgentTool, u as DevToolsCapabilities, v as RpcStreamingChannelOptions, y as RpcStreamingHost, z as DevToolsViewHost } from "./devframe-R5Ex5K5L.mjs";
+import { C as RpcReturnSchema, h as RpcFunctionDefinition, i as RpcArgsSchema, m as RpcFunctionAgentOptions, x as RpcFunctionType } from "./types-4rdUEi2R.mjs";
+import { t as DevToolsNodeRpcSessionMeta } from "./ws-server-DjvlwLuM.mjs";
 
 //#region src/define.d.ts
 declare const defineRpcFunction: <NAME extends string, TYPE extends RpcFunctionType, ARGS extends any[], RETURN = void, const AS extends RpcArgsSchema | undefined = undefined, const RS extends RpcReturnSchema | undefined = undefined>(definition: RpcFunctionDefinition<NAME, TYPE, ARGS, RETURN, AS, RS, DevToolsNodeContext>) => RpcFunctionDefinition<NAME, TYPE, ARGS, RETURN, AS, RS, DevToolsNodeContext>;
-declare function defineJsonRenderSpec(spec: JsonRenderSpec): JsonRenderSpec;
 //#endregion
-export { AgentHandle, AgentManifest, AgentResource, AgentResourceContent, AgentResourceInput, AgentTool, AgentToolInput, ConnectionMeta, DevToolsAgentHost, DevToolsAgentHostEvents, DevToolsCapabilities, DevToolsDiagnosticsDefinition, DevToolsDiagnosticsHost, DevToolsDiagnosticsLogger, DevToolsHost, DevToolsNodeContext, DevToolsNodeRpcSession, DevToolsNodeRpcSessionMeta, DevToolsRpcClientFunctions, DevToolsRpcServerFunctions, DevToolsRpcSharedStates, DevToolsViewHost, DevtoolBrowserContext, DevtoolCliOptions, DevtoolDefinition, DevtoolDeploymentKind, DevtoolRuntime, DevtoolSetupInfo, DevtoolSpaOptions, EntriesToObject, EventEmitter, EventUnsubscribe, EventsMap, JsonRenderElement, JsonRenderSpec, JsonRenderer, PartialWithoutId, RpcBroadcastOptions, RpcFunctionAgentOptions, RpcFunctionsHost, RpcSharedStateGetOptions, RpcSharedStateHost, RpcStreamingChannel, RpcStreamingChannelOptions, RpcStreamingHost, Thenable, defineDevtool, defineJsonRenderSpec, defineRpcFunction };
+export { AgentHandle, AgentManifest, AgentResource, AgentResourceContent, AgentResourceInput, AgentTool, AgentToolInput, ConnectionMeta, DevToolsAgentHost, DevToolsAgentHostEvents, DevToolsCapabilities, DevToolsDiagnosticsDefinition, DevToolsDiagnosticsHost, DevToolsDiagnosticsLogger, DevToolsHost, DevToolsNodeContext, DevToolsNodeRpcSession, DevToolsNodeRpcSessionMeta, DevToolsRpcClientFunctions, DevToolsRpcServerFunctions, DevToolsRpcSharedStates, DevToolsViewHost, DevframeBrowserContext, DevframeCliOptions, DevframeDefinition, DevframeDeploymentKind, DevframeRuntime, DevframeSetupInfo, DevframeSpaOptions, EntriesToObject, EventEmitter, EventUnsubscribe, EventsMap, PartialWithoutId, RpcBroadcastOptions, RpcFunctionAgentOptions, RpcFunctionsHost, RpcSharedStateGetOptions, RpcSharedStateHost, RpcStreamingChannel, RpcStreamingChannelOptions, RpcStreamingHost, Thenable, defineDevframe, defineRpcFunction };

package/dist/index.mjs

@@ -1,8 +1,5 @@
-import { t as createDefineWrapperWithContext } from "./define-Bb4zh-Dc.mjs";
+import { t as createDefineWrapperWithContext } from "./define-CW9gLnyG.mjs";
 //#region src/define.ts
 const defineRpcFunction = createDefineWrapperWithContext();
-function defineJsonRenderSpec(spec) {
-	return spec;
-}
 //#endregion
-export { defineJsonRenderSpec, defineRpcFunction };
+export { defineRpcFunction };