devframe 0.4.0 → 0.4.1

package/dist/adapters/build.d.mts

@@ -1,4 +1,4 @@
-import { r as DevframeDefinition } from "../devframe-xC8Q-xyt.mjs";
+import { r as DevframeDefinition } from "../devframe-K4IxpM4a.mjs";
 
 //#region src/adapters/build.d.ts
 interface CreateBuildOptions {

package/dist/adapters/cli.d.mts

@@ -1,6 +1,6 @@
-import { G as CliFlagsSchema, J as parseCliFlags, K as InferCliFlags, q as defineCliFlags, r as DevframeDefinition } from "../devframe-xC8Q-xyt.mjs";
-import { H3 } from "h3";
+import { dt as defineCliFlags, ft as parseCliFlags, lt as CliFlagsSchema, r as DevframeDefinition, ut as InferCliFlags } from "../devframe-K4IxpM4a.mjs";
 import { CAC } from "cac";
+import { H3 } from "h3";
 
 //#region src/adapters/cli.d.ts
 interface CreateCliOptions {

package/dist/adapters/dev.d.mts

@@ -1,5 +1,5 @@
-import { r as DevframeDefinition } from "../devframe-xC8Q-xyt.mjs";
-import { n as StartedServer } from "../server-FNcskEBD.mjs";
+import { r as DevframeDefinition } from "../devframe-K4IxpM4a.mjs";
+import { n as StartedServer } from "../server-KzCqriO9.mjs";
 import { H3 } from "h3";
 
 //#region src/adapters/dev.d.ts

package/dist/adapters/embedded.d.mts

@@ -1,4 +1,4 @@
-import { d as DevToolsNodeContext, r as DevframeDefinition } from "../devframe-xC8Q-xyt.mjs";
+import { d as DevToolsNodeContext, r as DevframeDefinition } from "../devframe-K4IxpM4a.mjs";
 
 //#region src/adapters/embedded.d.ts
 interface CreateEmbeddedOptions {

package/dist/adapters/mcp.d.mts

@@ -1,6 +1,4 @@
-import { r as DevframeDefinition } from "../devframe-xC8Q-xyt.mjs";
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-
+import { r as DevframeDefinition } from "../devframe-K4IxpM4a.mjs";
 //#region src/adapters/mcp/build-server.d.ts
 interface CreateMcpServerOptions {
   /**

package/dist/client/index.d.mts

@@ -1,23 +1,9 @@
-import { D as RpcCacheOptions, E as RpcCacheManager, O as RpcFunctionDefinitionAny, i as DevToolsRpcServerFunctions, k as RpcFunctionsCollector, l as StreamReader, n as RpcSharedStateHost, r as DevToolsRpcClientFunctions, t as ConnectionMeta, u as StreamSink, w as EventEmitter } from "../index-DTeZXHSi.mjs";
+import { T as StreamSink, U as DevToolsRpcClientFunctions, W as DevToolsRpcServerFunctions, g as RpcSharedStateHost, l as ConnectionMeta, ot as EventEmitter, w as StreamReader } from "../devframe-K4IxpM4a.mjs";
+import { C as RpcFunctionsCollector } from "../types-dNW3UmMl.mjs";
+import { C as RpcCacheManager, w as RpcCacheOptions } from "../index-CBSBvT9K.mjs";
+import { t as WsRpcChannelOptions } from "../ws-client-BZptK_Mf.mjs";
 import { BirpcOptions, BirpcReturn } from "birpc";
 
-//#region src/rpc/transports/ws-client.d.ts
-interface WsRpcChannelOptions {
-  url: string;
-  onConnected?: (e: Event) => void;
-  onError?: (e: Error) => void;
-  onDisconnected?: (e: CloseEvent) => void;
-  authToken?: string;
-  /**
-   * RPC function definitions (or just the `jsonSerializable` flag per
-   * method) used to dispatch the per-call wire serializer. Pass an
-   * empty / partial map on clients that don't have the full registry —
-   * encoding falls back to structured-clone (the safer superset) and
-   * decoding still routes correctly via the wire prefix.
-   */
-  definitions?: ReadonlyMap<string, Pick<RpcFunctionDefinitionAny, 'jsonSerializable'>>;
-}
-//#endregion
 //#region src/client/rpc-streaming.d.ts
 interface StreamingSubscribeOptions {
   /** Maximum buffered chunks before the oldest is dropped. Default 256. */

package/dist/{context-Ca70YtrW.d.mts → context-C9oW88gr.d.mts}

@@ -1,4 +1,4 @@
-import { b as SharedState, d as DevToolsNodeContext } from "./devframe-xC8Q-xyt.mjs";
+import { P as SharedState, d as DevToolsNodeContext } from "./devframe-K4IxpM4a.mjs";
 
 //#region src/node/internal/context.d.ts
 interface InternalAnonymousAuthStorage {

package/dist/{devframe-xC8Q-xyt.d.mts → devframe-K4IxpM4a.d.mts}

@@ -1,9 +1,9 @@
-import { S as RpcFunctionsCollectorBase } from "./index-CTK6fuXs.mjs";
-import { t as DevToolsNodeRpcSessionMeta } from "./ws-server-DOwLJL23.mjs";
-import { Diagnostic, DiagnosticDefinition, defineDiagnostics } from "nostics";
-import { BirpcReturn } from "birpc";
+import { S as RpcFunctionsCollectorBase } from "./index-CBSBvT9K.mjs";
+import { t as DevToolsNodeRpcSessionMeta } from "./ws-server-CTeMCO1r.mjs";
 import { CAC } from "cac";
 import { GenericSchema, InferOutput } from "valibot";
+import { BirpcReturn } from "birpc";
+import { Diagnostic, DiagnosticDefinition, defineDiagnostics } from "nostics";
 
 //#region src/adapters/flags.d.ts
 /**
@@ -573,6 +573,19 @@ interface SharedState<T> {
 interface SharedStateEvents<T> {
   updated: (fullState: T, patches: SharedStatePatch[] | undefined, syncId: string) => void;
 }
+interface SharedStateOptions<T> {
+  /**
+   * Initial state.
+   */
+  initialValue: T;
+  /**
+   * Enable patches.
+   *
+   * @default false
+   */
+  enablePatches?: boolean;
+}
+declare function createSharedState<T extends object>(options: SharedStateOptions<T>): SharedState<T>;
 //#endregion
 //#region src/utils/streaming-channel.d.ts
 /**
@@ -600,6 +613,14 @@ interface StreamSinkEvents<T> {
   /** Terminal — fired exactly once per sink lifetime. */
   end: (error?: StreamErrorPayload) => void;
 }
+interface CreateStreamSinkOptions {
+  id?: string;
+  /**
+   * Size of the per-stream ring buffer kept for replay-on-resubscribe.
+   * `0` (default) disables replay.
+   */
+  replayWindow?: number;
+}
 /**
  * Server-side producer handle. Two equivalent surfaces share one piece of
  * state: the imperative `write/error/close` triple, and a `WritableStream<T>`
@@ -640,6 +661,22 @@ interface StreamSink<T> {
    */
   readonly buffer: ReadonlyArray<BufferedChunk<T>>;
 }
+interface CreateStreamReaderOptions {
+  id?: string;
+  /**
+   * Maximum number of buffered chunks held client-side while the consumer
+   * isn't draining. On overflow, the oldest chunk is dropped.
+   */
+  highWaterMark?: number;
+  /**
+   * Called when the chunk queue overflows the high-water mark. The RPC
+   * layer wires this to a coded warning; the primitive itself is
+   * RPC-agnostic.
+   */
+  onOverflow?: (dropped: number) => void;
+  /** Called when the consumer cancels — the RPC layer sends `:cancel` upstream. */
+  onCancel?: () => void;
+}
 /**
  * Client-side consumer handle. Both an `AsyncIterable<T>` (for `for await`)
  * and exposes `readable: ReadableStream<T>` (for `pipeTo`). Pick one — they
@@ -659,6 +696,18 @@ interface StreamReader<T> extends AsyncIterable<T> {
   /** @internal */
   _end: (error?: StreamErrorPayload) => void;
 }
+/**
+ * Build a server-side stream sink. RPC-agnostic — the RPC host wires
+ * `events.on('chunk' | 'end')` to broadcast, and reads `buffer` to replay
+ * for late or reconnecting subscribers.
+ */
+declare function createStreamSink<T>(options?: CreateStreamSinkOptions): StreamSink<T>;
+/**
+ * Build a client-side stream reader. RPC-agnostic — the RPC host calls
+ * `_push(seq, chunk)` on each incoming chunk and `_end(error?)` on the
+ * terminal frame. Consumers iterate with `for await` or pipe `readable`.
+ */
+declare function createStreamReader<T>(options?: CreateStreamReaderOptions): StreamReader<T>;
 //#endregion
 //#region src/types/rpc.d.ts
 interface DevToolsNodeRpcSession {
@@ -1007,4 +1056,4 @@ interface DevframeDefinition {
 }
 declare function defineDevframe(d: DevframeDefinition): DevframeDefinition;
 //#endregion
-export { DevToolsDiagnosticsDefinition as A, DevToolsAgentHost as B, PartialWithoutId as C, DevToolsRpcSharedStates as D, DevToolsRpcServerFunctions as E, AgentResource as F, CliFlagsSchema as G, EventEmitter as H, AgentResourceContent as I, parseCliFlags as J, InferCliFlags as K, AgentResourceInput as L, DevToolsDiagnosticsLogger as M, AgentHandle as N, DevToolsHost as O, AgentManifest as P, AgentTool as R, EntriesToObject as S, DevToolsRpcClientFunctions as T, EventUnsubscribe as U, DevToolsAgentHostEvents as V, EventsMap as W, RpcStreamingChannel as _, DevframeRuntime as a, SharedState as b, defineDevframe as c, DevToolsNodeContext as d, DevToolsNodeRpcSession as f, RpcSharedStateHost as g, RpcSharedStateGetOptions as h, DevframeDeploymentKind as i, DevToolsDiagnosticsHost as j, DevToolsDefineDiagnosticsOptions as k, ConnectionMeta as l, RpcFunctionsHost as m, DevframeCliOptions as n, DevframeSetupInfo as o, RpcBroadcastOptions as p, defineCliFlags as q, DevframeDefinition as r, DevframeSpaOptions as s, DevframeBrowserContext as t, DevToolsCapabilities as u, RpcStreamingChannelOptions as v, Thenable as w, DevToolsViewHost as x, RpcStreamingHost as y, AgentToolInput as z };
+export { AgentResource as $, ImmutableArray as A, EntriesToObject as B, StreamErrorPayload as C, createStreamReader as D, StreamSinkEvents as E, SharedStateEvents as F, DevToolsRpcSharedStates as G, Thenable as H, SharedStateOptions as I, DevToolsDiagnosticsDefinition as J, DevToolsHost as K, SharedStatePatch as L, ImmutableObject as M, ImmutableSet as N, createStreamSink as O, SharedState as P, AgentManifest as Q, createSharedState as R, CreateStreamSinkOptions as S, StreamSink as T, DevToolsRpcClientFunctions as U, PartialWithoutId as V, DevToolsRpcServerFunctions as W, DevToolsDiagnosticsLogger as X, DevToolsDiagnosticsHost as Y, AgentHandle as Z, RpcStreamingChannel as _, DevframeRuntime as a, DevToolsAgentHostEvents as at, BufferedChunk as b, defineDevframe as c, EventsMap as ct, DevToolsNodeContext as d, defineCliFlags as dt, AgentResourceContent as et, DevToolsNodeRpcSession as f, parseCliFlags as ft, RpcSharedStateHost as g, RpcSharedStateGetOptions as h, DevframeDeploymentKind as i, DevToolsAgentHost as it, ImmutableMap as j, Immutable as k, ConnectionMeta as l, CliFlagsSchema as lt, RpcFunctionsHost as m, DevframeCliOptions as n, AgentTool as nt, DevframeSetupInfo as o, EventEmitter as ot, RpcBroadcastOptions as p, DevToolsDefineDiagnosticsOptions as q, DevframeDefinition as r, AgentToolInput as rt, DevframeSpaOptions as s, EventUnsubscribe as st, DevframeBrowserContext as t, AgentResourceInput as tt, DevToolsCapabilities as u, InferCliFlags as ut, RpcStreamingChannelOptions as v, StreamReader as w, CreateStreamReaderOptions as x, RpcStreamingHost as y, DevToolsViewHost as z };

package/dist/helpers/vite.d.mts

@@ -1,4 +1,4 @@
-import { r as DevframeDefinition } from "../devframe-xC8Q-xyt.mjs";
+import { r as DevframeDefinition } from "../devframe-K4IxpM4a.mjs";
 
 //#region src/helpers/vite.d.ts
 interface ViteDevBridgeOptions {

package/dist/{index-C5PmWqBf.d.mts → index-BhtRKN7X.d.mts}

@@ -1,4 +1,4 @@
-import { _ as RpcFunctionDefinitionAny, c as RpcDumpClientOptions, l as RpcDumpCollectionOptions, m as RpcDumpStore, n as BirpcReturn, o as RpcDefinitionsToFunctions, p as RpcDumpRecordError } from "./types-BXL7EIDM.mjs";
+import { _ as RpcFunctionDefinitionAny, c as RpcDumpClientOptions, l as RpcDumpCollectionOptions, m as RpcDumpStore, n as BirpcReturn, o as RpcDefinitionsToFunctions, p as RpcDumpRecordError } from "./types-dNW3UmMl.mjs";
 
 //#region src/rpc/dump/static.d.ts
 type StaticRpcDumpSerialization = 'json' | 'structured-clone';

package/dist/{index-CTK6fuXs.d.mts → index-CBSBvT9K.d.mts}

@@ -1,5 +1,5 @@
-import { C as RpcFunctionsCollector, S as RpcFunctionType, _ as RpcFunctionDefinitionAny, g as RpcFunctionDefinition, i as RpcArgsSchema, w as RpcReturnSchema, x as RpcFunctionSetupResult } from "./types-BXL7EIDM.mjs";
-import { a as getDefinitionsWithDumps$1, c as StaticRpcDumpManifest$1, d as StaticRpcDumpManifestValue$1, f as StaticRpcDumpSerialization$1, i as dumpFunctions$1, l as StaticRpcDumpManifestQueryEntry$1, n as serializeDumpError$1, o as StaticRpcDumpCollection$1, p as collectStaticRpcDump$1, r as createClientFromDump$1, s as StaticRpcDumpFile$1, t as reviveDumpError$1, u as StaticRpcDumpManifestStaticEntry$1 } from "./index-C5PmWqBf.mjs";
+import { C as RpcFunctionsCollector, S as RpcFunctionType, _ as RpcFunctionDefinitionAny, g as RpcFunctionDefinition, i as RpcArgsSchema, w as RpcReturnSchema, x as RpcFunctionSetupResult } from "./types-dNW3UmMl.mjs";
+import { a as getDefinitionsWithDumps$1, c as StaticRpcDumpManifest$1, d as StaticRpcDumpManifestValue$1, f as StaticRpcDumpSerialization$1, i as dumpFunctions$1, l as StaticRpcDumpManifestQueryEntry$1, n as serializeDumpError$1, o as StaticRpcDumpCollection$1, p as collectStaticRpcDump$1, r as createClientFromDump$1, s as StaticRpcDumpFile$1, t as reviveDumpError$1, u as StaticRpcDumpManifestStaticEntry$1 } from "./index-BhtRKN7X.mjs";
 
 //#region src/rpc/cache.d.ts
 interface RpcCacheOptions {

package/dist/index.d.mts

@@ -1,6 +1,6 @@
-import { A as DevToolsDiagnosticsDefinition, B as DevToolsAgentHost, C as PartialWithoutId, D as DevToolsRpcSharedStates, E as DevToolsRpcServerFunctions, F as AgentResource, H as EventEmitter, I as AgentResourceContent, L as AgentResourceInput, M as DevToolsDiagnosticsLogger, N as AgentHandle, O as DevToolsHost, P as AgentManifest, R as AgentTool, S as EntriesToObject, T as DevToolsRpcClientFunctions, U as EventUnsubscribe, V as DevToolsAgentHostEvents, W as EventsMap, _ as RpcStreamingChannel, a as DevframeRuntime, c as defineDevframe, d as DevToolsNodeContext, f as DevToolsNodeRpcSession, g as RpcSharedStateHost, h as RpcSharedStateGetOptions, i as DevframeDeploymentKind, j as DevToolsDiagnosticsHost, k as DevToolsDefineDiagnosticsOptions, l as ConnectionMeta, m as RpcFunctionsHost, n as DevframeCliOptions, o as DevframeSetupInfo, p as RpcBroadcastOptions, r as DevframeDefinition, s as DevframeSpaOptions, t as DevframeBrowserContext, u as DevToolsCapabilities, v as RpcStreamingChannelOptions, w as Thenable, x as DevToolsViewHost, y as RpcStreamingHost, z as AgentToolInput } from "./devframe-xC8Q-xyt.mjs";
-import { S as RpcFunctionType, g as RpcFunctionDefinition, h as RpcFunctionAgentOptions, i as RpcArgsSchema, w as RpcReturnSchema } from "./types-BXL7EIDM.mjs";
-import { t as DevToolsNodeRpcSessionMeta } from "./ws-server-DOwLJL23.mjs";
+import { $ as AgentResource, B as EntriesToObject, G as DevToolsRpcSharedStates, H as Thenable, J as DevToolsDiagnosticsDefinition, K as DevToolsHost, Q as AgentManifest, U as DevToolsRpcClientFunctions, V as PartialWithoutId, W as DevToolsRpcServerFunctions, X as DevToolsDiagnosticsLogger, Y as DevToolsDiagnosticsHost, Z as AgentHandle, _ as RpcStreamingChannel, a as DevframeRuntime, at as DevToolsAgentHostEvents, c as defineDevframe, ct as EventsMap, d as DevToolsNodeContext, et as AgentResourceContent, f as DevToolsNodeRpcSession, g as RpcSharedStateHost, h as RpcSharedStateGetOptions, i as DevframeDeploymentKind, it as DevToolsAgentHost, l as ConnectionMeta, m as RpcFunctionsHost, n as DevframeCliOptions, nt as AgentTool, o as DevframeSetupInfo, ot as EventEmitter, p as RpcBroadcastOptions, q as DevToolsDefineDiagnosticsOptions, r as DevframeDefinition, rt as AgentToolInput, s as DevframeSpaOptions, st as EventUnsubscribe, t as DevframeBrowserContext, tt as AgentResourceInput, u as DevToolsCapabilities, v as RpcStreamingChannelOptions, y as RpcStreamingHost, z as DevToolsViewHost } from "./devframe-K4IxpM4a.mjs";
+import { S as RpcFunctionType, g as RpcFunctionDefinition, h as RpcFunctionAgentOptions, i as RpcArgsSchema, w as RpcReturnSchema } from "./types-dNW3UmMl.mjs";
+import { t as DevToolsNodeRpcSessionMeta } from "./ws-server-CTeMCO1r.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>;

package/dist/node/auth.d.mts

@@ -1,5 +1,5 @@
-import { b as SharedState, d as DevToolsNodeContext, f as DevToolsNodeRpcSession } from "../devframe-xC8Q-xyt.mjs";
-import { n as InternalAnonymousAuthStorage } from "../context-Ca70YtrW.mjs";
+import { P as SharedState, d as DevToolsNodeContext, f as DevToolsNodeRpcSession } from "../devframe-K4IxpM4a.mjs";
+import { n as InternalAnonymousAuthStorage } from "../context-C9oW88gr.mjs";
 
 //#region src/node/auth/revoke.d.ts
 /**

package/dist/node/index.d.mts

@@ -1,8 +1,8 @@
-import { B as DevToolsAgentHost$1, E as DevToolsRpcServerFunctions, F as AgentResource, H as EventEmitter, I as AgentResourceContent, L as AgentResourceInput, M as DevToolsDiagnosticsLogger, N as AgentHandle, O as DevToolsHost, P as AgentManifest, R as AgentTool, T as DevToolsRpcClientFunctions, V as DevToolsAgentHostEvents, b as SharedState, d as DevToolsNodeContext, f as DevToolsNodeRpcSession, g as RpcSharedStateHost, j as DevToolsDiagnosticsHost$1, m as RpcFunctionsHost$1, p as RpcBroadcastOptions, x as DevToolsViewHost$1, y as RpcStreamingHost, z as AgentToolInput } from "../devframe-xC8Q-xyt.mjs";
-import { _ as RpcFunctionDefinitionAny } from "../types-BXL7EIDM.mjs";
-import { S as RpcFunctionsCollectorBase } from "../index-CTK6fuXs.mjs";
-import { t as DevToolsNodeRpcSessionMeta } from "../ws-server-DOwLJL23.mjs";
-import { n as StartedServer, r as startHttpAndWs, t as StartHttpAndWsOptions } from "../server-FNcskEBD.mjs";
+import { $ as AgentResource, K as DevToolsHost, P as SharedState, Q as AgentManifest, U as DevToolsRpcClientFunctions, W as DevToolsRpcServerFunctions, X as DevToolsDiagnosticsLogger, Y as DevToolsDiagnosticsHost$1, Z as AgentHandle, at as DevToolsAgentHostEvents, d as DevToolsNodeContext, et as AgentResourceContent, f as DevToolsNodeRpcSession, g as RpcSharedStateHost, it as DevToolsAgentHost$1, m as RpcFunctionsHost$1, nt as AgentTool, ot as EventEmitter, p as RpcBroadcastOptions, rt as AgentToolInput, tt as AgentResourceInput, y as RpcStreamingHost, z as DevToolsViewHost$1 } from "../devframe-K4IxpM4a.mjs";
+import { _ as RpcFunctionDefinitionAny } from "../types-dNW3UmMl.mjs";
+import { S as RpcFunctionsCollectorBase } from "../index-CBSBvT9K.mjs";
+import { t as DevToolsNodeRpcSessionMeta } from "../ws-server-CTeMCO1r.mjs";
+import { n as StartedServer, r as startHttpAndWs, t as StartHttpAndWsOptions } from "../server-KzCqriO9.mjs";
 import { BirpcGroup } from "birpc";
 import { AsyncLocalStorage } from "node:async_hooks";
 

package/dist/node/internal.d.mts

@@ -1,5 +1,5 @@
-import { i as DevframeDeploymentKind, r as DevframeDefinition } from "../devframe-xC8Q-xyt.mjs";
-import { a as internalContextMap, i as getInternalContext, n as InternalAnonymousAuthStorage, r as RemoteTokenRecord, t as DevToolsInternalContext } from "../context-Ca70YtrW.mjs";
+import { i as DevframeDeploymentKind, r as DevframeDefinition } from "../devframe-K4IxpM4a.mjs";
+import { a as internalContextMap, i as getInternalContext, n as InternalAnonymousAuthStorage, r as RemoteTokenRecord, t as DevToolsInternalContext } from "../context-C9oW88gr.mjs";
 
 //#region src/adapters/_shared.d.ts
 /**

package/dist/recipes/open-helpers.d.mts

@@ -1,4 +1,4 @@
-import { T as Thenable, h as RpcFunctionAgentOptions, s as RpcDump, x as RpcFunctionSetupResult } from "../types-BXL7EIDM.mjs";
+import { T as Thenable, h as RpcFunctionAgentOptions, s as RpcDump, x as RpcFunctionSetupResult } from "../types-dNW3UmMl.mjs";
 import * as v from "valibot";
 
 //#region src/recipes/open-helpers.d.ts

package/dist/rpc/dump.d.mts

@@ -1,2 +1,2 @@
-import { a as getDefinitionsWithDumps, c as StaticRpcDumpManifest, d as StaticRpcDumpManifestValue, f as StaticRpcDumpSerialization, i as dumpFunctions, l as StaticRpcDumpManifestQueryEntry, n as serializeDumpError, o as StaticRpcDumpCollection, p as collectStaticRpcDump, r as createClientFromDump, s as StaticRpcDumpFile, t as reviveDumpError, u as StaticRpcDumpManifestStaticEntry } from "../index-C5PmWqBf.mjs";
+import { a as getDefinitionsWithDumps, c as StaticRpcDumpManifest, d as StaticRpcDumpManifestValue, f as StaticRpcDumpSerialization, i as dumpFunctions, l as StaticRpcDumpManifestQueryEntry, n as serializeDumpError, o as StaticRpcDumpCollection, p as collectStaticRpcDump, r as createClientFromDump, s as StaticRpcDumpFile, t as reviveDumpError, u as StaticRpcDumpManifestStaticEntry } from "../index-BhtRKN7X.mjs";
 export { StaticRpcDumpCollection, StaticRpcDumpFile, StaticRpcDumpManifest, StaticRpcDumpManifestQueryEntry, StaticRpcDumpManifestStaticEntry, StaticRpcDumpManifestValue, StaticRpcDumpSerialization, collectStaticRpcDump, createClientFromDump, dumpFunctions, getDefinitionsWithDumps, reviveDumpError, serializeDumpError };

package/dist/rpc/index.d.mts

@@ -1,3 +1,3 @@
-import { C as RpcFunctionsCollector, S as RpcFunctionType, T as Thenable, _ as RpcFunctionDefinitionAny, a as RpcDefinitionsFilter, b as RpcFunctionDefinitionToFunction, c as RpcDumpClientOptions, d as RpcDumpGetter, f as RpcDumpRecord, g as RpcFunctionDefinition, h as RpcFunctionAgentOptions, i as RpcArgsSchema, l as RpcDumpCollectionOptions, m as RpcDumpStore, n as BirpcReturn, o as RpcDefinitionsToFunctions, p as RpcDumpRecordError, r as EntriesToObject, s as RpcDump, t as BirpcFn, u as RpcDumpDefinition, v as RpcFunctionDefinitionAnyWithContext, w as RpcReturnSchema, x as RpcFunctionSetupResult, y as RpcFunctionDefinitionBase } from "../types-BXL7EIDM.mjs";
-import { C as RpcCacheManager, S as RpcFunctionsCollectorBase, _ as strictJsonStringify, a as StaticRpcDumpManifestStaticEntry, b as createDefineWrapperWithContext, c as collectStaticRpcDump, d as getDefinitionsWithDumps, f as reviveDumpError, g as STRUCTURED_CLONE_PREFIX, h as validateDefinitions, i as StaticRpcDumpManifestQueryEntry, l as createClientFromDump, m as validateDefinition, n as StaticRpcDumpFile, o as StaticRpcDumpManifestValue, p as serializeDumpError, r as StaticRpcDumpManifest, s as StaticRpcDumpSerialization, t as StaticRpcDumpCollection, u as dumpFunctions, v as getRpcHandler, w as RpcCacheOptions, x as defineRpcFunction, y as getRpcResolvedSetupResult } from "../index-CTK6fuXs.mjs";
+import { C as RpcFunctionsCollector, S as RpcFunctionType, T as Thenable, _ as RpcFunctionDefinitionAny, a as RpcDefinitionsFilter, b as RpcFunctionDefinitionToFunction, c as RpcDumpClientOptions, d as RpcDumpGetter, f as RpcDumpRecord, g as RpcFunctionDefinition, h as RpcFunctionAgentOptions, i as RpcArgsSchema, l as RpcDumpCollectionOptions, m as RpcDumpStore, n as BirpcReturn, o as RpcDefinitionsToFunctions, p as RpcDumpRecordError, r as EntriesToObject, s as RpcDump, t as BirpcFn, u as RpcDumpDefinition, v as RpcFunctionDefinitionAnyWithContext, w as RpcReturnSchema, x as RpcFunctionSetupResult, y as RpcFunctionDefinitionBase } from "../types-dNW3UmMl.mjs";
+import { C as RpcCacheManager, S as RpcFunctionsCollectorBase, _ as strictJsonStringify, a as StaticRpcDumpManifestStaticEntry, b as createDefineWrapperWithContext, c as collectStaticRpcDump, d as getDefinitionsWithDumps, f as reviveDumpError, g as STRUCTURED_CLONE_PREFIX, h as validateDefinitions, i as StaticRpcDumpManifestQueryEntry, l as createClientFromDump, m as validateDefinition, n as StaticRpcDumpFile, o as StaticRpcDumpManifestValue, p as serializeDumpError, r as StaticRpcDumpManifest, s as StaticRpcDumpSerialization, t as StaticRpcDumpCollection, u as dumpFunctions, v as getRpcHandler, w as RpcCacheOptions, x as defineRpcFunction, y as getRpcResolvedSetupResult } from "../index-CBSBvT9K.mjs";
 export { BirpcFn, BirpcReturn, EntriesToObject, RpcArgsSchema, RpcCacheManager, RpcCacheOptions, RpcDefinitionsFilter, RpcDefinitionsToFunctions, RpcDump, RpcDumpClientOptions, RpcDumpCollectionOptions, RpcDumpDefinition, RpcDumpGetter, RpcDumpRecord, RpcDumpRecordError, RpcDumpStore, RpcFunctionAgentOptions, RpcFunctionDefinition, RpcFunctionDefinitionAny, RpcFunctionDefinitionAnyWithContext, RpcFunctionDefinitionBase, RpcFunctionDefinitionToFunction, RpcFunctionSetupResult, RpcFunctionType, RpcFunctionsCollector, RpcFunctionsCollectorBase, RpcReturnSchema, STRUCTURED_CLONE_PREFIX, StaticRpcDumpCollection, StaticRpcDumpFile, StaticRpcDumpManifest, StaticRpcDumpManifestQueryEntry, StaticRpcDumpManifestStaticEntry, StaticRpcDumpManifestValue, StaticRpcDumpSerialization, Thenable, collectStaticRpcDump, createClientFromDump, createDefineWrapperWithContext, defineRpcFunction, dumpFunctions, getDefinitionsWithDumps, getRpcHandler, getRpcResolvedSetupResult, reviveDumpError, serializeDumpError, strictJsonStringify, validateDefinition, validateDefinitions };

package/dist/rpc/transports/ws-client.d.mts

@@ -1,26 +1,2 @@
-import { _ as RpcFunctionDefinitionAny } from "../../types-BXL7EIDM.mjs";
-import { ChannelOptions } from "birpc";
-
-//#region src/rpc/transports/ws-client.d.ts
-interface WsRpcChannelOptions {
-  url: string;
-  onConnected?: (e: Event) => void;
-  onError?: (e: Error) => void;
-  onDisconnected?: (e: CloseEvent) => void;
-  authToken?: string;
-  /**
-   * RPC function definitions (or just the `jsonSerializable` flag per
-   * method) used to dispatch the per-call wire serializer. Pass an
-   * empty / partial map on clients that don't have the full registry —
-   * encoding falls back to structured-clone (the safer superset) and
-   * decoding still routes correctly via the wire prefix.
-   */
-  definitions?: ReadonlyMap<string, Pick<RpcFunctionDefinitionAny, 'jsonSerializable'>>;
-}
-/**
- * Build a birpc `ChannelOptions` object backed by a browser `WebSocket`.
- * Pass the result straight to `createRpcClient`'s `channel` option.
- */
-declare function createWsRpcChannel(options: WsRpcChannelOptions): ChannelOptions;
-//#endregion
+import { n as createWsRpcChannel, t as WsRpcChannelOptions } from "../../ws-client-BZptK_Mf.mjs";
 export { WsRpcChannelOptions, createWsRpcChannel };

package/dist/rpc/transports/ws-server.d.mts

@@ -1,2 +1,2 @@
-import { n as WsRpcTransportOptions, r as attachWsRpcTransport, t as DevToolsNodeRpcSessionMeta } from "../../ws-server-DOwLJL23.mjs";
+import { n as WsRpcTransportOptions, r as attachWsRpcTransport, t as DevToolsNodeRpcSessionMeta } from "../../ws-server-CTeMCO1r.mjs";
 export { DevToolsNodeRpcSessionMeta, WsRpcTransportOptions, attachWsRpcTransport };

package/dist/{server-FNcskEBD.d.mts → server-KzCqriO9.d.mts}

@@ -1,4 +1,4 @@
-import { E as DevToolsRpcServerFunctions, T as DevToolsRpcClientFunctions, d as DevToolsNodeContext } from "./devframe-xC8Q-xyt.mjs";
+import { U as DevToolsRpcClientFunctions, W as DevToolsRpcServerFunctions, d as DevToolsNodeContext } from "./devframe-K4IxpM4a.mjs";
 import { BirpcGroup } from "birpc";
 import { WebSocketServer } from "ws";
 import { H3 } from "h3";

package/dist/types/index.d.mts

@@ -1,4 +1,4 @@
-import { A as DevToolsDiagnosticsDefinition, B as DevToolsAgentHost, C as PartialWithoutId, D as DevToolsRpcSharedStates, E as DevToolsRpcServerFunctions, F as AgentResource, H as EventEmitter, I as AgentResourceContent, L as AgentResourceInput, M as DevToolsDiagnosticsLogger, N as AgentHandle, O as DevToolsHost, P as AgentManifest, R as AgentTool, S as EntriesToObject, T as DevToolsRpcClientFunctions, U as EventUnsubscribe, V as DevToolsAgentHostEvents, W as EventsMap, _ as RpcStreamingChannel, a as DevframeRuntime, c as defineDevframe, d as DevToolsNodeContext, f as DevToolsNodeRpcSession, g as RpcSharedStateHost, h as RpcSharedStateGetOptions, i as DevframeDeploymentKind, j as DevToolsDiagnosticsHost, k as DevToolsDefineDiagnosticsOptions, l as ConnectionMeta, m as RpcFunctionsHost, n as DevframeCliOptions, o as DevframeSetupInfo, p as RpcBroadcastOptions, r as DevframeDefinition, s as DevframeSpaOptions, t as DevframeBrowserContext, u as DevToolsCapabilities, v as RpcStreamingChannelOptions, w as Thenable, x as DevToolsViewHost, y as RpcStreamingHost, z as AgentToolInput } from "../devframe-xC8Q-xyt.mjs";
-import { h as RpcFunctionAgentOptions } from "../types-BXL7EIDM.mjs";
-import { t as DevToolsNodeRpcSessionMeta } from "../ws-server-DOwLJL23.mjs";
+import { $ as AgentResource, B as EntriesToObject, G as DevToolsRpcSharedStates, H as Thenable, J as DevToolsDiagnosticsDefinition, K as DevToolsHost, Q as AgentManifest, U as DevToolsRpcClientFunctions, V as PartialWithoutId, W as DevToolsRpcServerFunctions, X as DevToolsDiagnosticsLogger, Y as DevToolsDiagnosticsHost, Z as AgentHandle, _ as RpcStreamingChannel, a as DevframeRuntime, at as DevToolsAgentHostEvents, c as defineDevframe, ct as EventsMap, d as DevToolsNodeContext, et as AgentResourceContent, f as DevToolsNodeRpcSession, g as RpcSharedStateHost, h as RpcSharedStateGetOptions, i as DevframeDeploymentKind, it as DevToolsAgentHost, l as ConnectionMeta, m as RpcFunctionsHost, n as DevframeCliOptions, nt as AgentTool, o as DevframeSetupInfo, ot as EventEmitter, p as RpcBroadcastOptions, q as DevToolsDefineDiagnosticsOptions, r as DevframeDefinition, rt as AgentToolInput, s as DevframeSpaOptions, st as EventUnsubscribe, t as DevframeBrowserContext, tt as AgentResourceInput, u as DevToolsCapabilities, v as RpcStreamingChannelOptions, y as RpcStreamingHost, z as DevToolsViewHost } from "../devframe-K4IxpM4a.mjs";
+import { h as RpcFunctionAgentOptions } from "../types-dNW3UmMl.mjs";
+import { t as DevToolsNodeRpcSessionMeta } from "../ws-server-CTeMCO1r.mjs";
 export { AgentHandle, AgentManifest, AgentResource, AgentResourceContent, AgentResourceInput, AgentTool, AgentToolInput, ConnectionMeta, DevToolsAgentHost, DevToolsAgentHostEvents, DevToolsCapabilities, DevToolsDefineDiagnosticsOptions, 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 };

package/dist/{types-BXL7EIDM.d.mts → types-dNW3UmMl.d.mts}

@@ -1,5 +1,5 @@
-import { BirpcFn, BirpcReturn as BirpcReturn$1 } from "birpc";
 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 */

package/dist/utils/events.d.mts

@@ -1,4 +1,4 @@
-import { T as EventsMap, w as EventEmitter } from "../index-DTeZXHSi.mjs";
+import { ct as EventsMap, ot as EventEmitter } from "../devframe-K4IxpM4a.mjs";
 
 //#region src/utils/events.d.ts
 /**

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

@@ -1,2 +1,2 @@
-import { C as createSharedState, S as SharedStatePatch, _ as ImmutableObject, b as SharedStateEvents, g as ImmutableMap, h as ImmutableArray, m as Immutable, v as ImmutableSet, x as SharedStateOptions, y as SharedState } from "../index-DTeZXHSi.mjs";
+import { A as ImmutableArray, F as SharedStateEvents, I as SharedStateOptions, L as SharedStatePatch, M as ImmutableObject, N as ImmutableSet, P as SharedState, R as createSharedState, j as ImmutableMap, k as Immutable } from "../devframe-K4IxpM4a.mjs";
 export { Immutable, ImmutableArray, ImmutableMap, ImmutableObject, ImmutableSet, SharedState, SharedStateEvents, SharedStateOptions, SharedStatePatch, createSharedState };

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

@@ -1,2 +1,2 @@
-import { a as BufferedChunk, c as StreamErrorPayload, d as StreamSinkEvents, f as createStreamReader, l as StreamReader, o as CreateStreamReaderOptions, p as createStreamSink, s as CreateStreamSinkOptions, u as StreamSink } from "../index-DTeZXHSi.mjs";
+import { C as StreamErrorPayload, D as createStreamReader, E as StreamSinkEvents, O as createStreamSink, S as CreateStreamSinkOptions, T as StreamSink, b as BufferedChunk, w as StreamReader, x as CreateStreamReaderOptions } from "../devframe-K4IxpM4a.mjs";
 export { BufferedChunk, CreateStreamReaderOptions, CreateStreamSinkOptions, StreamErrorPayload, StreamReader, StreamSink, StreamSinkEvents, createStreamReader, createStreamSink };

package/dist/ws-client-BZptK_Mf.d.mts

@@ -0,0 +1,26 @@
+import { _ as RpcFunctionDefinitionAny } from "./types-dNW3UmMl.mjs";
+import { ChannelOptions } from "birpc";
+
+//#region src/rpc/transports/ws-client.d.ts
+interface WsRpcChannelOptions {
+  url: string;
+  onConnected?: (e: Event) => void;
+  onError?: (e: Error) => void;
+  onDisconnected?: (e: CloseEvent) => void;
+  authToken?: string;
+  /**
+   * RPC function definitions (or just the `jsonSerializable` flag per
+   * method) used to dispatch the per-call wire serializer. Pass an
+   * empty / partial map on clients that don't have the full registry —
+   * encoding falls back to structured-clone (the safer superset) and
+   * decoding still routes correctly via the wire prefix.
+   */
+  definitions?: ReadonlyMap<string, Pick<RpcFunctionDefinitionAny, 'jsonSerializable'>>;
+}
+/**
+ * Build a birpc `ChannelOptions` object backed by a browser `WebSocket`.
+ * Pass the result straight to `createRpcClient`'s `channel` option.
+ */
+declare function createWsRpcChannel(options: WsRpcChannelOptions): ChannelOptions;
+//#endregion
+export { createWsRpcChannel as n, WsRpcChannelOptions as t };

package/dist/{ws-server-DOwLJL23.d.mts → ws-server-CTeMCO1r.d.mts}

@@ -1,8 +1,8 @@
-import { _ as RpcFunctionDefinitionAny } from "./types-BXL7EIDM.mjs";
+import { _ as RpcFunctionDefinitionAny } from "./types-dNW3UmMl.mjs";
 import { BirpcGroup, ChannelOptions } from "birpc";
+import { IncomingMessage } from "node:http";
 import { ServerOptions } from "node:https";
 import { WebSocket, WebSocketServer } from "ws";
-import { IncomingMessage } from "node:http";
 
 //#region src/rpc/transports/ws-server.d.ts
 interface DevToolsNodeRpcSessionMeta {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "devframe",
   "type": "module",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "Framework for building generic DevTools",
   "author": "Anthony Fu <anthonyfu117@hotmail.com>",
   "license": "MIT",
@@ -90,6 +90,7 @@
     "p-limit": "^7.3.0",
     "perfect-debounce": "^2.1.0",
     "structured-clone-es": "^2.0.0",
+    "tinyglobby": "^0.2.16",
     "tsdown": "^0.22.0",
     "ua-parser-modern": "^0.1.1",
     "whenexpr": "^0.1.2"

package/dist/index-DTeZXHSi.d.mts

@@ -1,639 +0,0 @@
-import { defineDiagnostics } from "nostics";
-import { BirpcReturn } from "birpc";
-import { GenericSchema, InferInput } from "valibot";
-//#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 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;
-/**
- * Serialized representation of a thrown value in a dump record.
- *
- * Errors are stored as plain objects so they round-trip through both the
- * strict-JSON and structured-clone codecs. `message` and `name` are always
- * present; `cause` and any own enumerable properties of the original
- * `Error` are preserved on a best-effort basis. Non-`Error` throws are
- * normalized to `{ name: 'Error', message: String(thrown) }`.
- */
-interface RpcDumpRecordError {
-  /** Error message (mirrors `Error.message`). */
-  message: string;
-  /** Error type name (e.g., "Error", "TypeError"). */
-  name: string;
-  /** `Error.cause`, recursively serialized when it is itself an `Error`. */
-  cause?: unknown;
-  /** Own enumerable properties of the original error (excluding `message`/`name`/`cause`). */
-  [key: string]: unknown;
-}
-/**
- * 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?: RpcDumpRecordError;
-}
-/**
- * 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>;
-/**
- * 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 RpcFunctionDefinitionAny = RpcFunctionDefinition<string, any, any, any, any, any, any>;
-type RpcFunctionDefinitionAnyWithContext<CONTEXT = undefined> = RpcFunctionDefinition<string, any, any, any, any, any, CONTEXT>;
-//#endregion
-//#region src/rpc/cache.d.ts
-interface RpcCacheOptions {
-  functions: string[];
-  keySerializer?: (args: unknown[]) => string;
-}
-/**
- * @experimental API is expected to change.
- */
-declare class RpcCacheManager {
-  private cacheMap;
-  private options;
-  private keySerializer;
-  constructor(options: RpcCacheOptions);
-  updateOptions(options: Partial<RpcCacheOptions>): void;
-  cached<T>(m: string, a: unknown[]): T | undefined;
-  apply(req: {
-    m: string;
-    a: unknown[];
-  }, res: unknown): void;
-  validate(m: string): boolean;
-  clear(fn?: string): void;
-}
-//#endregion
-//#region src/types/events.d.ts
-interface EventsMap {
-  [event: string]: any;
-}
-interface EventUnsubscribe {
-  (): void;
-}
-interface EventEmitter<Events extends EventsMap> {
-  /**
-   * Calls each of the listeners registered for a given event.
-   *
-   * ```js
-   * ee.emit('tick', tickType, tickDuration)
-   * ```
-   *
-   * @param event The event name.
-   * @param args The arguments for listeners.
-   */
-  emit: <K extends keyof Events>(event: K, ...args: Parameters<Events[K]>) => void;
-  /**
-   * Calls the listeners for a given event once and then removes the listener.
-   *
-   * @param event The event name.
-   * @param args The arguments for listeners.
-   */
-  emitOnce: <K extends keyof Events>(event: K, ...args: Parameters<Events[K]>) => void;
-  /**
-   * Event names in keys and arrays with listeners in values.
-   *
-   * @internal
-   */
-  _listeners: Partial<{ [E in keyof Events]: Events[E][] }>;
-  /**
-   * Add a listener for a given event.
-   *
-   * ```js
-   * const unbind = ee.on('tick', (tickType, tickDuration) => {
-   *   count += 1
-   * })
-   *
-   * disable () {
-   *   unbind()
-   * }
-   * ```
-   *
-   * @param event The event name.
-   * @param cb The listener function.
-   * @returns Unbind listener from event.
-   */
-  on: <K extends keyof Events>(event: K, cb: Events[K]) => EventUnsubscribe;
-  /**
-   * Add a listener for a given event once.
-   *
-   * ```js
-   * const unbind = ee.once('tick', (tickType, tickDuration) => {
-   *   count += 1
-   * })
-   *
-   * disable () {
-   *   unbind()
-   * }
-   * ```
-   *
-   * @param event The event name.
-   * @param cb The listener function.
-   * @returns Unbind listener from event.
-   */
-  once: <K extends keyof Events>(event: K, cb: Events[K]) => EventUnsubscribe;
-}
-//#endregion
-//#region src/utils/shared-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]> };
-/**
- * Serializable patch describing a single mutation to a `SharedState`.
- * Structurally compatible with JSON-Patch and is safe to send over RPC.
- */
-interface SharedStatePatch {
-  op: 'add' | 'remove' | 'replace';
-  path: readonly (string | number)[];
-  value?: unknown;
-}
-/**
- * State host that is immutable by default with explicit mutate.
- */
-interface SharedState<T> {
-  /**
-   * Get the current state. Immutable.
-   */
-  value: () => Immutable<T>;
-  /**
-   * Subscribe to state changes.
-   */
-  on: EventEmitter<SharedStateEvents<T>>['on'];
-  /**
-   * Mutate the state.
-   */
-  mutate: (fn: (state: T) => void, syncId?: string) => void;
-  /**
-   * Apply patches to the state.
-   */
-  patch: (patches: SharedStatePatch[], syncId?: string) => void;
-  /**
-   * Sync IDs that have been applied to the state.
-   */
-  syncIds: Set<string>;
-}
-interface SharedStateEvents<T> {
-  updated: (fullState: T, patches: SharedStatePatch[] | undefined, syncId: string) => void;
-}
-interface SharedStateOptions<T> {
-  /**
-   * Initial state.
-   */
-  initialValue: T;
-  /**
-   * Enable patches.
-   *
-   * @default false
-   */
-  enablePatches?: boolean;
-}
-declare function createSharedState<T extends object>(options: SharedStateOptions<T>): SharedState<T>;
-//#endregion
-//#region src/utils/streaming-channel.d.ts
-/**
- * Serialized error shape sent over the wire when a stream ends with a failure.
- * Stays JSON-safe so the strict-JSON encoder can carry it without coercion.
- */
-interface StreamErrorPayload {
-  name: string;
-  message: string;
-}
-/**
- * Single buffered chunk in the server-side ring buffer.
- *
- * Sequence numbers start at 1 and increment per write. Subscribers track
- * `lastSeenSeq` and ask for `afterSeq` on resubscribe so the server can
- * replay any chunks the client missed during a brief disconnect.
- */
-interface BufferedChunk<T> {
-  seq: number;
-  chunk: T;
-}
-interface StreamSinkEvents<T> {
-  /** Fired for each `write()`. The RPC layer subscribes and broadcasts. */
-  chunk: (seq: number, chunk: T) => void;
-  /** Terminal — fired exactly once per sink lifetime. */
-  end: (error?: StreamErrorPayload) => void;
-}
-interface CreateStreamSinkOptions {
-  id?: string;
-  /**
-   * Size of the per-stream ring buffer kept for replay-on-resubscribe.
-   * `0` (default) disables replay.
-   */
-  replayWindow?: number;
-}
-/**
- * Server-side producer handle. Two equivalent surfaces share one piece of
- * state: the imperative `write/error/close` triple, and a `WritableStream<T>`
- * for `pipeTo`-style consumption.
- */
-interface StreamSink<T> {
-  /** Stable id used by clients to subscribe. */
-  readonly id: string;
-  /**
-   * Aborts when the consumer cancels (server-side) or when the transport
-   * loses every subscriber. Producers should poll `signal.aborted` and exit
-   * cleanly.
-   */
-  readonly signal: AbortSignal;
-  /** `true` after `close()` / `error()`. Further writes throw. */
-  readonly closed: boolean;
-  /** Last allocated sequence number. `0` until the first write. */
-  readonly lastSeq: number;
-  write: (chunk: T) => void;
-  error: (reason: unknown) => void;
-  close: () => void;
-  /** External-cancel path. Aborts the signal so handlers can short-circuit. */
-  abort: (reason?: unknown) => void;
-  /** `WritableStream<T>` adapter — same in-memory state as the imperative API. */
-  readonly writable: WritableStream<T>;
-  /**
-   * Internal — RPC layer subscribes to receive chunk/end notifications.
-   * Not part of the public contract; do not call directly.
-   *
-   * @internal
-   */
-  readonly events: EventEmitter<StreamSinkEvents<T>>;
-  /**
-   * Internal — replay buffer. RPC layer reads on (re)subscribe to feed
-   * missed chunks before going live.
-   *
-   * @internal
-   */
-  readonly buffer: ReadonlyArray<BufferedChunk<T>>;
-}
-interface CreateStreamReaderOptions {
-  id?: string;
-  /**
-   * Maximum number of buffered chunks held client-side while the consumer
-   * isn't draining. On overflow, the oldest chunk is dropped.
-   */
-  highWaterMark?: number;
-  /**
-   * Called when the chunk queue overflows the high-water mark. The RPC
-   * layer wires this to a coded warning; the primitive itself is
-   * RPC-agnostic.
-   */
-  onOverflow?: (dropped: number) => void;
-  /** Called when the consumer cancels — the RPC layer sends `:cancel` upstream. */
-  onCancel?: () => void;
-}
-/**
- * Client-side consumer handle. Both an `AsyncIterable<T>` (for `for await`)
- * and exposes `readable: ReadableStream<T>` (for `pipeTo`). Pick one — they
- * share a single internal queue, so concurrent draining will race.
- */
-interface StreamReader<T> extends AsyncIterable<T> {
-  readonly id: string;
-  readonly cancelled: boolean;
-  readonly done: boolean;
-  /** Highest `seq` observed. Used for replay on reconnect. */
-  readonly lastSeenSeq: number;
-  /** `ReadableStream<T>` adapter for `pipeTo`-style consumption. */
-  readonly readable: ReadableStream<T>;
-  cancel: () => void;
-  /** @internal */
-  _push: (seq: number, chunk: T) => void;
-  /** @internal */
-  _end: (error?: StreamErrorPayload) => void;
-}
-/**
- * Build a server-side stream sink. RPC-agnostic — the RPC host wires
- * `events.on('chunk' | 'end')` to broadcast, and reads `buffer` to replay
- * for late or reconnecting subscribers.
- */
-declare function createStreamSink<T>(options?: CreateStreamSinkOptions): StreamSink<T>;
-/**
- * Build a client-side stream reader. RPC-agnostic — the RPC host calls
- * `_push(seq, chunk)` on each incoming chunk and `_end(error?)` on the
- * terminal frame. Consumers iterate with `for await` or pipe `readable`.
- */
-declare function createStreamReader<T>(options?: CreateStreamReaderOptions): StreamReader<T>;
-//#endregion
-//#region src/types/rpc-augments.d.ts
-/**
- * To be extended
- */
-interface DevToolsRpcClientFunctions {
-  /**
-   * Streaming chunk pushed from server to subscribed clients. Wired by
-   * `RpcStreamingHost`; do not register manually.
-   *
-   * @internal
-   */
-  'devframe:streaming:chunk': (channel: string, id: string, seq: number, chunk: any) => Promise<void>;
-  /**
-   * Streaming terminator pushed from server to subscribed clients. Wired by
-   * `RpcStreamingHost`; do not register manually.
-   *
-   * @internal
-   */
-  'devframe:streaming:end': (channel: string, id: string, error?: {
-    name: string;
-    message: string;
-  }) => Promise<void>;
-  /**
-   * Server→client cancel for an in-flight upload. Wired by
-   * `RpcStreamingHost`; do not register manually.
-   *
-   * @internal
-   */
-  'devframe:streaming:upload-cancel': (channel: string, id: string) => Promise<void>;
-}
-/**
- * To be extended
- */
-interface DevToolsRpcServerFunctions {
-  /**
-   * Subscribe a client to a shared-state key. Wired by
-   * `RpcSharedStateHost`; do not register manually.
-   *
-   * @internal
-   */
-  'devframe:rpc:server-state:subscribe': (key: string) => Promise<void>;
-  /**
-   * Read the current value for a shared-state key. Wired by
-   * `RpcSharedStateHost`; do not register manually.
-   *
-   * @internal
-   */
-  'devframe:rpc:server-state:get': (key: string) => Promise<any>;
-  /**
-   * Replace a shared-state value (from the client). Wired by
-   * `RpcSharedStateHost`; do not register manually.
-   *
-   * @internal
-   */
-  'devframe:rpc:server-state:set': (key: string, value: any, syncId: string) => Promise<void>;
-  /**
-   * Apply a patch to a shared-state value (from the client). Wired by
-   * `RpcSharedStateHost`; do not register manually.
-   *
-   * @internal
-   */
-  'devframe:rpc:server-state:patch': (key: string, patches: any[], syncId: string) => Promise<void>;
-  /**
-   * Client→server streaming subscription with optional replay cursor.
-   * Wired by `RpcStreamingHost`; do not register manually.
-   *
-   * @internal
-   */
-  'devframe:streaming:subscribe': (channel: string, id: string, opts?: {
-    afterSeq?: number;
-  }) => Promise<void>;
-  /**
-   * Client→server streaming unsubscribe. Wired by `RpcStreamingHost`;
-   * do not register manually.
-   *
-   * @internal
-   */
-  'devframe:streaming:unsubscribe': (channel: string, id: string) => Promise<void>;
-  /**
-   * Client→server streaming cancellation request. Wired by
-   * `RpcStreamingHost`; do not register manually.
-   *
-   * @internal
-   */
-  'devframe:streaming:cancel': (channel: string, id: string) => Promise<void>;
-  /**
-   * Client→server upload chunk. Wired by `RpcStreamingHost`; do not
-   * register manually.
-   *
-   * @internal
-   */
-  'devframe:streaming:upload-chunk': (channel: string, id: string, seq: number, chunk: any) => Promise<void>;
-  /**
-   * Client→server upload terminator. Wired by `RpcStreamingHost`; do not
-   * register manually.
-   *
-   * @internal
-   */
-  'devframe:streaming:upload-end': (channel: string, id: string, error?: {
-    name: string;
-    message: string;
-  }) => Promise<void>;
-}
-/**
- * To be extended
- */
-interface DevToolsRpcSharedStates {}
-//#endregion
-//#region src/types/rpc.d.ts
-interface RpcSharedStateGetOptions<T> {
-  sharedState?: SharedState<T>;
-  initialValue?: T;
-}
-interface RpcSharedStateHost {
-  get: <T extends keyof DevToolsRpcSharedStates>(key: T, options?: RpcSharedStateGetOptions<DevToolsRpcSharedStates[T]>) => Promise<SharedState<DevToolsRpcSharedStates[T]>>;
-  keys: () => string[];
-  /**
-   * Subscribe to new shared-state keys becoming available. Fires when
-   * `get(key, ...)` creates a fresh entry (not on subsequent gets).
-   * Useful for protocol adapters (e.g. MCP) that surface shared state
-   * as dynamic resources.
-   */
-  onKeyAdded: (fn: (key: string) => void) => () => void;
-}
-//#endregion
-//#region src/types/context.d.ts
-interface ConnectionMeta {
-  backend: 'websocket' | 'static';
-  websocket?: number | string;
-  /**
-   * Names of RPC functions that have declared `jsonSerializable: true`.
-   * Used by the WS / static client to dispatch the per-call wire
-   * serializer (strict JSON for these methods, structured-clone for
-   * the rest). Populated by the server / build adapter; absent on
-   * legacy clients, in which case all outgoing messages fall back to
-   * structured-clone.
-   */
-  jsonSerializableMethods?: string[];
-}
-//#endregion
-export { createSharedState as C, RpcCacheOptions as D, RpcCacheManager as E, RpcFunctionDefinitionAny as O, SharedStatePatch as S, EventsMap as T, ImmutableObject as _, BufferedChunk as a, SharedStateEvents as b, StreamErrorPayload as c, StreamSinkEvents as d, createStreamReader as f, ImmutableMap as g, ImmutableArray as h, DevToolsRpcServerFunctions as i, RpcFunctionsCollector as k, StreamReader as l, Immutable as m, RpcSharedStateHost as n, CreateStreamReaderOptions as o, createStreamSink as p, DevToolsRpcClientFunctions as r, CreateStreamSinkOptions as s, ConnectionMeta as t, StreamSink as u, ImmutableSet as v, EventEmitter as w, SharedStateOptions as x, SharedState as y };