devframe 0.8.2 → 0.9.0-beta.1

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

@@ -1,132 +1,6 @@
+import { n as validateDefinitions, r as getRpcHandler, s as hash } from "./validation-BiuDXTKW.mjs";
 import { t as diagnostics } from "./diagnostics-hwjXp_UV.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-CTNVbuFB.mjs → storage-BcmVEJRc.mjs}

@@ -1,4 +1,4 @@
-import { t as diagnostics } from "./diagnostics-D7wM2cwM.mjs";
+import { t as diagnostics } from "./diagnostics-DLYH5oD3.mjs";
 import fs from "node:fs";
 import { dirname } from "pathe";
 import process$1 from "node:process";
@@ -42,7 +42,7 @@ function createEventEmitter() {
 	};
 }
 //#endregion
-//#region ../../node_modules/.pnpm/immer@11.1.15/node_modules/immer/dist/immer.mjs
+//#region ../../node_modules/.pnpm/immer@11.1.16/node_modules/immer/dist/immer.mjs
 var NOTHING = Symbol.for("immer-nothing");
 var DRAFTABLE = Symbol.for("immer-draftable");
 var DRAFT_STATE = Symbol.for("immer-state");

package/dist/types/index.d.mts

@@ -1,4 +1,4 @@
-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 { $ as DevframeRpcClientFunctions, A as DevframeSettingsRegistry, At as DevframeAgentHost, B as DevframeStorageScope, C as DevframeServiceOf, Ct as AgentResource, D as DevframeScopedNodeRpc, Dt as AgentToolInput, E as DevframeScopedNodeContext, Et as AgentTool, F as ScopedServerFunctions, G as DevframeNodeRpcSession, H as DevframeDiagnosticsDefinition, I as ScopedSharedStates, J as RpcSharedStateGetOptions, K as RpcBroadcastOptions, L as SettingsForNamespace, M as ScopedBroadcastOptions, Mt as EventEmitter, N as ScopedClientFunctions, Nt as EventUnsubscribe, O as DevframeScopedStreamingHost, Ot as AgentToolProvider, P as ScopedRpcFn, Pt as EventsMap, Q as RpcStreamingHost, R as DevframeViewHost, S as DevframeServiceId, St as AgentManifest, T as DevframeServicesRegistry, Tt as AgentResourceInput, U as DevframeDiagnosticsHost, V as DevframeDefineDiagnosticsOptions, W as DevframeDiagnosticsLogger, X as RpcStreamingChannel, Y as RpcSharedStateHost, Z as RpcStreamingChannelOptions, _ as ConnectionMeta, a as DevframeDockDefaults, b as DevframeCapabilities, c as DevframeSetupInfo, d as DevframeWsOptions, et as DevframeRpcServerFunctions, f as McpRouteOptions, g as Thenable, h as PartialWithoutId, i as DevframeDeploymentKind, j as DevframeSettingsStore, jt as DevframeAgentHostEvents, k as DevframeSettings, kt as AgentToolProviderHandle, l as DevframeSpaOptions, m as EntriesToObject, n as DevframeCliOptions, o as DevframeDuplicationStrategy, q as RpcFunctionsHost, r as DevframeDefinition, s as DevframeRuntime, t as DevframeBrowserContext, tt as DevframeRpcSharedStates, u as DevframeSseOptions, v as ConnectionMetaSse, w as DevframeServicesHost, wt as AgentResourceContent, x as DevframeNodeContext, xt as AgentHandle, y as ConnectionMetaWebsocket, z as DevframeHost } from "../devframe-Bdd9YXTy.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 { d as DevframeRpcConnection, f as DevframeRpcConnectionRequest, p as DevframeRpcTransportKind, u as DevframeNodeRpcSessionMeta } from "../ws-server-Ces08fjP.mjs";
+export { AgentHandle, AgentManifest, AgentResource, AgentResourceContent, AgentResourceInput, AgentTool, AgentToolInput, AgentToolProvider, AgentToolProviderHandle, ConnectionMeta, ConnectionMetaSse, ConnectionMetaWebsocket, DevframeAgentHost, DevframeAgentHostEvents, DevframeBrowserContext, DevframeCapabilities, DevframeCliOptions, DevframeDefineDiagnosticsOptions, DevframeDefinition, DevframeDeploymentKind, DevframeDiagnosticsDefinition, DevframeDiagnosticsHost, DevframeDiagnosticsLogger, DevframeDockDefaults, DevframeDuplicationStrategy, DevframeHost, DevframeNodeContext, DevframeNodeRpcSession, type DevframeNodeRpcSessionMeta, DevframeRpcClientFunctions, type DevframeRpcConnection, type DevframeRpcConnectionRequest, DevframeRpcServerFunctions, DevframeRpcSharedStates, type DevframeRpcTransportKind, DevframeRuntime, DevframeScopedNodeContext, DevframeScopedNodeRpc, DevframeScopedStreamingHost, DevframeServiceId, DevframeServiceOf, DevframeServicesHost, DevframeServicesRegistry, DevframeSettings, DevframeSettingsRegistry, DevframeSettingsStore, DevframeSetupInfo, DevframeSpaOptions, DevframeSseOptions, 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 };

package/dist/types/index.mjs

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

package/dist/utils/events.d.mts

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

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/open.mjs

@@ -1,2 +1,2 @@
-import { t as open } from "../open-Deb5xmIT.mjs";
+import { t as open } from "../open-Dz4V4irZ.mjs";
 export { open };

package/dist/utils/serve-static.mjs

@@ -1,7 +1,7 @@
 import { createReadStream } from "node:fs";
 import { extname, join, normalize, resolve, sep } from "pathe";
-import { H3, defineHandler } from "h3";
 import { stat } from "node:fs/promises";
+import { H3, defineHandler } from "h3";
 import { Readable } from "node:stream";
 import { lookup } from "mrmime";
 //#region src/utils/serve-static.ts

package/dist/utils/shared-state.d.mts

@@ -1,2 +1,2 @@
-import { _t as SharedStateOptions, dt as ImmutableArray, ft as ImmutableMap, gt as SharedStateEvents, ht as SharedState, mt as ImmutableSet, pt as ImmutableObject, ut as Immutable, vt as SharedStatePatch, yt as createSharedState } from "../devframe-mQ4qZAuo.mjs";
+import { _t as SharedStateEvents, bt as createSharedState, dt as Immutable, ft as ImmutableArray, gt as SharedState, ht as ImmutableSet, mt as ImmutableObject, pt as ImmutableMap, vt as SharedStateOptions, yt as SharedStatePatch } from "../devframe-Bdd9YXTy.mjs";
 export { Immutable, ImmutableArray, ImmutableMap, ImmutableObject, ImmutableSet, SharedState, SharedStateEvents, SharedStateOptions, SharedStatePatch, createSharedState };

package/dist/utils/shared-state.mjs

@@ -1,2 +1,2 @@
-import { t as createSharedState } from "../shared-state-6kHolYZy.mjs";
+import { t as createSharedState } from "../shared-state-fRRbRUtD.mjs";
 export { createSharedState };

package/dist/utils/simple-schema.d.mts

@@ -1,2 +1,102 @@
-import { a as literal, c as number, d as picklist, f as record, g as voidType, h as union, i as describe, l as object, m as string, n as array, o as nullType, p as s, r as boolean, s as nullable, t as SimpleSchema, u as optional } from "../simple-schema-BDzLeJDk.mjs";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+//#region src/utils/simple-schema.d.ts
+/**
+ * A tiny, zero-dependency [Standard Schema](https://standardschema.dev/)
+ * builder.
+ *
+ * ⚠️ **Discouraged for app code.** This is a deliberately minimal,
+ * best-effort validator that exists only so devframe's own first-party
+ * packages (recipes, built-in plugins) can declare `args`/`returns`/flag
+ * schemas without taking on a validator dependency. It implements a small
+ * subset of primitives and approximates refinements — it is not a
+ * general-purpose validator.
+ *
+ * For your own code, prefer a real Standard Schema validator — **valibot**,
+ * **zod**, or **arktype**. Devframe's RPC and CLI-flag layers accept any of
+ * them; install the one you like and use it directly:
+ *
+ * ```ts
+ * import * as v from 'valibot' // npm i valibot
+ *
+ * defineRpcFunction({
+ *   name: 'greet',
+ *   args: [v.object({ name: v.string() })],
+ *   returns: v.string(),
+ *   handler: ({ name }) => `hi ${name}`,
+ * })
+ * ```
+ */
+/**
+ * A Standard Schema produced by the {@link s} builder. It carries a
+ * duck-typed `type` marker (and `wrapped` for wrappers) alongside the
+ * standard `~standard` prop so the CLI-flags adapter can introspect the
+ * schema kind without importing any validator.
+ */
+interface SimpleSchema<Input, Output = Input> extends StandardSchemaV1<Input, Output> {
+  /** Schema kind marker, e.g. `'string'`, `'boolean'`, `'optional'`. */
+  readonly type: string;
+  /** Inner schema for wrapper kinds (`optional` / `nullable`). */
+  readonly wrapped?: StandardSchemaV1;
+  /** Optional human description (surfaced as CLI option help). */
+  readonly description?: string;
+}
+/** Any string. */
+declare function string(): SimpleSchema<string>;
+/** A finite number (rejects `NaN`). */
+declare function number(): SimpleSchema<number>;
+/** A boolean. */
+declare function boolean(): SimpleSchema<boolean>;
+/** `undefined` — mirrors valibot's `void`. */
+declare function voidType(): SimpleSchema<void>;
+/** `null`. */
+declare function nullType(): SimpleSchema<null>;
+/** One of a fixed set of literal values. */
+declare function picklist<const T extends readonly (string | number | boolean)[]>(values: T): SimpleSchema<T[number]>;
+/** A single literal value (string / number / boolean). */
+declare function literal<const T extends string | number | boolean>(value: T): SimpleSchema<T>;
+/** A value matching any one of the given schemas. */
+declare function union<const T extends readonly StandardSchemaV1[]>(options: T): SimpleSchema<StandardSchemaV1.InferInput<T[number]>, StandardSchemaV1.InferOutput<T[number]>>;
+/** A record with string keys whose values each satisfy the value schema. */
+declare function record<V extends StandardSchemaV1>(_key: StandardSchemaV1, value: V): SimpleSchema<Record<string, StandardSchemaV1.InferInput<V>>, Record<string, StandardSchemaV1.InferOutput<V>>>;
+/** An array whose every element satisfies the item schema. */
+declare function array<T extends StandardSchemaV1>(item: T): SimpleSchema<StandardSchemaV1.InferInput<T>[], StandardSchemaV1.InferOutput<T>[]>;
+/** Flatten an intersection into a single object literal for readable types. */
+type Prettify<T> = { [K in keyof T]: T[K]; } & {};
+/**
+ * Map a shape to its object type, turning fields whose type includes
+ * `undefined` (i.e. `optional()`) into optional keys — mirroring how
+ * valibot/zod render `optional` object entries.
+ */
+type InferField<T extends StandardSchemaV1, Mode extends 'input' | 'output'> = Mode extends 'input' ? StandardSchemaV1.InferInput<T> : StandardSchemaV1.InferOutput<T>;
+type InferObject<T extends Record<string, StandardSchemaV1>, Mode extends 'input' | 'output'> = Prettify<{ [K in keyof T as undefined extends InferField<T[K], Mode> ? never : K]: InferField<T[K], Mode>; } & { [K in keyof T as undefined extends InferField<T[K], Mode> ? K : never]?: InferField<T[K], Mode>; }>;
+/** An object whose known keys each satisfy their schema (extra keys are kept). */
+declare function object<T extends Record<string, StandardSchemaV1>>(shape: T): SimpleSchema<InferObject<T, 'input'>, InferObject<T, 'output'>>;
+/** Allow `undefined` in addition to the inner schema. */
+declare function optional<T extends StandardSchemaV1>(inner: T): SimpleSchema<StandardSchemaV1.InferInput<T> | undefined, StandardSchemaV1.InferOutput<T> | undefined>;
+/** Allow `null` in addition to the inner schema. */
+declare function nullable<T extends StandardSchemaV1>(inner: T): SimpleSchema<StandardSchemaV1.InferInput<T> | null, StandardSchemaV1.InferOutput<T> | null>;
+/** Attach a human-readable description (used for CLI option help). */
+declare function describe<T extends SimpleSchema<any, any>>(schema: T, description: string): T;
+/**
+ * Grouped access to every builder — `s.string()`, `s.object({ ... })`,
+ * `s.void()`, etc. Handy for a valibot-like `import { s } from
+ * 'devframe/utils/simple-schema'` call site.
+ */
+declare const s: {
+  readonly string: typeof string;
+  readonly number: typeof number;
+  readonly boolean: typeof boolean;
+  readonly void: typeof voidType;
+  readonly null: typeof nullType;
+  readonly literal: typeof literal;
+  readonly picklist: typeof picklist;
+  readonly union: typeof union;
+  readonly record: typeof record;
+  readonly array: typeof array;
+  readonly object: typeof object;
+  readonly optional: typeof optional;
+  readonly nullable: typeof nullable;
+  readonly describe: typeof describe;
+};
+//#endregion
 export { SimpleSchema, array, boolean, describe, literal, nullType, nullable, number, object, optional, picklist, record, s, string, union, voidType };

package/dist/utils/streaming-channel.d.mts

@@ -1,2 +1,2 @@
-import { at as StreamReader, ct as createStreamReader, it as StreamErrorPayload, lt as createStreamSink, nt as CreateStreamReaderOptions, ot as StreamSink, rt as CreateStreamSinkOptions, st as StreamSinkEvents, tt as BufferedChunk } from "../devframe-mQ4qZAuo.mjs";
+import { at as StreamErrorPayload, ct as StreamSinkEvents, it as CreateStreamSinkOptions, lt as createStreamReader, nt as BufferedChunk, ot as StreamReader, rt as CreateStreamReaderOptions, st as StreamSink, ut as createStreamSink } from "../devframe-Bdd9YXTy.mjs";
 export { BufferedChunk, CreateStreamReaderOptions, CreateStreamSinkOptions, StreamErrorPayload, StreamReader, StreamSink, StreamSinkEvents, createStreamReader, createStreamSink };