devframe 0.8.2 → 0.9.0-beta.10

package/dist/{dump-CgZShDRB.mjs → static-BPZ1_OPA.mjs}

@@ -1,132 +1,6 @@
-import { t as diagnostics } from "./diagnostics-hwjXp_UV.mjs";
+import { n as validateDefinitions, r as getRpcHandler, s as hash } from "./validation-CpXFB6Dz.mjs";
+import { t as diagnostics } from "./diagnostics-CD8nlgll.mjs";
 import { DEVFRAME_RPC_DUMP_DIRNAME } from "./constants.mjs";
-import { createHash } from "node:crypto";
-//#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/node/index.mjs
-const e = globalThis.process?.getBuiltinModule?.("crypto")?.hash;
-const r = "sha256";
-const s = "base64url";
-function digest(t) {
-	if (e) return e(r, t, s);
-	const o = createHash(r).update(t);
-	return globalThis.process?.versions?.webcontainer ? o.digest().toString(s) : o.digest(s);
-}
-//#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
 //#region ../../node_modules/.pnpm/yocto-queue@1.2.2/node_modules/yocto-queue/index.js
 var Node = class {
 	value;
@@ -254,35 +128,6 @@ function validateConcurrency(concurrency) {
 	if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) throw new TypeError("Expected `concurrency` to be a number from 1 and up");
 }
 //#endregion
-//#region src/rpc/validation.ts
-/**
-* Validates RPC function definitions.
-* Action and event functions cannot have dumps (side effects should not be cached).
-*
-* @throws {Error} If an action or event function has a dump configuration
-*/
-function validateDefinitions(definitions) {
-	for (const definition of definitions) {
-		const type = definition.type || "query";
-		if ((type === "action" || type === "event") && definition.dump) throw diagnostics.DF0027({
-			name: definition.name,
-			type
-		});
-		if (definition.snapshot && type !== "query") throw diagnostics.DF0028({
-			name: definition.name,
-			type
-		});
-	}
-}
-/**
-* Validates a single RPC function definition.
-*
-* @throws {Error} If an action or event function has a dump configuration
-*/
-function validateDefinition(definition) {
-	validateDefinitions([definition]);
-}
-//#endregion
 //#region src/rpc/dump/error.ts
 /**
 * Normalize a thrown value into a plain object suitable for storage in
@@ -498,114 +343,6 @@ function getDefinitionsWithDumps(definitions) {
 	return definitions.filter((def) => def.dump !== void 0);
 }
 //#endregion
-//#region src/rpc/validate-io.ts
-/**
-* Run a single [Standard Schema](https://standardschema.dev) validator,
-* awaiting the result when the validator is asynchronous.
-*/
-async function runStandardSchema(schema, value) {
-	const result = schema["~standard"].validate(value);
-	return result instanceof Promise ? await result : result;
-}
-/**
-* Render Standard Schema issues into a single human-readable line for a
-* diagnostic message, prefixing each with its dotted path when present.
-*/
-function formatIssues(issues) {
-	return issues.map((issue) => {
-		const path = issue.path?.map((segment) => typeof segment === "object" ? segment.key : segment).join(".");
-		return path ? `${path}: ${issue.message}` : issue.message;
-	}).join("; ");
-}
-/**
-* Validate positional arguments against their declared schemas. Only
-* indices with a schema are checked; extra arguments pass through
-* untouched. Throws `DF0038` on the first failing argument.
-*
-* Validation guards the payload without rewriting it: the original values
-* are handed to the handler unchanged, so a schema that describes a subset
-* of an object never silently strips the sender's extra fields (and any
-* declared transforms stay a purely type-level concern).
-*
-* @internal
-*/
-async function validateRpcArgs(name, argsSchema, args) {
-	const original = args.slice();
-	if (!argsSchema || argsSchema.length === 0) return original;
-	for (let index = 0; index < argsSchema.length; index++) {
-		const schema = argsSchema[index];
-		if (!schema) continue;
-		const result = await runStandardSchema(schema, args[index]);
-		if (result.issues) throw diagnostics.DF0043({
-			name,
-			index,
-			issues: formatIssues(result.issues)
-		});
-	}
-	return original;
-}
-/**
-* Validate a handler's resolved return value against its declared schema.
-* Throws `DF0039` when the value fails the schema, otherwise returns the
-* original value unchanged (guard-only, never rewriting the payload — see
-* {@link validateRpcArgs}). Passes through when no return schema is set.
-*
-* @internal
-*/
-async function validateRpcReturn(name, returnSchema, value) {
-	if (!returnSchema) return value;
-	const result = await runStandardSchema(returnSchema, value);
-	if (result.issues) throw diagnostics.DF0044({
-		name,
-		issues: formatIssues(result.issues)
-	});
-	return value;
-}
-//#endregion
-//#region src/rpc/handler.ts
-async function getRpcResolvedSetupResult(definition, context) {
-	if (!definition.setup) return {};
-	if (typeof context === "object" && context !== null) {
-		definition.__cache ??= /* @__PURE__ */ new WeakMap();
-		const cache = definition.__cache;
-		let promise = cache.get(context);
-		if (!promise) {
-			promise = Promise.resolve(definition.setup(context));
-			promise.catch(() => {
-				if (cache.get(context) === promise) cache.delete(context);
-			});
-			cache.set(context, promise);
-		}
-		return await promise;
-	}
-	if (!definition.__promise) {
-		const promise = Promise.resolve(definition.setup(context));
-		promise.catch(() => {
-			if (definition.__promise === promise) definition.__promise = void 0;
-		});
-		definition.__promise = promise;
-	}
-	return await definition.__promise;
-}
-async function getRpcHandler(definition, context) {
-	let handler = definition.handler;
-	if (!handler) {
-		const result = await getRpcResolvedSetupResult(definition, context);
-		if (!result.handler) throw diagnostics.DF0024({ name: definition.name });
-		handler = result.handler;
-	}
-	const argsSchema = definition.args;
-	const returnSchema = definition.returns;
-	if (!argsSchema && !returnSchema) return handler;
-	const inner = handler;
-	const validating = async (...args) => {
-		const validatedArgs = await validateRpcArgs(definition.name, argsSchema, args);
-		const output = await inner(...validatedArgs);
-		return await validateRpcReturn(definition.name, returnSchema, output);
-	};
-	return validating;
-}
-//#endregion
 //#region src/rpc/dump/static.ts
 function makeDumpKey(name) {
 	return encodeURIComponent(name.replaceAll(":", "~"));
@@ -683,4 +420,4 @@ async function collectStaticRpcDump(definitions, context) {
 	};
 }
 //#endregion
-export { validateRpcReturn as a, getDefinitionsWithDumps as c, validateDefinition as d, validateDefinitions as f, validateRpcArgs as i, reviveDumpError as l, getRpcHandler as n, createClientFromDump as o, hash as p, getRpcResolvedSetupResult as r, dumpFunctions as s, collectStaticRpcDump as t, serializeDumpError as u };
+export { reviveDumpError as a, getDefinitionsWithDumps as i, createClientFromDump as n, serializeDumpError as o, dumpFunctions as r, collectStaticRpcDump as t };

package/dist/storage-CYye7P7L.mjs

@@ -0,0 +1,137 @@
+import { t as diagnostics } from "./diagnostics-DOQPnQmX.mjs";
+import { createSharedState } from "devframe/utils/shared-state";
+import fs from "node:fs";
+import { dirname } from "pathe";
+import process from "node:process";
+//#region ../../node_modules/.pnpm/perfect-debounce@2.1.0/node_modules/perfect-debounce/dist/index.mjs
+const DEBOUNCE_DEFAULTS = { trailing: true };
+/**
+Debounce functions
+@param fn - Promise-returning/async function to debounce.
+@param wait - Milliseconds to wait before calling `fn`. Default value is 25ms
+@returns A function that delays calling `fn` until after `wait` milliseconds have elapsed since the last time it was called.
+@example
+```
+import { debounce } from 'perfect-debounce';
+const expensiveCall = async input => input;
+const debouncedFn = debounce(expensiveCall, 200);
+for (const number of [1, 2, 3]) {
+console.log(await debouncedFn(number));
+}
+//=> 1
+//=> 2
+//=> 3
+```
+*/
+function debounce(fn, wait = 25, options = {}) {
+	options = {
+		...DEBOUNCE_DEFAULTS,
+		...options
+	};
+	if (!Number.isFinite(wait)) throw new TypeError("Expected `wait` to be a finite number");
+	let leadingValue;
+	let timeout;
+	let resolveList = [];
+	let currentPromise;
+	let trailingArgs;
+	const applyFn = (_this, args) => {
+		currentPromise = _applyPromised(fn, _this, args);
+		currentPromise.finally(() => {
+			currentPromise = null;
+			if (options.trailing && trailingArgs && !timeout) {
+				const promise = applyFn(_this, trailingArgs);
+				trailingArgs = null;
+				return promise;
+			}
+		});
+		return currentPromise;
+	};
+	const debounced = function(...args) {
+		if (options.trailing) trailingArgs = args;
+		if (currentPromise) return currentPromise;
+		return new Promise((resolve) => {
+			const shouldCallNow = !timeout && options.leading;
+			clearTimeout(timeout);
+			timeout = setTimeout(() => {
+				timeout = null;
+				const promise = options.leading ? leadingValue : applyFn(this, args);
+				trailingArgs = null;
+				for (const _resolve of resolveList) _resolve(promise);
+				resolveList = [];
+			}, wait);
+			if (shouldCallNow) {
+				leadingValue = applyFn(this, args);
+				resolve(leadingValue);
+			} else resolveList.push(resolve);
+		});
+	};
+	const _clearTimeout = (timer) => {
+		if (timer) {
+			clearTimeout(timer);
+			timeout = null;
+		}
+	};
+	debounced.isPending = () => !!timeout;
+	debounced.cancel = () => {
+		_clearTimeout(timeout);
+		resolveList = [];
+		trailingArgs = null;
+	};
+	debounced.flush = () => {
+		_clearTimeout(timeout);
+		if (!trailingArgs || currentPromise) return;
+		const args = trailingArgs;
+		trailingArgs = null;
+		return applyFn(this, args);
+	};
+	return debounced;
+}
+async function _applyPromised(fn, _this, args) {
+	return await fn.apply(_this, args);
+}
+//#endregion
+//#region src/node/storage.ts
+function safeJsonParse(text) {
+	return JSON.parse(text, (key, value) => {
+		if (key === "__proto__" || key === "constructor" && value && typeof value === "object" && "prototype" in value) return void 0;
+		return value;
+	});
+}
+function createStorage(options) {
+	const { mergeInitialValue = (initialValue, savedValue) => ({
+		...initialValue,
+		...savedValue
+	}), debounce: debounceTime = 100 } = options;
+	let initialValue = options.initialValue;
+	if (fs.existsSync(options.filepath)) try {
+		const savedValue = safeJsonParse(fs.readFileSync(options.filepath, "utf-8"));
+		initialValue = mergeInitialValue ? mergeInitialValue(options.initialValue, savedValue) : savedValue;
+	} catch (error) {
+		diagnostics.DF0012({
+			filepath: options.filepath,
+			cause: error
+		}, { method: "warn" });
+		initialValue = options.initialValue;
+	}
+	const state = createSharedState({
+		initialValue,
+		enablePatches: false
+	});
+	state.on("updated", debounce((newState) => {
+		try {
+			const dir = dirname(options.filepath);
+			fs.mkdirSync(dir, { recursive: true });
+			const tmp = `${options.filepath}.${process.pid}.tmp`;
+			fs.writeFileSync(tmp, `${JSON.stringify(newState, null, 2)}\n`);
+			fs.renameSync(tmp, options.filepath);
+		} catch (error) {
+			diagnostics.DF0035({
+				filepath: options.filepath,
+				cause: error
+			}, { method: "error" });
+		}
+	}, debounceTime));
+	return state;
+}
+//#endregion
+export { createStorage as t };

package/dist/types/index.d.mts

@@ -1,4 +1,6 @@
-import { $ as DevframeRpcServerFunctions, A as DevframeSettingsStore, At as DevframeAgentHostEvents, B as DevframeDefineDiagnosticsOptions, C as DevframeServicesHost, Ct as AgentResourceContent, D as DevframeScopedStreamingHost, Dt as AgentToolProvider, E as DevframeScopedNodeRpc, Et as AgentToolInput, F as ScopedSharedStates, G as RpcBroadcastOptions, H as DevframeDiagnosticsHost, I as SettingsForNamespace, J as RpcSharedStateHost, K as RpcFunctionsHost, L as DevframeViewHost, M as ScopedClientFunctions, Mt as EventUnsubscribe, N as ScopedRpcFn, Nt as EventsMap, O as DevframeSettings, Ot as AgentToolProviderHandle, P as ScopedServerFunctions, Q as DevframeRpcClientFunctions, R as DevframeHost, S as DevframeServiceOf, St as AgentResource, T as DevframeScopedNodeContext, Tt as AgentTool, U as DevframeDiagnosticsLogger, V as DevframeDiagnosticsDefinition, W as DevframeNodeRpcSession, X as RpcStreamingChannelOptions, Y as RpcStreamingChannel, Z as RpcStreamingHost, _ as ConnectionMeta, a as DevframeDockDefaults, b as DevframeNodeContext, bt as AgentHandle, c as DevframeSetupInfo, d as McpRouteOptions, et as DevframeRpcSharedStates, f as defineDevframe, g as Thenable, h as PartialWithoutId, i as DevframeDeploymentKind, j as ScopedBroadcastOptions, jt as EventEmitter, k as DevframeSettingsRegistry, kt as DevframeAgentHost, l as DevframeSpaOptions, m as EntriesToObject, n as DevframeCliOptions, o as DevframeDuplicationStrategy, q as RpcSharedStateGetOptions, r as DevframeDefinition, s as DevframeRuntime, t as DevframeBrowserContext, u as DevframeWsOptions, v as ConnectionMetaWebsocket, w as DevframeServicesRegistry, wt as AgentResourceInput, x as DevframeServiceId, xt as AgentManifest, y as DevframeCapabilities, z as DevframeStorageScope } from "../devframe-mQ4qZAuo.mjs";
-import { g as RpcFunctionAgentOptions } from "../types-CnJSgRVa.mjs";
-import { n as DevframeNodeRpcSessionMeta } from "../ws-server-uKQcClcJ.mjs";
-export { AgentHandle, AgentManifest, AgentResource, AgentResourceContent, AgentResourceInput, AgentTool, AgentToolInput, AgentToolProvider, AgentToolProviderHandle, ConnectionMeta, ConnectionMetaWebsocket, DevframeAgentHost, DevframeAgentHostEvents, DevframeBrowserContext, DevframeCapabilities, DevframeCliOptions, DevframeDefineDiagnosticsOptions, DevframeDefinition, DevframeDeploymentKind, DevframeDiagnosticsDefinition, DevframeDiagnosticsHost, DevframeDiagnosticsLogger, DevframeDockDefaults, DevframeDuplicationStrategy, DevframeHost, DevframeNodeContext, DevframeNodeRpcSession, type DevframeNodeRpcSessionMeta, DevframeRpcClientFunctions, DevframeRpcServerFunctions, DevframeRpcSharedStates, DevframeRuntime, DevframeScopedNodeContext, DevframeScopedNodeRpc, DevframeScopedStreamingHost, DevframeServiceId, DevframeServiceOf, DevframeServicesHost, DevframeServicesRegistry, DevframeSettings, DevframeSettingsRegistry, DevframeSettingsStore, DevframeSetupInfo, DevframeSpaOptions, DevframeStorageScope, DevframeViewHost, DevframeWsOptions, EntriesToObject, EventEmitter, EventUnsubscribe, EventsMap, McpRouteOptions, PartialWithoutId, RpcBroadcastOptions, type RpcFunctionAgentOptions, RpcFunctionsHost, RpcSharedStateGetOptions, RpcSharedStateHost, RpcStreamingChannel, RpcStreamingChannelOptions, RpcStreamingHost, ScopedBroadcastOptions, ScopedClientFunctions, ScopedRpcFn, ScopedServerFunctions, ScopedSharedStates, SettingsForNamespace, Thenable, defineDevframe };
+import { A as ScopedServerFunctions, B as RpcFunctionsHost, C as DevframeScopedStreamingHost, Ct as DevframeAgentHost, D as ScopedBroadcastOptions, Dt as EventsMap, E as DevframeSettingsStore, Et as EventUnsubscribe, F as DevframeStorageScope, G as RpcStreamingHost, H as RpcSharedStateHost, I as DevframeDiagnosticsHost, J as DevframeRpcSharedStates, K as DevframeRpcClientFunctions, L as DevframeDiagnosticsLogger, M as SettingsForNamespace, N as DevframeViewHost, O as ScopedClientFunctions, P as DevframeHost, R as DevframeNodeRpcSession, S as DevframeScopedNodeRpc, St as AgentToolProviderHandle, T as DevframeSettingsRegistry, Tt as EventEmitter, U as RpcStreamingChannel, V as RpcSharedStateGetOptions, W as RpcStreamingChannelOptions, _ as DevframeServiceId, _t as AgentResourceContent, a as DevframeDuplicationStrategy, b as DevframeServicesRegistry, bt as AgentToolInput, c as DevframeWsOptions, d as ConnectionMeta, f as ConnectionMetaSse, g as DevframeNodeContext, gt as AgentResource, h as DevframeConnectionConfigsRegistry, ht as AgentManifest, i as DevframeDockDefaults, j as ScopedSharedStates, k as ScopedRpcFn, l as McpRouteOptions, m as DevframeCapabilities, mt as AgentHandle, n as DevframeDefinition, o as DevframeSetupInfo, p as ConnectionMetaWebsocket, q as DevframeRpcServerFunctions, r as DevframeDeploymentKind, s as DevframeSseOptions, t as DevframeCliOptions, v as DevframeServiceOf, vt as AgentResourceInput, w as DevframeSettings, wt as DevframeAgentHostEvents, x as DevframeScopedNodeContext, xt as AgentToolProvider, y as DevframeServicesHost, yt as AgentTool, z as RpcBroadcastOptions } from "../devframe-DJMg0WLe.mjs";
+import { g as RpcFunctionAgentOptions } from "../types-Djq7CBXh.mjs";
+import { d as DevframeRpcConnection, f as DevframeRpcConnectionRequest, p as DevframeRpcTransportKind, u as DevframeNodeRpcSessionMeta } from "../ws-server-D1d3QM9f.mjs";
+import { i as DevframeDefineDiagnosticsOptions } from "../nostics-SPGDgHEP.mjs";
+import { a as RemoteAssetsStore, i as RemoteAssetsProviderCustom, n as RemoteAssetsErrorMessage, o as StaticAssetsSource, r as RemoteAssetsProvider, t as RemoteAssets } from "../remote-assets-Bg4gCUZ_.mjs";
+export { AgentHandle, AgentManifest, AgentResource, AgentResourceContent, AgentResourceInput, AgentTool, AgentToolInput, AgentToolProvider, AgentToolProviderHandle, ConnectionMeta, ConnectionMetaSse, ConnectionMetaWebsocket, DevframeAgentHost, DevframeAgentHostEvents, DevframeCapabilities, DevframeCliOptions, DevframeConnectionConfigsRegistry, type DevframeDefineDiagnosticsOptions, DevframeDefinition, DevframeDeploymentKind, DevframeDiagnosticsHost, DevframeDiagnosticsLogger, DevframeDockDefaults, DevframeDuplicationStrategy, DevframeHost, DevframeNodeContext, DevframeNodeRpcSession, type DevframeNodeRpcSessionMeta, DevframeRpcClientFunctions, type DevframeRpcConnection, type DevframeRpcConnectionRequest, DevframeRpcServerFunctions, DevframeRpcSharedStates, type DevframeRpcTransportKind, DevframeScopedNodeContext, DevframeScopedNodeRpc, DevframeScopedStreamingHost, DevframeServiceId, DevframeServiceOf, DevframeServicesHost, DevframeServicesRegistry, DevframeSettings, DevframeSettingsRegistry, DevframeSettingsStore, DevframeSetupInfo, DevframeSseOptions, DevframeStorageScope, DevframeViewHost, DevframeWsOptions, EventEmitter, EventUnsubscribe, EventsMap, McpRouteOptions, RemoteAssets, RemoteAssetsErrorMessage, RemoteAssetsProvider, RemoteAssetsProviderCustom, RemoteAssetsStore, RpcBroadcastOptions, type RpcFunctionAgentOptions, RpcFunctionsHost, RpcSharedStateGetOptions, RpcSharedStateHost, RpcStreamingChannel, RpcStreamingChannelOptions, RpcStreamingHost, ScopedBroadcastOptions, ScopedClientFunctions, ScopedRpcFn, ScopedServerFunctions, ScopedSharedStates, SettingsForNamespace, StaticAssetsSource };

package/dist/types/index.mjs

@@ -1,6 +1 @@
-//#region src/types/devframe.ts
-function defineDevframe(d) {
-	return d;
-}
-//#endregion
-export { defineDevframe };
+export {};

package/dist/{types-CnJSgRVa.d.mts → types-Djq7CBXh.d.mts}

@@ -24,9 +24,6 @@ type RpcFunctionType = 'static' | 'action' | 'event' | 'query';
  * the function is surfaced to agents (e.g. via the devframe MCP adapter)
  * as a callable tool. Functions without an `agent` field are not exposed —
  * default-deny.
- *
- * @experimental The agent-native surface is experimental and may change
- * without a major version bump until it stabilizes.
  */
 interface RpcFunctionAgentOptions {
   /**
@@ -233,8 +230,6 @@ type RpcFunctionDefinition<NAME extends string, TYPE extends RpcFunctionType = '
   /**
    * Expose this function to agents (e.g. via the MCP adapter).
    * When omitted, the function is not agent-exposed (default-deny).
-   *
-   * @experimental
    */
   agent?: RpcFunctionAgentOptions;
   /** Setup function called with context to initialize handler and dump */
@@ -280,8 +275,6 @@ type RpcFunctionDefinition<NAME extends string, TYPE extends RpcFunctionType = '
   /**
    * Expose this function to agents (e.g. via the MCP adapter).
    * When omitted, the function is not agent-exposed (default-deny).
-   *
-   * @experimental
    */
   agent?: RpcFunctionAgentOptions;
   /** Setup function called with context to initialize handler and dump */

package/dist/utils/agent-tool-name.d.mts

@@ -18,9 +18,6 @@
  * A plain string transform with no node dependency, so browser-side UIs
  * that display a tool's id (e.g. the inspect plugin's agent view) can
  * import it too and show the name a client actually calls.
- *
- * @experimental The agent-native surface is experimental and may change
- * without a major version bump until it stabilizes.
  */
 declare function toAgentToolName(id: string): string;
 //#endregion

package/dist/utils/agent-tool-name.mjs

@@ -23,9 +23,6 @@ const MAX_TOOL_NAME_LENGTH = 128;
 * A plain string transform with no node dependency, so browser-side UIs
 * that display a tool's id (e.g. the inspect plugin's agent view) can
 * import it too and show the name a client actually calls.
-*
-* @experimental The agent-native surface is experimental and may change
-* without a major version bump until it stabilizes.
 */
 function toAgentToolName(id) {
 	return id.replace(/[^\w-]+/g, "_").slice(0, MAX_TOOL_NAME_LENGTH);

package/dist/utils/events.d.mts

@@ -1,4 +1,4 @@
-import { Nt as EventsMap, jt as EventEmitter } from "../devframe-mQ4qZAuo.mjs";
+import { Dt as EventsMap, Tt as EventEmitter } from "../devframe-DJMg0WLe.mjs";
 //#region src/utils/events.d.ts
 /**
  * Create event emitter.

package/dist/utils/get-port.d.mts

@@ -0,0 +1,17 @@
+//#region ../../node_modules/.pnpm/get-port-please@3.2.0/node_modules/get-port-please/dist/index.d.mts
+interface GetPortOptions {
+  name: string;
+  random: boolean;
+  port: number;
+  ports: number[];
+  portRange: [fromInclusive: number, toInclusive: number];
+  alternativePortRange: [fromInclusive: number, toInclusive: number];
+  host: string;
+  verbose?: boolean;
+  public?: boolean;
+}
+type GetPortInput = Partial<GetPortOptions> | number | string;
+type PortNumber = number;
+declare function getPort(_userOptions?: GetPortInput): Promise<PortNumber>;
+//#endregion
+export { type GetPortInput, type GetPortOptions, getPort };

package/dist/utils/get-port.mjs

@@ -0,0 +1,2 @@
+import { n as getPort } from "../dist-eNI9qM_I.mjs";
+export { getPort };

package/dist/utils/launch-editor.mjs

@@ -1,28 +1,4 @@
-import { createRequire } from "node:module";
-//#region \0rolldown/runtime.js
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-var __require = /* #__PURE__ */ (() => createRequire(import.meta.url))();
-//#endregion
+import { i as __toESM, r as __require, t as __commonJSMin } from "../rolldown-runtime-JspESFgx.mjs";
 //#region ../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js
 var require_picocolors = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	let p = process || {};

package/dist/utils/nostics.d.mts

@@ -0,0 +1,2 @@
+import { a as Diagnostic, c as DiagnosticHandle, d as Diagnostics, f as ansiFormatter, g as formatDiagnostic, h as defineProdDiagnostics, i as DevframeDefineDiagnosticsOptions, l as DiagnosticInit, m as defineDiagnostics, n as ConsoleMethod, o as DiagnosticCallParams, p as createConsoleReporter, r as ConsoleReporterOptions, s as DiagnosticDefinition, t as AnyDiagnosticReporter, u as DiagnosticReporter } from "../nostics-SPGDgHEP.mjs";
+export { type AnyDiagnosticReporter, type ConsoleMethod, type ConsoleReporterOptions, DevframeDefineDiagnosticsOptions, type Diagnostic, type DiagnosticCallParams, type DiagnosticDefinition, type DiagnosticHandle, type DiagnosticInit, type DiagnosticReporter, type Diagnostics, ansiFormatter, createConsoleReporter, defineDiagnostics, defineProdDiagnostics, formatDiagnostic };

package/dist/utils/nostics.mjs

@@ -0,0 +1,2 @@
+import { a as defineProdDiagnostics, i as defineDiagnostics, n as ansiFormatter, o as formatDiagnostic, r as createConsoleReporter, t as Diagnostic } from "../nostics-CzECRXpE.mjs";
+export { Diagnostic, ansiFormatter, createConsoleReporter, defineDiagnostics, defineProdDiagnostics, formatDiagnostic };

package/dist/utils/open.d.mts

@@ -1,16 +1,8 @@
 //#region src/utils/open.d.ts
-interface OpenOptions {
-  /**
-   * Resolve only after the launched app exits.
-   *
-   * @default false
-   */
-  wait?: boolean;
-}
 /**
  * Open a URL, file, or other target in its default OS handler
  * (browser for URLs, Finder/Explorer for paths, etc.).
  */
-declare function open(target: string, options?: OpenOptions): Promise<void>;
+declare function open(target: string): Promise<void>;
 //#endregion
-export { OpenOptions, open };
+export { open };

package/dist/utils/open.mjs

@@ -1,2 +1,57 @@
-import { t as open } from "../open-Deb5xmIT.mjs";
+import fs from "node:fs";
+import process from "node:process";
+import { spawn } from "node:child_process";
+//#region src/utils/open.ts
+/**
+* Launches `command` detached from the current process and resolves once
+* the OS has accepted the spawn (not once the launched app exits) — the
+* same "fire and forget" behavior `open`'s default (`wait: false`) gave us.
+*/
+function spawnDetached(command, args) {
+	return new Promise((resolve, reject) => {
+		const child = spawn(command, args, {
+			detached: true,
+			stdio: "ignore",
+			windowsHide: true
+		});
+		child.once("error", reject);
+		child.once("spawn", () => {
+			child.unref();
+			resolve();
+		});
+	});
+}
+function isWsl() {
+	if (process.platform !== "linux") return false;
+	try {
+		return fs.readFileSync("/proc/version", "utf-8").toLowerCase().includes("microsoft");
+	} catch {
+		return false;
+	}
+}
+/**
+* Open a URL, file, or other target in its default OS handler
+* (browser for URLs, Finder/Explorer for paths, etc.).
+*/
+async function open(target) {
+	if (process.platform === "darwin") return spawnDetached("open", [target]);
+	if (process.platform === "win32") return spawnDetached("cmd", [
+		"/c",
+		"start",
+		"\"\"",
+		target
+	]);
+	if (isWsl()) try {
+		return await spawnDetached("wslview", [target]);
+	} catch {
+		return spawnDetached("cmd.exe", [
+			"/c",
+			"start",
+			"\"\"",
+			target
+		]);
+	}
+	return spawnDetached("xdg-open", [target]);
+}
+//#endregion
 export { open };