devframe 0.0.0 → 0.1.17

package/dist/static-dump-DwFfj4U_.mjs

@@ -0,0 +1,97 @@
+import { n as dumpFunctions, s as getRpcHandler } from "./rpc-hbRk8qtt.mjs";
+import { DEVTOOLS_RPC_DUMP_DIRNAME } from "./constants.mjs";
+//#region src/node/host-h3.ts
+/**
+* h3-backed {@link DevToolsHost} — used by the standalone CLI adapter.
+* This commit adds the shell; the CLI adapter in commit 5 wires it up
+* with a real h3 app and sirv handler.
+*/
+function createH3DevToolsHost(options) {
+	return {
+		mountStatic(base, distDir) {
+			return options.mount?.(base, distDir);
+		},
+		resolveOrigin() {
+			return options.origin;
+		}
+	};
+}
+//#endregion
+//#region src/node/static-dump.ts
+function makeDumpKey(name) {
+	return encodeURIComponent(name.replaceAll(":", "~"));
+}
+function makeStaticPath(name) {
+	return `${DEVTOOLS_RPC_DUMP_DIRNAME}/${makeDumpKey(name)}.static.json`;
+}
+function makeQueryRecordPath(name, hash) {
+	return `${DEVTOOLS_RPC_DUMP_DIRNAME}/${makeDumpKey(name)}.record.${hash}.json`;
+}
+function makeQueryFallbackPath(name) {
+	return `${DEVTOOLS_RPC_DUMP_DIRNAME}/${makeDumpKey(name)}.fallback.json`;
+}
+async function resolveRecord(record) {
+	return typeof record === "function" ? await record() : record;
+}
+async function collectStaticRpcDump(definitions, context) {
+	const manifest = {};
+	const files = {};
+	for (const definition of definitions) {
+		const type = definition.type ?? "query";
+		const serialization = definition.jsonSerializable === true ? "json" : "structured-clone";
+		if (type === "static") {
+			const handler = await getRpcHandler(definition, context);
+			const path = makeStaticPath(definition.name);
+			files[path] = {
+				serialization,
+				fnName: definition.name,
+				data: { output: await Promise.resolve(handler()) }
+			};
+			manifest[definition.name] = {
+				type: "static",
+				path,
+				serialization
+			};
+			continue;
+		}
+		if (type !== "query") continue;
+		const store = await dumpFunctions([definition], context);
+		if (!(definition.name in store.definitions)) continue;
+		const queryEntry = {
+			type: "query",
+			records: {},
+			serialization
+		};
+		const prefix = `${definition.name}---`;
+		for (const [recordKey, recordOrGetter] of Object.entries(store.records)) {
+			if (!recordKey.startsWith(prefix)) continue;
+			const key = recordKey.slice(prefix.length);
+			const record = await resolveRecord(recordOrGetter);
+			if (key === "fallback") {
+				const path = makeQueryFallbackPath(definition.name);
+				files[path] = {
+					serialization,
+					fnName: definition.name,
+					data: record
+				};
+				queryEntry.fallback = path;
+			} else {
+				const path = makeQueryRecordPath(definition.name, key);
+				files[path] = {
+					serialization,
+					fnName: definition.name,
+					data: record
+				};
+				queryEntry.records[key] = path;
+			}
+		}
+		if (!Object.keys(queryEntry.records).length && !queryEntry.fallback) continue;
+		manifest[definition.name] = queryEntry;
+	}
+	return {
+		manifest,
+		files
+	};
+}
+//#endregion
+export { createH3DevToolsHost as n, collectStaticRpcDump as t };

package/dist/transports-4bqw6Fqg.mjs

@@ -0,0 +1,15 @@
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+//#region src/node/mcp/transports.ts
+/**
+* Start the MCP server on stdio. Returns a stop function.
+* @internal
+*/
+async function startStdioTransport(server) {
+	const transport = new StdioServerTransport();
+	await server.connect(transport);
+	return async () => {
+		await server.close();
+	};
+}
+//#endregion
+export { startStdioTransport };

package/dist/types/index.d.mts

@@ -0,0 +1,4 @@
+import { $ as DevToolsLogsHost, $t as EventsMap, A as DevToolsViewHost, At as DevToolsDiagnosticsHost, B as DevToolsTerminalStatus, Bt as DevToolsServerCommandEntry, Ct as DevToolsViewLauncher, Dt as JsonRenderer, Et as JsonRenderSpec, F as DevToolsChildProcessTerminalSession, Ft as DevToolsCommandHandle, G as DevToolsLogElementPosition, Gt as AgentResourceContent, H as DevToolsRpcClientFunctions, Ht as AgentHandle, I as DevToolsTerminalHost, It as DevToolsCommandKeybinding, J as DevToolsLogEntryInput, Jt as AgentToolInput, K as DevToolsLogEntry, Kt as AgentResourceInput, L as DevToolsTerminalSession, Lt as DevToolsCommandShortcutOverrides, M as PartialWithoutId, Mt as DevToolsClientCommand, N as Thenable, Nt as DevToolsCommandBase, Ot as RemoteDockOptions, P as DevToolsChildProcessExecuteOptions, Pt as DevToolsCommandEntry, Q as DevToolsLogsClient, Qt as EventUnsubscribe, R as DevToolsTerminalSessionBase, Rt as DevToolsCommandsHost, St as DevToolsViewJsonRender, Tt as JsonRenderElement, U as DevToolsRpcServerFunctions, Ut as AgentManifest, V as DevToolsDocksUserSettings, Vt as DevToolsServerCommandInput, W as DevToolsRpcSharedStates, Wt as AgentResource, X as DevToolsLogHandle, Xt as DevToolsAgentHostEvents, Y as DevToolsLogFilePosition, Yt as DevToolsAgentHost, Z as DevToolsLogLevel, Zt as EventEmitter, _ as RpcSharedStateGetOptions, _t as DevToolsDockUserEntry, a as DevtoolRuntime, at as DevToolsMessageHandle, bt as DevToolsViewCustomRender, c as defineDevtool, ct as DevToolsMessagesHost, d as DevToolsNodeContext, dt as DevToolsDockEntriesGrouped, et as DevToolsMessageElementPosition, f as DevToolsNodeUtils, ft as DevToolsDockEntry, g as RpcFunctionsHost, gt as DevToolsDockHost, h as RpcBroadcastOptions, ht as DevToolsDockEntryIcon, i as DevtoolDeploymentKind, it as DevToolsMessageFilePosition, j as EntriesToObject, jt as DevToolsDiagnosticsLogger, kt as DevToolsDiagnosticsDefinition, l as ConnectionMeta, lt as DevToolsHost, m as DevToolsNodeRpcSession, mt as DevToolsDockEntryCategory, n as DevtoolCliOptions, nt as DevToolsMessageEntryFrom, o as DevtoolSetupInfo, ot as DevToolsMessageLevel, p as RemoteConnectionInfo, pt as DevToolsDockEntryBase, q as DevToolsLogEntryFrom, qt as AgentTool, r as DevtoolDefinition, rt as DevToolsMessageEntryInput, s as DevtoolSpaOptions, st as DevToolsMessagesClient, t as DevtoolBrowserContext, tt as DevToolsMessageEntry, u as DevToolsCapabilities, ut as ClientScriptEntry, v as RpcSharedStateHost, vt as DevToolsViewAction, wt as DevToolsViewLauncherStatus, xt as DevToolsViewIframe, yt as DevToolsViewBuiltin, z as DevToolsTerminalSessionStreamChunkEvent, zt as DevToolsCommandsHostEvents } from "../devtool-CHT-4_OU.mjs";
+import { m as RpcFunctionAgentOptions } from "../types-BkyzI9r4.mjs";
+import { t as DevToolsNodeRpcSessionMeta } from "../ws-server-Cu8tmZcF.mjs";
+export { AgentHandle, AgentManifest, AgentResource, AgentResourceContent, AgentResourceInput, AgentTool, AgentToolInput, ClientScriptEntry, ConnectionMeta, DevToolsAgentHost, DevToolsAgentHostEvents, DevToolsCapabilities, DevToolsChildProcessExecuteOptions, DevToolsChildProcessTerminalSession, DevToolsClientCommand, DevToolsCommandBase, DevToolsCommandEntry, DevToolsCommandHandle, DevToolsCommandKeybinding, DevToolsCommandShortcutOverrides, DevToolsCommandsHost, DevToolsCommandsHostEvents, DevToolsDiagnosticsDefinition, DevToolsDiagnosticsHost, DevToolsDiagnosticsLogger, DevToolsDockEntriesGrouped, DevToolsDockEntry, DevToolsDockEntryBase, DevToolsDockEntryCategory, DevToolsDockEntryIcon, DevToolsDockHost, DevToolsDockUserEntry, DevToolsDocksUserSettings, DevToolsHost, DevToolsLogElementPosition, DevToolsLogEntry, DevToolsLogEntryFrom, DevToolsLogEntryInput, DevToolsLogFilePosition, DevToolsLogHandle, DevToolsLogLevel, DevToolsLogsClient, DevToolsLogsHost, DevToolsMessageElementPosition, DevToolsMessageEntry, DevToolsMessageEntryFrom, DevToolsMessageEntryInput, DevToolsMessageFilePosition, DevToolsMessageHandle, DevToolsMessageLevel, DevToolsMessagesClient, DevToolsMessagesHost, DevToolsNodeContext, DevToolsNodeRpcSession, DevToolsNodeRpcSessionMeta, DevToolsNodeUtils, DevToolsRpcClientFunctions, DevToolsRpcServerFunctions, DevToolsRpcSharedStates, DevToolsServerCommandEntry, DevToolsServerCommandInput, DevToolsTerminalHost, DevToolsTerminalSession, DevToolsTerminalSessionBase, DevToolsTerminalSessionStreamChunkEvent, DevToolsTerminalStatus, DevToolsViewAction, DevToolsViewBuiltin, DevToolsViewCustomRender, DevToolsViewHost, DevToolsViewIframe, DevToolsViewJsonRender, DevToolsViewLauncher, DevToolsViewLauncherStatus, DevtoolBrowserContext, DevtoolCliOptions, DevtoolDefinition, DevtoolDeploymentKind, DevtoolRuntime, DevtoolSetupInfo, DevtoolSpaOptions, EntriesToObject, EventEmitter, EventUnsubscribe, EventsMap, JsonRenderElement, JsonRenderSpec, JsonRenderer, PartialWithoutId, RemoteConnectionInfo, RemoteDockOptions, RpcBroadcastOptions, RpcFunctionAgentOptions, RpcFunctionsHost, RpcSharedStateGetOptions, RpcSharedStateHost, Thenable, defineDevtool };

package/dist/types/index.mjs

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

package/dist/types-BkyzI9r4.d.mts

@@ -0,0 +1,273 @@
+import { GenericSchema, InferInput } from "valibot";
+import { BirpcFn, BirpcReturn as BirpcReturn$1 } from "birpc";
+
+//#region src/rpc/utils.d.ts
+/** Infers TypeScript tuple type from Valibot schema array */
+type InferArgsType<S extends RpcArgsSchema | undefined> = S extends readonly [] ? [] : S extends readonly [infer H, ...infer T] ? H extends GenericSchema ? T extends readonly GenericSchema[] ? [InferInput<H>, ...InferArgsType<T>] : never : never : never;
+/** Infers TypeScript return type from Valibot return schema */
+type InferReturnType<S extends RpcReturnSchema | undefined> = S extends RpcReturnSchema ? InferInput<S> : void;
+//#endregion
+//#region src/rpc/types.d.ts
+type Thenable<T> = T | Promise<T>;
+type EntriesToObject<T extends readonly [string, any][]> = { [K in T[number] as K[0]]: K[1] };
+/**
+ * Type of the RPC function,
+ * - static: A function that returns a static data, no arguments (can be cached and dumped)
+ * - action: A function that performs an action (no data returned)
+ * - event: A function that emits an event (no data returned), and does not wait for a response
+ * - query: A function that queries a resource
+ *
+ * By default, the function is a query function.
+ */
+type RpcFunctionType = 'static' | 'action' | 'event' | 'query';
+/**
+ * Agent exposure settings for an RPC function. When this field is set,
+ * 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 {
+  /**
+   * Human-readable description shown to the agent. Required — agents
+   * rely on this to decide when to invoke the tool. Keep it to ~1–3
+   * sentences explaining what the tool does and when to use it.
+   */
+  description: string;
+  /**
+   * Optional human-friendly display title. Maps to the MCP tool `title`
+   * annotation. Falls back to the RPC function `name` when omitted.
+   */
+  title?: string;
+  /**
+   * Safety classification. Drives MCP annotations (`readOnlyHint`,
+   * `destructiveHint`) downstream.
+   * - `'read'` — no side effects; safe to call freely.
+   * - `'action'` — mutates state but not destructive.
+   * - `'destructive'` — may perform destructive updates.
+   *
+   * When omitted it is inferred from the function `type`:
+   *   - `'static'` / `'query'` → `'read'`
+   *   - `'action'` / `'event'` → `'action'`
+   */
+  safety?: 'read' | 'action' | 'destructive';
+  /** Free-form tags for grouping or filtering. */
+  tags?: readonly string[];
+  /**
+   * Optional example invocations shown to agents. Returned verbatim in
+   * the agent manifest.
+   */
+  examples?: readonly {
+    args: unknown[];
+    description?: string;
+  }[];
+}
+/**
+ * Manages dynamic function registration and provides a type-safe proxy for accessing functions.
+ */
+interface RpcFunctionsCollector<LocalFunctions, SetupContext = undefined> {
+  /** User-provided context passed to setup functions */
+  context: SetupContext;
+  /** Type-safe proxy for calling registered functions */
+  readonly functions: LocalFunctions;
+  /** Map of registered function definitions keyed by function name */
+  readonly definitions: Map<string, RpcFunctionDefinitionAnyWithContext<SetupContext>>;
+  /** Register a new function definition */
+  register: (fn: RpcFunctionDefinitionAnyWithContext<SetupContext>) => void;
+  /** Update an existing function definition */
+  update: (fn: RpcFunctionDefinitionAnyWithContext<SetupContext>) => void;
+  /** Subscribe to function changes, returns unsubscribe function */
+  onChanged: (fn: (id?: string) => void) => (() => void);
+}
+/**
+ * Result returned by a function's setup method.
+ */
+interface RpcFunctionSetupResult<ARGS extends any[], RETURN = void> {
+  /** Function handler */
+  handler?: (...args: ARGS) => RETURN;
+  /** Optional dump definition (overrides definition-level dump) */
+  dump?: RpcDumpDefinition<ARGS, RETURN>;
+}
+/** Valibot schema array for validating function arguments */
+type RpcArgsSchema = readonly GenericSchema[];
+/** Valibot schema for validating function return value */
+type RpcReturnSchema = GenericSchema;
+/**
+ * Single record in a dump store with pre-computed results.
+ */
+interface RpcDumpRecord<ARGS extends any[] = any[], RETURN = any> {
+  /** Function arguments */
+  inputs: ARGS;
+  /** Result (value or lazy function) */
+  output?: RETURN;
+  /** Error if execution failed */
+  error?: {
+    /** Error message */message: string; /** Error type name (e.g., "Error", "TypeError") */
+    name: string;
+  };
+}
+/**
+ * Defines argument combinations to pre-compute for a function.
+ */
+interface RpcDumpDefinition<ARGS extends any[] = any[], RETURN = any> {
+  /** Argument combinations to pre-compute by executing handler */
+  inputs?: ARGS[];
+  /** Pre-computed records to use directly (bypasses handler execution) */
+  records?: RpcDumpRecord<ARGS, RETURN>[];
+  /** Fallback value when no match found */
+  fallback?: RETURN;
+}
+/**
+ * Dynamically generates dump definitions based on context.
+ */
+type RpcDumpGetter<ARGS extends any[] = any[], RETURN = any, CONTEXT = any> = (context: CONTEXT, handler: (...args: ARGS) => RETURN) => Thenable<RpcDumpDefinition<ARGS, RETURN>>;
+/**
+ * Dump configuration (static object or dynamic function).
+ */
+type RpcDump<ARGS extends any[] = any[], RETURN = any, CONTEXT = any> = RpcDumpDefinition<ARGS, RETURN> | RpcDumpGetter<ARGS, RETURN, CONTEXT>;
+/**
+ * Base function definition metadata.
+ */
+interface RpcFunctionDefinitionBase {
+  /** Function name (unique identifier) */
+  name: string;
+  /** Function type (static, action, event, or query) */
+  type?: RpcFunctionType;
+  /**
+   * Declares whether this function's args/return are JSON-serializable
+   * — i.e. no `Map`, `Set`, `Date`, `BigInt`, class instances, circular
+   * references, `undefined` leaves, `Symbol`, or `Function` values.
+   *
+   * - `true` — args and return are encoded with strict `JSON.stringify`
+   *   on the wire and on disk. Misshapen values throw `DF0019` at the
+   *   sender, surfacing the bug *during the offending call* rather than
+   *   silently coercing to `{}` later. Required for `agent` exposure.
+   * - `false` (default) — payloads use `structured-clone-es`, which
+   *   round-trips Maps/Sets/cycles. Functions in this mode cannot be
+   *   exposed via the `agent` field — registration throws `DF0018`.
+   */
+  jsonSerializable?: boolean;
+}
+/**
+ * Dump store containing pre-computed results.
+ * Flat structure for serialization and efficient lookups.
+ */
+interface RpcDumpStore<T = any> {
+  /** Function definitions keyed by name */
+  definitions: Record<string, RpcFunctionDefinitionBase>;
+  /** Records keyed by '<function-name>---<hash>' or '<function-name>---fallback' */
+  records: Record<string, RpcDumpRecord | (() => Promise<RpcDumpRecord>)>;
+  /** @internal */
+  _functions?: T;
+}
+/**
+ * Dump client options.
+ */
+interface RpcDumpClientOptions {
+  /** Called when arguments don't match any pre-computed entry */
+  onMiss?: (functionName: string, args: any[]) => void;
+}
+/**
+ * Options for collecting dumps.
+ */
+interface RpcDumpCollectionOptions {
+  /**
+   * Concurrency control for parallel execution.
+   * - `false` or `undefined`: sequential execution (default)
+   * - `true`: parallel execution with concurrency limit of 5
+   * - `number`: parallel execution with specified concurrency limit
+   */
+  concurrency?: boolean | number | null;
+}
+/**
+ * RPC function definition with optional dump support.
+ */
+type RpcFunctionDefinition<NAME extends string, TYPE extends RpcFunctionType = 'query', ARGS extends any[] = [], RETURN = void, AS extends RpcArgsSchema | undefined = undefined, RS extends RpcReturnSchema | undefined = undefined, CONTEXT = undefined> = [AS, RS] extends [undefined, undefined] ? {
+  /** Function name (unique identifier) */name: NAME; /** Function type (static, action, event, or query) */
+  type?: TYPE; /** Whether the function results should be cached */
+  cacheable?: boolean; /** Valibot schema array for validating function arguments */
+  args?: AS; /** Valibot schema for validating function return value */
+  returns?: RS;
+  /**
+   * Declares whether this function's args/return are JSON-serializable
+   * (no Map/Set/Date/BigInt/cycles/class instances/undefined/Symbol/Function).
+   *
+   * - `true` — wire and dump use strict `JSON.stringify`; misshapen
+   *   values throw `DF0019` at the call site. Required for `agent`.
+   * - `false` (default) — `structured-clone-es` round-trips fancy
+   *   types. Cannot be `agent`-exposed (registration throws `DF0018`).
+   */
+  jsonSerializable?: boolean;
+  /**
+   * 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 */
+  setup?: (context: CONTEXT) => Thenable<RpcFunctionSetupResult<ARGS, RETURN>>; /** Function implementation (required if setup doesn't provide one) */
+  handler?: (...args: ARGS) => RETURN; /** Dump definition (setup dump takes priority) */
+  dump?: RpcDump<ARGS, RETURN, CONTEXT>;
+  /**
+   * Sugar for "query in dev, single baked snapshot in build": when
+   * `true` and no `dump` is provided, the build adapter runs the
+   * handler once with no arguments and stores the result as both a
+   * no-args record and the fallback so any call variant resolves
+   * to the same snapshot. Only valid on `query` (or untyped)
+   * functions — `static` already has equivalent default behavior.
+   */
+  snapshot?: boolean;
+  __resolved?: RpcFunctionSetupResult<ARGS, RETURN>;
+  __promise?: Thenable<RpcFunctionSetupResult<ARGS, RETURN>>;
+} : {
+  /** Function name (unique identifier) */name: NAME; /** Function type (static, action, event, or query) */
+  type?: TYPE; /** Whether the function results should be cached */
+  cacheable?: boolean; /** Valibot schema array for validating function arguments */
+  args: AS; /** Valibot schema for validating function return value */
+  returns: RS;
+  /**
+   * Declares whether this function's args/return are JSON-serializable
+   * (no Map/Set/Date/BigInt/cycles/class instances/undefined/Symbol/Function).
+   *
+   * - `true` — wire and dump use strict `JSON.stringify`; misshapen
+   *   values throw `DF0019` at the call site. Required for `agent`.
+   * - `false` (default) — `structured-clone-es` round-trips fancy
+   *   types. Cannot be `agent`-exposed (registration throws `DF0018`).
+   */
+  jsonSerializable?: boolean;
+  /**
+   * 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 */
+  setup?: (context: CONTEXT) => Thenable<RpcFunctionSetupResult<InferArgsType<AS>, InferReturnType<RS>>>; /** Function implementation (required if setup doesn't provide one) */
+  handler?: (...args: InferArgsType<AS>) => InferReturnType<RS>; /** Dump definition (setup dump takes priority) */
+  dump?: RpcDump<InferArgsType<AS>, InferReturnType<RS>, CONTEXT>;
+  /**
+   * Sugar for "query in dev, single baked snapshot in build": when
+   * `true` and no `dump` is provided, the build adapter runs the
+   * handler once with no arguments and stores the result as both a
+   * no-args record and the fallback so any call variant resolves
+   * to the same snapshot. Only valid on `query` (or untyped)
+   * functions — `static` already has equivalent default behavior.
+   */
+  snapshot?: boolean;
+  __resolved?: RpcFunctionSetupResult<InferArgsType<AS>, InferReturnType<RS>>;
+  __promise?: Thenable<RpcFunctionSetupResult<InferArgsType<AS>, InferReturnType<RS>>>;
+};
+type RpcFunctionDefinitionToFunction<T extends RpcFunctionDefinitionAny> = T extends {
+  args: infer AS;
+  returns: infer RS;
+} ? AS extends RpcArgsSchema ? RS extends RpcReturnSchema ? (...args: InferArgsType<AS>) => InferReturnType<RS> : never : never : T extends RpcFunctionDefinition<string, any, infer ARGS, infer RETURN, any, any, any> ? (...args: ARGS) => RETURN : never;
+type RpcFunctionDefinitionAny = RpcFunctionDefinition<string, any, any, any, any, any, any>;
+type RpcFunctionDefinitionAnyWithContext<CONTEXT = undefined> = RpcFunctionDefinition<string, any, any, any, any, any, CONTEXT>;
+type RpcDefinitionsToFunctions<T extends readonly RpcFunctionDefinitionAny[]> = EntriesToObject<{ [K in keyof T]: [T[K]['name'], RpcFunctionDefinitionToFunction<T[K]>] }>;
+type RpcDefinitionsFilter<T extends readonly RpcFunctionDefinitionAny[], Type extends RpcFunctionType> = { [K in keyof T]: T[K] extends {
+  type: Type;
+} ? T[K] : never };
+//#endregion
+export { RpcReturnSchema as C, RpcFunctionsCollector as S, RpcFunctionDefinitionAnyWithContext as _, RpcDefinitionsFilter as a, RpcFunctionSetupResult as b, RpcDumpClientOptions as c, RpcDumpGetter as d, RpcDumpRecord as f, RpcFunctionDefinitionAny as g, RpcFunctionDefinition as h, RpcArgsSchema as i, RpcDumpCollectionOptions as l, RpcFunctionAgentOptions as m, BirpcReturn$1 as n, RpcDefinitionsToFunctions as o, RpcDumpStore as p, EntriesToObject as r, RpcDump as s, BirpcFn as t, RpcDumpDefinition as u, RpcFunctionDefinitionBase as v, Thenable as w, RpcFunctionType as x, RpcFunctionDefinitionToFunction as y };

package/dist/utils/events.d.mts

@@ -0,0 +1,9 @@
+import { $t as EventsMap, Zt as EventEmitter } from "../devtool-CHT-4_OU.mjs";
+
+//#region src/utils/events.d.ts
+/**
+ * Create event emitter.
+ */
+declare function createEventEmitter<Events extends EventsMap>(): EventEmitter<Events>;
+//#endregion
+export { createEventEmitter };

package/dist/utils/events.mjs

@@ -0,0 +1,40 @@
+//#region src/utils/events.ts
+/**
+* Create event emitter.
+*/
+function createEventEmitter() {
+	const _listeners = {};
+	function emit(event, ...args) {
+		const callbacks = _listeners[event] || [];
+		for (let i = 0, length = callbacks.length; i < length; i++) {
+			const callback = callbacks[i];
+			if (callback) callback(...args);
+		}
+	}
+	function emitOnce(event, ...args) {
+		emit(event, ...args);
+		delete _listeners[event];
+	}
+	function on(event, cb) {
+		(_listeners[event] ||= []).push(cb);
+		return () => {
+			_listeners[event] = _listeners[event]?.filter((i) => cb !== i);
+		};
+	}
+	function once(event, cb) {
+		const unsubscribe = on(event, ((...args) => {
+			unsubscribe();
+			return cb(...args);
+		}));
+		return unsubscribe;
+	}
+	return {
+		_listeners,
+		emit,
+		emitOnce,
+		on,
+		once
+	};
+}
+//#endregion
+export { createEventEmitter };

package/dist/utils/human-id.d.mts

@@ -0,0 +1,10 @@
+//#region ../../../node_modules/.pnpm/human-id@4.1.3/node_modules/human-id/dist/index.d.ts
+interface Options {
+  separator?: string;
+  capitalize?: boolean;
+  adjectiveCount?: number;
+  addAdverb?: boolean;
+}
+declare function humanId(options?: Options | string | boolean): string;
+//#endregion
+export { humanId };

package/dist/utils/human-id.mjs

@@ -0,0 +1,3 @@
+import { t as import_dist } from "../human-id-CHS0s28X.mjs";
+var humanId = import_dist.humanId;
+export { humanId };

package/dist/utils/nanoid.d.mts

@@ -0,0 +1,4 @@
+//#region src/utils/nanoid.d.ts
+declare function nanoid(size?: number): string;
+//#endregion
+export { nanoid };

package/dist/utils/nanoid.mjs

@@ -0,0 +1,10 @@
+//#region src/utils/nanoid.ts
+const urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+function nanoid(size = 21) {
+	let id = "";
+	let i = size;
+	while (i--) id += urlAlphabet[Math.random() * 64 | 0];
+	return id;
+}
+//#endregion
+export { nanoid };

package/dist/utils/promise.d.mts

@@ -0,0 +1,8 @@
+//#region src/utils/promise.d.ts
+declare function promiseWithResolver<T>(): {
+  promise: Promise<T>;
+  resolve: (value: T) => void;
+  reject: (error: Error) => void;
+};
+//#endregion
+export { promiseWithResolver };

package/dist/utils/promise.mjs

@@ -0,0 +1,15 @@
+//#region src/utils/promise.ts
+function promiseWithResolver() {
+	let resolve;
+	let reject;
+	return {
+		promise: new Promise((_resolve, _reject) => {
+			resolve = _resolve;
+			reject = _reject;
+		}),
+		resolve,
+		reject
+	};
+}
+//#endregion
+export { promiseWithResolver };

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

@@ -0,0 +1,2 @@
+import { C as ImmutableSet, D as createSharedState, E as SharedStateOptions, S as ImmutableObject, T as SharedStateEvents, b as ImmutableArray, k as Patch, w as SharedState, x as ImmutableMap, y as Immutable } from "../devtool-CHT-4_OU.mjs";
+export { Immutable, ImmutableArray, ImmutableMap, ImmutableObject, ImmutableSet, SharedState, SharedStateEvents, SharedStateOptions, Patch as SharedStatePatch, createSharedState };

package/dist/utils/shared-state.mjs

@@ -0,0 +1,36 @@
+import { createEventEmitter } from "./events.mjs";
+import { i as produceWithPatches, n as enablePatches, r as produce, t as applyPatches } from "../immer-DEqg5kOd.mjs";
+import { nanoid } from "./nanoid.mjs";
+//#region src/utils/shared-state.ts
+function createSharedState(options) {
+	const { enablePatches: enablePatches$1 = false } = options;
+	const events = createEventEmitter();
+	let state = options.initialValue;
+	const syncIds = /* @__PURE__ */ new Set();
+	return {
+		on: events.on,
+		value: () => state,
+		patch: (patches, syncId = nanoid()) => {
+			if (syncIds.has(syncId)) return;
+			enablePatches();
+			state = applyPatches(state, patches);
+			syncIds.add(syncId);
+			events.emit("updated", state, void 0, syncId);
+		},
+		mutate: (fn, syncId = nanoid()) => {
+			if (syncIds.has(syncId)) return;
+			syncIds.add(syncId);
+			if (enablePatches$1) {
+				const [newState, patches] = produceWithPatches(state, fn);
+				state = newState;
+				events.emit("updated", state, patches, syncId);
+			} else {
+				state = produce(state, fn);
+				events.emit("updated", state, void 0, syncId);
+			}
+		},
+		syncIds
+	};
+}
+//#endregion
+export { createSharedState };

package/dist/utils/state.d.mts

@@ -0,0 +1,49 @@
+import { O as Objectish, Zt as EventEmitter, k as Patch } from "../devtool-CHT-4_OU.mjs";
+
+//#region src/utils/state.d.ts
+type ImmutablePrimitive = undefined | null | boolean | string | number | Function;
+type Immutable<T> = T extends ImmutablePrimitive ? T : T extends Array<infer U> ? ImmutableArray<U> : T extends Map<infer K, infer V> ? ImmutableMap<K, V> : T extends Set<infer M> ? ImmutableSet<M> : ImmutableObject<T>;
+type ImmutableArray<T> = ReadonlyArray<Immutable<T>>;
+type ImmutableMap<K, V> = ReadonlyMap<Immutable<K>, Immutable<V>>;
+type ImmutableSet<T> = ReadonlySet<Immutable<T>>;
+type ImmutableObject<T> = { readonly [K in keyof T]: Immutable<T[K]> };
+/**
+ * State host that is immutable by default with explicit mutate.
+ */
+interface SharedState<T> {
+  /**
+   * Get the current state. Immutable.
+   */
+  get: () => Immutable<T>;
+  /**
+   * Subscribe to state changes.
+   */
+  on: EventEmitter<SharedStateEvents<T>>['on'];
+  /**
+   * Mutate the state.
+   */
+  mutate: (fn: (state: T) => void) => void;
+  /**
+   * Apply patches to the state.
+   */
+  patch: (patches: Patch[]) => void;
+}
+interface SharedStateEvents<T> {
+  updated: (state: T) => void;
+  patches: (patches: Patch[]) => void;
+}
+interface SharedStateOptions<T> {
+  /**
+   * Initial state.
+   */
+  initialState: T;
+  /**
+   * Enable patches.
+   *
+   * @default false
+   */
+  enablePatches?: boolean;
+}
+declare function createSharedState<T extends Objectish>(options: SharedStateOptions<T>): SharedState<T>;
+//#endregion
+export { Immutable, ImmutableArray, ImmutableMap, ImmutableObject, ImmutableSet, SharedState, SharedStateEvents, SharedStateOptions, createSharedState };

package/dist/utils/state.mjs

@@ -0,0 +1,26 @@
+import { createEventEmitter } from "./events.mjs";
+import { i as produceWithPatches, r as produce, t as applyPatches } from "../immer-DEqg5kOd.mjs";
+//#region src/utils/state.ts
+function createSharedState(options) {
+	const { enablePatches = false } = options;
+	const events = createEventEmitter();
+	let state = options.initialState;
+	return {
+		on: events.on,
+		get: () => state,
+		patch: (patches) => {
+			state = applyPatches(state, patches);
+			events.emit("updated", state);
+		},
+		mutate: (fn) => {
+			if (enablePatches) {
+				const [newState, patches] = produceWithPatches(state, fn);
+				state = newState;
+				events.emit("patches", patches);
+			} else state = produce(state, fn);
+			events.emit("updated", state);
+		}
+	};
+}
+//#endregion
+export { createSharedState };

package/dist/utils/when.d.mts

@@ -0,0 +1,2 @@
+import { i as resolveContextValue, n as WhenExpression, r as evaluateWhen, t as WhenContext } from "../when-aBBXAEh5.mjs";
+export { WhenContext, WhenExpression, evaluateWhen, resolveContextValue };