devframe 0.8.1 → 0.9.0-beta.1

package/dist/node/index.d.mts

@@ -1,38 +1,7 @@
-import { At as DevframeAgentHostEvents, C as DevframeServicesHost, Ct as AgentResourceContent, Dt as AgentToolProvider, Et as AgentToolInput, H as DevframeDiagnosticsHost$1, J as RpcSharedStateHost, K as RpcFunctionsHost, L as DevframeViewHost$1, O as DevframeSettings, Ot as AgentToolProviderHandle, R as DevframeHost, S as DevframeServiceOf, St as AgentResource, T as DevframeScopedNodeContext, Tt as AgentTool, U as DevframeDiagnosticsLogger, Z as RpcStreamingHost, b as DevframeNodeContext, bt as AgentHandle, ht as SharedState, jt as EventEmitter, kt as DevframeAgentHost$1, wt as AgentResourceInput, x as DevframeServiceId, xt as AgentManifest } from "../devframe-qgCKL683.mjs";
+import { gt as SharedState, q as RpcFunctionsHost, x as DevframeNodeContext, z as DevframeHost } from "../devframe-Bdd9YXTy.mjs";
+import "../index-DSCq4M4q.mjs";
 import { v as RpcFunctionDefinitionAny } from "../types-CnJSgRVa.mjs";
-import "../index-Dbw1p5ch.mjs";
-import { n as StartedServer, r as startHttpAndWs, t as StartHttpAndWsOptions } from "../server-E9z4ZWbd.mjs";
 import { BirpcGroup } from "birpc";
-//#region src/node/agent-args.d.ts
-/**
- * How {@link coerceAgentPositionalArgs} treats an args object that carries
- * neither declared schemas nor `arg0`/`arg1`/… keys:
- *
- * - `'wrap'` — pass the object itself as the single positional argument.
- *   RPC-backed tools use this: an untyped RPC may take one raw object.
- * - `'drop'` — call with zero arguments. Command-backed tools use this:
- *   a handler's positional parameters come solely from its declared
- *   `agent.args` schemas, so undeclared payload is ignored.
- */
-type AgentArgsFallback = 'wrap' | 'drop';
-/**
- * Map the args payload an agent surface receives (MCP sends an object
- * keyed `arg0`/`arg1`/…, matching the schema the adapter advertises) onto
- * a handler's positional parameters. Shared by the agent host's RPC
- * bridge and the hub's command-derived tools so the coercion cannot
- * drift between them.
- *
- * - an array passes through as-is
- * - `null`/`undefined` become a zero-argument call
- * - with declared schemas, each schema reads its own `argN` key, in order
- * - without schemas, `arg0`/`arg1`/… keys are collected when present
- * - an empty object becomes a zero-argument call
- * - anything else follows the {@link AgentArgsFallback}
- *
- * @experimental
- */
-declare function coerceAgentPositionalArgs(args: unknown, schemas: readonly unknown[] | undefined, fallback?: AgentArgsFallback): unknown[];
-//#endregion
 //#region src/node/context.d.ts
 interface CreateHostContextOptions {
   cwd: string;
@@ -56,231 +25,6 @@ interface CreateHostContextOptions {
  */
 declare function createHostContext(options: CreateHostContextOptions): Promise<DevframeNodeContext>;
 //#endregion
-//#region src/node/host-agent.d.ts
-/**
- * Framework-neutral host aggregating the agent-exposed surface of a
- * devframe. Auto-discovers RPC functions with an `agent` field from
- * `ctx.rpc.definitions`, and accepts plugin-registered tools /
- * resources via `registerTool` / `registerResource`.
- *
- * @experimental
- */
-declare class DevframeAgentHost implements DevframeAgentHost$1 {
-  readonly context: DevframeNodeContext;
-  readonly events: EventEmitter<DevframeAgentHostEvents>;
-  private readonly tools;
-  private readonly resources;
-  private readonly providers;
-  private _rpcUnsubscribe;
-  constructor(context: DevframeNodeContext);
-  registerTool(input: AgentToolInput): AgentHandle;
-  unregisterTool(id: string): boolean;
-  registerToolProvider(provider: AgentToolProvider): AgentToolProviderHandle;
-  registerResource(input: AgentResourceInput): AgentHandle;
-  unregisterResource(id: string): boolean;
-  list(): AgentManifest;
-  getTool(id: string): AgentTool | undefined;
-  getResource(id: string): AgentResource | undefined;
-  invoke(id: string, args: unknown): Promise<unknown>;
-  read(id: string): Promise<AgentResourceContent>;
-  /** @internal */
-  _dispose(): void;
-  private _validateToolId;
-  private _projectTool;
-  /** Query every registered provider, projecting inputs to serializable tools. */
-  private _collectProviderTools;
-  private _collectRpcTools;
-  private _findRpcDefinition;
-}
-//#endregion
-//#region src/node/host-diagnostics.d.ts
-declare class DevframeDiagnosticsHost implements DevframeDiagnosticsHost$1 {
-  readonly context: DevframeNodeContext;
-  private _registry;
-  readonly logger: DevframeDiagnosticsLogger;
-  readonly defineDiagnostics: DevframeDiagnosticsHost$1['defineDiagnostics'];
-  constructor(context: DevframeNodeContext, initialDefinitions?: Array<Record<string, unknown>>);
-  register(diagnostics: Record<string, unknown>): void;
-}
-//#endregion
-//#region src/node/host-h3.d.ts
-interface CreateH3DevframeHostOptions {
-  /** The h3 app instance — registered once the CLI adapter lands. */
-  app?: unknown;
-  /**
-   * Host the standalone server listens on, e.g. `http://localhost:9999`.
-   * Consumed by `resolveOrigin` for dock entries that need an absolute URL.
-   */
-  origin: string;
-  /**
-   * Register a static-file handler at `base` serving files from `distDir`.
-   * Wired into the h3 app once the CLI adapter lands (commit 5). For now
-   * the CLI isn't running, so the default is a no-op.
-   */
-  mount?: (base: string, distDir: string) => void | Promise<void>;
-  /**
-   * Namespace for storage paths returned by `getStorageDir`. Workspace
-   * state (committable) lives under `${workspaceRoot}/.devframe/`, project
-   * state under `${workspaceRoot}/node_modules/.<appName>/devframe/`, and
-   * global state under `${homedir()}/.<appName>/devframe/`. Pick the
-   * devtool's id (or another stable, filesystem-safe identifier) so the
-   * standalone host doesn't collide with other tools' storage.
-   */
-  appName: string;
-  /**
-   * Workspace root used as the parent of the per-project storage
-   * directory. Defaults to `process.cwd()`.
-   */
-  workspaceRoot?: string;
-}
-/**
- * h3-backed {@link DevframeHost} — used by the standalone CLI adapter.
- */
-declare function createH3DevframeHost(options: CreateH3DevframeHostOptions): DevframeHost;
-//#endregion
-//#region src/node/host-services.d.ts
-/**
- * Cross-plugin service registry (see `types/services.ts` for the contract).
- * Values are held per context instance; `whenAvailable` subscriptions make
- * the mechanism robust against setup ordering between provider and consumer.
- */
-declare class DevframeServicesHostImpl implements DevframeServicesHost {
-  private services;
-  private listeners;
-  provide<ID extends DevframeServiceId>(id: ID, service: DevframeServiceOf<ID>): () => void;
-  get<ID extends DevframeServiceId>(id: ID): DevframeServiceOf<ID> | undefined;
-  has(id: DevframeServiceId): boolean;
-  whenAvailable<ID extends DevframeServiceId>(id: ID, callback: (service: DevframeServiceOf<ID>) => void): () => void;
-  keys(): string[];
-}
-//#endregion
-//#region src/node/host-views.d.ts
-declare class DevframeViewHost implements DevframeViewHost$1 {
-  readonly context: DevframeNodeContext;
-  /**
-   * @internal
-   */
-  buildStaticDirs: {
-    baseUrl: string;
-    distDir: string;
-  }[];
-  constructor(context: DevframeNodeContext);
-  hostStatic(baseUrl: string, distDir: string): void;
-}
-//#endregion
-//#region src/node/instance-registry.d.ts
-/**
- * One running devframe instance, as recorded in the instance registry.
- * Records are self-describing JSON — additive fields are safe.
- *
- * @experimental The agent-native surface is experimental and may change
- * without a major version bump until it stabilizes.
- */
-interface DevframeInstanceRecord {
-  /** Process id of the dev server. */
-  pid: number;
-  /** Listening port. */
-  port: number;
-  /** Dialable HTTP origin, e.g. `http://127.0.0.1:9876`. */
-  origin: string;
-  /** Base path the devframe is mounted at (trailing slash). */
-  basePath: string;
-  /** Definition id. */
-  id: string;
-  /** Definition display name. */
-  name?: string;
-  /** Working directory the instance was started from. */
-  rootDir: string;
-  /**
-   * Absolute URL path of the MCP Streamable-HTTP endpoint on `origin`, or
-   * `null` when the instance runs without an MCP route.
-   */
-  mcp: {
-    path: string;
-  } | null;
-  /** Epoch-ms timestamp of registration. */
-  startedAt: number;
-}
-/**
- * Handle returned by {@link registerDevframeInstance}.
- *
- * @experimental
- */
-interface DevframeInstanceRegistration {
-  /** The registry file backing this registration. */
-  readonly file: string;
-  /** Remove the record (idempotent). Call on server close. */
-  unregister: () => void;
-}
-/**
- * Record a running devframe instance in the global instance registry so
- * discovery tooling (`devframe connect`, editor integrations) can find it
- * without port guessing.
- *
- * `createDevServer` registers automatically; custom hosts that serve a
- * devframe in-process (e.g. `@devframes/next`'s host inside a Next dev
- * server) call this explicitly with the origin they are reachable at.
- *
- * The record is written atomically to `<dir>/<pid>-<port>.json` and removed
- * by {@link DevframeInstanceRegistration.unregister}. Records surviving a
- * crash are pruned by readers whose liveness probe fails. Registration never
- * throws — a write failure degrades to a coded warning (`DF0045`), since a
- * dev server must not die over discovery metadata.
- *
- * @experimental
- */
-declare function registerDevframeInstance(record: DevframeInstanceRecord, options?: {
-  instancesDir?: string;
-}): DevframeInstanceRegistration;
-/**
- * Read the registry and split records into live and dead by probing each
- * one's `__connection.json`, deleting dead records (prune-on-read). Live
- * records carry the dialable origin the probe confirmed (a `localhost`
- * record may come back as `127.0.0.1` / `[::1]`).
- *
- * A liveness probe only proves *something* answers on the record's port, so
- * records left behind by killed processes shadow the server currently bound
- * there: per `(port, basePath)` only the newest record survives, older
- * ghosts are pruned with the dead.
- *
- * @experimental
- */
-declare function listLiveDevframeInstances(options?: {
-  instancesDir?: string;
-  timeoutMs?: number;
-}): Promise<{
-  live: DevframeInstanceRecord[];
-  pruned: DevframeInstanceRecord[];
-}>;
-//#endregion
-//#region src/node/rpc-shared-state.d.ts
-declare function createRpcSharedStateServerHost(rpc: RpcFunctionsHost): RpcSharedStateHost;
-//#endregion
-//#region src/node/rpc-streaming.d.ts
-/**
- * Build the server-side streaming host. Mirrors the layout of
- * `createRpcSharedStateServerHost` — registers a fixed set of internal
- * RPC methods (`subscribe` / `unsubscribe` / `cancel`) once, then per-channel
- * state lives in a `Map<channelName, ChannelState>`.
- */
-declare function createRpcStreamingServerHost(rpc: RpcFunctionsHost): RpcStreamingHost;
-//#endregion
-//#region src/node/scope.d.ts
-/**
- * Build a namespace-scoped view of a {@link DevframeNodeContext}. Every
- * RPC id, shared-state key, and streaming channel passed through the
- * returned `rpc` surface is auto-namespaced with `<namespace>:`.
- */
-declare function createScopedNodeContext<NS extends string = string>(context: DevframeNodeContext, namespace: NS): DevframeScopedNodeContext<NS>;
-//#endregion
-//#region src/node/settings.d.ts
-/**
- * Build the node-side `settings` surface for a scope namespace. `project`
- * persists under the host's `workspace` storage dir, `global` under its
- * `global` dir. Each is a file-backed, client-synced key-value store.
- */
-declare function createNodeSettings<T extends Record<string, any> = Record<string, any>>(context: DevframeNodeContext, namespace: string): DevframeSettings<T>;
-//#endregion
 //#region src/node/storage.d.ts
 interface CreateStorageOptions<T extends object> {
   filepath: string;
@@ -290,12 +34,4 @@ interface CreateStorageOptions<T extends object> {
 }
 declare function createStorage<T extends object>(options: CreateStorageOptions<T>): SharedState<T>;
 //#endregion
-//#region src/node/utils.d.ts
-declare function isObject(value: unknown): value is Record<string, any>;
-/** Map a bind host to a host a client can actually connect to. */
-declare function toDialableHost(host: string): string;
-/** Format a bind host for use in a URL authority (dialable, IPv6-bracketed). */
-declare function formatHostForUrl(host: string): string;
-declare function normalizeHttpServerUrl(host: string, port: number | string): string;
-//#endregion
-export { AgentArgsFallback, CreateH3DevframeHostOptions, CreateHostContextOptions, CreateStorageOptions, DevframeAgentHost, DevframeDiagnosticsHost, type DevframeInstanceRecord, type DevframeInstanceRegistration, DevframeServicesHostImpl, DevframeViewHost, type RpcFunctionsHost, StartHttpAndWsOptions, StartedServer, coerceAgentPositionalArgs, createH3DevframeHost, createHostContext, createNodeSettings, createRpcSharedStateServerHost, createRpcStreamingServerHost, createScopedNodeContext, createStorage, formatHostForUrl, isObject, listLiveDevframeInstances, normalizeHttpServerUrl, registerDevframeInstance, startHttpAndWs, toDialableHost };
+export { CreateHostContextOptions, CreateStorageOptions, type RpcFunctionsHost, createHostContext, createStorage };

package/dist/node/index.mjs

@@ -1,5 +1,3 @@
-import { a as DevframeViewHost, c as createRpcSharedStateServerHost, d as coerceAgentPositionalArgs, i as createNodeSettings, l as DevframeDiagnosticsHost, n as createHostContext, o as DevframeServicesHostImpl, r as createScopedNodeContext, s as createRpcStreamingServerHost, t as createH3DevframeHost, u as DevframeAgentHost } from "../host-h3-Kz7t5Xab.mjs";
-import { t as createStorage } from "../storage-Dzoc3NVC.mjs";
-import { r as registerDevframeInstance, t as listLiveDevframeInstances } from "../instance-registry-D6fxYu36.mjs";
-import { a as toDialableHost, i as normalizeHttpServerUrl, n as formatHostForUrl, r as isObject, t as startHttpAndWs } from "../server-CXaDDUl0.mjs";
-export { DevframeAgentHost, DevframeDiagnosticsHost, DevframeServicesHostImpl, DevframeViewHost, coerceAgentPositionalArgs, createH3DevframeHost, createHostContext, createNodeSettings, createRpcSharedStateServerHost, createRpcStreamingServerHost, createScopedNodeContext, createStorage, formatHostForUrl, isObject, listLiveDevframeInstances, normalizeHttpServerUrl, registerDevframeInstance, startHttpAndWs, toDialableHost };
+import { t as createStorage } from "../storage-BcmVEJRc.mjs";
+import { t as createHostContext } from "../context-Du11TLcO.mjs";
+export { createHostContext, createStorage };

package/dist/recipes/common-rpc-functions.d.mts

@@ -1,7 +1,7 @@
-import "../devframe-qgCKL683.mjs";
+import "../devframe-Bdd9YXTy.mjs";
+import "../index-DSCq4M4q.mjs";
 import { E as Thenable, S as RpcFunctionSetupResult, c as RpcDump, g as RpcFunctionAgentOptions } from "../types-CnJSgRVa.mjs";
-import "../index-Dbw1p5ch.mjs";
-import { t as SimpleSchema } from "../simple-schema-BDzLeJDk.mjs";
+import { SimpleSchema } from "../utils/simple-schema.mjs";
 //#region src/recipes/common-rpc-functions.d.ts
 /**
  * Editor commands that `launch-editor` (the library behind

package/dist/recipes/interactive-auth.d.mts

@@ -1,5 +1,5 @@
-import { b as DevframeNodeContext, p as DevframeAuthHandler } from "../devframe-qgCKL683.mjs";
-import "../index-B7RgLw--.mjs";
+import { p as DevframeAuthHandler, x as DevframeNodeContext } from "../devframe-Bdd9YXTy.mjs";
+import "../index-CZRd2K1C.mjs";
 //#region src/recipes/interactive-auth.d.ts
 interface CreateInteractiveAuthOptions {
   /**
@@ -44,7 +44,7 @@ interface CreateInteractiveAuthOptions {
  * auth.printBanner()
  *
  * // wire `auth.authorize` / `auth.onConnect` into your transport, or pass
- * // the whole handler to `startHttpAndWs({ auth, ... })`.
+ * // the whole handler to `initDevframe` / `initHub` via their `auth` option.
  * ```
  */
 declare function createInteractiveAuth(context: DevframeNodeContext, options?: CreateInteractiveAuthOptions): DevframeAuthHandler;

package/dist/recipes/interactive-auth.mjs

@@ -1,8 +1,8 @@
 import { n as colors } from "../diagnostics-reporter-CsIG85Q5.mjs";
-import { isAnonymousRpcMethod } from "../constants.mjs";
 import { n as defineRpcFunction } from "../define-BLWPsH6y.mjs";
-import { t as getInternalContext } from "../context-CQefP2jR.mjs";
+import { isAnonymousRpcMethod } from "../constants.mjs";
 import { a as verifyAuthToken, n as exchangeTempAuthCode, r as getTempAuthCode, t as buildOtpAuthUrl } from "../state-BeUHDDjk.mjs";
+import { t as getInternalContext } from "../context-C33rR7n0.mjs";
 import { t as s } from "../simple-schema-DQPZrAaZ.mjs";
 //#region src/recipes/interactive-auth.ts
 function defaultBanner(info) {
@@ -26,7 +26,7 @@ function defaultBanner(info) {
 * auth.printBanner()
 *
 * // wire `auth.authorize` / `auth.onConnect` into your transport, or pass
-* // the whole handler to `startHttpAndWs({ auth, ... })`.
+* // the whole handler to `initDevframe` / `initHub` via their `auth` option.
 * ```
 */
 function createInteractiveAuth(context, options = {}) {
@@ -105,14 +105,14 @@ function createInteractiveAuth(context, options = {}) {
 		if (isAnonymousRpcMethod(methodName)) return true;
 		return !!session.meta.isTrusted;
 	}
-	function onConnect(peer, session) {
+	function onConnect(connection, session) {
 		let token;
 		let requestOrigin;
 		try {
-			token = new URL(peer.request?.url ?? "", "http://localhost").searchParams.get("devframe_auth_token") ?? void 0;
+			token = new URL(connection.request?.url ?? "", "http://localhost").searchParams.get("devframe_auth_token") ?? void 0;
 		} catch {}
 		try {
-			requestOrigin = peer.request?.headers?.get?.("origin") ?? void 0;
+			requestOrigin = connection.request?.headers?.get?.("origin") ?? void 0;
 		} catch {}
 		if (!token) return;
 		if (isStaticToken(token)) {

package/dist/rolldown-runtime-JspESFgx.mjs

@@ -0,0 +1,35 @@
+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 __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+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
+export { __toESM as i, __exportAll as n, __require as r, __commonJSMin as t };

package/dist/rpc/dump.d.mts

@@ -1,2 +1,78 @@
-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-vAX6bYuc.mjs";
+import { h as RpcDumpStore, l as RpcDumpClientOptions, m as RpcDumpRecordError, n as BirpcReturn, o as RpcDefinitionsToFunctions, u as RpcDumpCollectionOptions, v as RpcFunctionDefinitionAny } from "../types-CnJSgRVa.mjs";
+//#region src/rpc/dump/collect.d.ts
+/**
+ * Collects pre-computed dumps by executing functions with their defined input combinations.
+ * Static functions without dump config automatically get `{ inputs: [[]] }`.
+ *
+ * @example
+ * ```ts
+ * const store = await dumpFunctions([greet], context, { concurrency: 10 })
+ * ```
+ */
+declare function dumpFunctions<T extends readonly RpcFunctionDefinitionAny[]>(definitions: T, context?: any, options?: RpcDumpCollectionOptions): Promise<RpcDumpStore<RpcDefinitionsToFunctions<T>>>;
+/**
+ * Creates a client that serves pre-computed results from a dump store.
+ * Uses argument hashing to match calls to stored records.
+ *
+ * @example
+ * ```ts
+ * const client = createClientFromDump(store)
+ * await client.greet('Alice')
+ * ```
+ */
+declare function createClientFromDump<T extends Record<string, any>>(store: RpcDumpStore<T>, options?: RpcDumpClientOptions): BirpcReturn<T>;
+/**
+ * Filters function definitions to only those with dump definitions.
+ * Note: Only checks the definition itself, not setup results.
+ */
+declare function getDefinitionsWithDumps<T extends readonly RpcFunctionDefinitionAny[]>(definitions: T): RpcFunctionDefinitionAny[];
+//#endregion
+//#region src/rpc/dump/error.d.ts
+/**
+ * Normalize a thrown value into a plain object suitable for storage in
+ * a dump record. Preserves `message`, `name`, `cause`, and any own
+ * enumerable properties of an `Error` so consumers reading the dump can
+ * reconstruct a richer Error than just `{ message, name }`.
+ *
+ * Non-`Error` throws are wrapped as `{ name: 'Error', message: String(thrown) }`.
+ */
+declare function serializeDumpError(error: unknown): RpcDumpRecordError;
+/**
+ * Inverse of {@link serializeDumpError}: rebuild a thrown `Error` from
+ * the plain object stored in a dump record. Preserves `cause`, restores
+ * the original `name`, and re-attaches any custom own properties.
+ */
+declare function reviveDumpError(stored: RpcDumpRecordError): Error;
+//#endregion
+//#region src/rpc/dump/static.d.ts
+type StaticRpcDumpSerialization = 'json' | 'structured-clone';
+interface StaticRpcDumpManifestStaticEntry {
+  type: 'static';
+  path: string;
+  /** Encoder used when this entry's file was written. Default: `'json'`. */
+  serialization?: StaticRpcDumpSerialization;
+}
+interface StaticRpcDumpManifestQueryEntry {
+  type: 'query';
+  records: Record<string, string>;
+  fallback?: string;
+  /** Encoder used when each record/fallback file was written. Default: `'json'`. */
+  serialization?: StaticRpcDumpSerialization;
+}
+type StaticRpcDumpManifestValue = StaticRpcDumpManifestStaticEntry | StaticRpcDumpManifestQueryEntry | any;
+type StaticRpcDumpManifest = Record<string, StaticRpcDumpManifestValue>;
+interface StaticRpcDumpFile {
+  /** Whether this file was written via `JSON.stringify` or `structured-clone-es.stringify`. */
+  serialization: StaticRpcDumpSerialization;
+  /** Function name the file belongs to — used to scope `DF0019` errors during write. */
+  fnName: string;
+  /** Payload to encode. */
+  data: unknown;
+}
+interface StaticRpcDumpCollection {
+  manifest: StaticRpcDumpManifest;
+  files: Record<string, StaticRpcDumpFile>;
+}
+declare function collectStaticRpcDump(definitions: Iterable<RpcFunctionDefinitionAny>, context: any): Promise<StaticRpcDumpCollection>;
+//#endregion
 export { StaticRpcDumpCollection, StaticRpcDumpFile, StaticRpcDumpManifest, StaticRpcDumpManifestQueryEntry, StaticRpcDumpManifestStaticEntry, StaticRpcDumpManifestValue, StaticRpcDumpSerialization, collectStaticRpcDump, createClientFromDump, dumpFunctions, getDefinitionsWithDumps, reviveDumpError, serializeDumpError };

package/dist/rpc/dump.mjs

@@ -1,2 +1,2 @@
-import { c as getDefinitionsWithDumps, l as reviveDumpError, o as createClientFromDump, s as dumpFunctions, t as collectStaticRpcDump, u as serializeDumpError } from "../dump-CgZShDRB.mjs";
+import { a as reviveDumpError, i as getDefinitionsWithDumps, n as createClientFromDump, o as serializeDumpError, r as dumpFunctions, t as collectStaticRpcDump } from "../static-CvjkO8QE.mjs";
 export { collectStaticRpcDump, createClientFromDump, dumpFunctions, getDefinitionsWithDumps, reviveDumpError, serializeDumpError };

package/dist/rpc/index.d.mts

@@ -1,3 +1,3 @@
+import { a as STRUCTURED_CLONE_PREFIX, c as getRpcResolvedSetupResult, d as RpcFunctionsCollectorBase, f as RpcCacheManager, i as validateRpcReturn, l as createDefineWrapperWithContext, n as validateDefinitions, o as strictJsonStringify, p as RpcCacheOptions, r as validateRpcArgs, s as getRpcHandler, t as validateDefinition, u as defineRpcFunction } from "../index-DSCq4M4q.mjs";
 import { C as RpcFunctionType, E as Thenable, S as RpcFunctionSetupResult, T as RpcReturnSchema, _ as RpcFunctionDefinition, a as RpcDefinitionsFilter, b as RpcFunctionDefinitionBase, c as RpcDump, d as RpcDumpDefinition, f as RpcDumpGetter, g as RpcFunctionAgentOptions, h as RpcDumpStore, i as RpcArgsSchema, l as RpcDumpClientOptions, m as RpcDumpRecordError, n as BirpcReturn, o as RpcDefinitionsToFunctions, p as RpcDumpRecord, r as EntriesToObject, s as RpcDefinitionsToFunctionsWithNamespace, t as BirpcFn, u as RpcDumpCollectionOptions, v as RpcFunctionDefinitionAny, w as RpcFunctionsCollector, x as RpcFunctionDefinitionToFunction, y as RpcFunctionDefinitionAnyWithContext } from "../types-CnJSgRVa.mjs";
-import { C as defineRpcFunction, E as RpcCacheOptions, S as createDefineWrapperWithContext, T as RpcCacheManager, _ as validateRpcReturn, a as StaticRpcDumpManifestStaticEntry, b as getRpcHandler, c as collectStaticRpcDump, d as getDefinitionsWithDumps, f as reviveDumpError, g as validateRpcArgs, 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 STRUCTURED_CLONE_PREFIX, w as RpcFunctionsCollectorBase, x as getRpcResolvedSetupResult, y as strictJsonStringify } from "../index-Dbw1p5ch.mjs";
-export { type BirpcFn, type BirpcReturn, EntriesToObject, RpcArgsSchema, RpcCacheManager, RpcCacheOptions, RpcDefinitionsFilter, RpcDefinitionsToFunctions, RpcDefinitionsToFunctionsWithNamespace, 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, validateRpcArgs, validateRpcReturn };
+export { type BirpcFn, type BirpcReturn, EntriesToObject, RpcArgsSchema, RpcCacheManager, RpcCacheOptions, RpcDefinitionsFilter, RpcDefinitionsToFunctions, RpcDefinitionsToFunctionsWithNamespace, RpcDump, RpcDumpClientOptions, RpcDumpCollectionOptions, RpcDumpDefinition, RpcDumpGetter, RpcDumpRecord, RpcDumpRecordError, RpcDumpStore, RpcFunctionAgentOptions, RpcFunctionDefinition, RpcFunctionDefinitionAny, RpcFunctionDefinitionAnyWithContext, RpcFunctionDefinitionBase, RpcFunctionDefinitionToFunction, RpcFunctionSetupResult, RpcFunctionType, RpcFunctionsCollector, RpcFunctionsCollectorBase, RpcReturnSchema, STRUCTURED_CLONE_PREFIX, Thenable, createDefineWrapperWithContext, defineRpcFunction, getRpcHandler, getRpcResolvedSetupResult, strictJsonStringify, validateDefinition, validateDefinitions, validateRpcArgs, validateRpcReturn };

package/dist/rpc/index.mjs

@@ -1,7 +1,7 @@
-import { a as validateRpcReturn, c as getDefinitionsWithDumps$1, d as validateDefinition, f as validateDefinitions, i as validateRpcArgs, l as reviveDumpError$1, n as getRpcHandler, o as createClientFromDump$1, p as hash, r as getRpcResolvedSetupResult, s as dumpFunctions$1, t as collectStaticRpcDump$1, u as serializeDumpError$1 } from "../dump-CgZShDRB.mjs";
+import { a as validateRpcArgs, i as getRpcResolvedSetupResult, n as validateDefinitions, o as validateRpcReturn, r as getRpcHandler, s as hash, t as validateDefinition } from "../validation-BiuDXTKW.mjs";
 import { t as diagnostics } from "../diagnostics-hwjXp_UV.mjs";
 import { n as defineRpcFunction, t as createDefineWrapperWithContext } from "../define-BLWPsH6y.mjs";
-import { n as strictJsonStringify, t as STRUCTURED_CLONE_PREFIX } from "../serialization-C8Mnw9hK.mjs";
+import { n as strictJsonStringify, t as STRUCTURED_CLONE_PREFIX } from "../serialization-BHY8M5NQ.mjs";
 //#region src/rpc/cache.ts
 /**
 * @experimental API is expected to change.
@@ -116,18 +116,4 @@ function assertAgentJsonSerializable(fn) {
 	if (fn.agent && fn.jsonSerializable !== true) throw diagnostics.DF0019({ name: fn.name });
 }
 //#endregion
-//#region src/rpc/index.ts
-/** @deprecated Import from `devframe/rpc/dump` instead. */
-const collectStaticRpcDump = collectStaticRpcDump$1;
-/** @deprecated Import from `devframe/rpc/dump` instead. */
-const createClientFromDump = createClientFromDump$1;
-/** @deprecated Import from `devframe/rpc/dump` instead. */
-const dumpFunctions = dumpFunctions$1;
-/** @deprecated Import from `devframe/rpc/dump` instead. */
-const getDefinitionsWithDumps = getDefinitionsWithDumps$1;
-/** @deprecated Import from `devframe/rpc/dump` instead. */
-const reviveDumpError = reviveDumpError$1;
-/** @deprecated Import from `devframe/rpc/dump` instead. */
-const serializeDumpError = serializeDumpError$1;
-//#endregion
-export { RpcCacheManager, RpcFunctionsCollectorBase, STRUCTURED_CLONE_PREFIX, collectStaticRpcDump, createClientFromDump, createDefineWrapperWithContext, defineRpcFunction, dumpFunctions, getDefinitionsWithDumps, getRpcHandler, getRpcResolvedSetupResult, reviveDumpError, serializeDumpError, strictJsonStringify, validateDefinition, validateDefinitions, validateRpcArgs, validateRpcReturn };
+export { RpcCacheManager, RpcFunctionsCollectorBase, STRUCTURED_CLONE_PREFIX, createDefineWrapperWithContext, defineRpcFunction, getRpcHandler, getRpcResolvedSetupResult, strictJsonStringify, validateDefinition, validateDefinitions, validateRpcArgs, validateRpcReturn };

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

@@ -0,0 +1,2 @@
+import { n as createSseRpcChannel, t as SseRpcChannelOptions } from "../../sse-client-BsIK3hMD.mjs";
+export { SseRpcChannelOptions, createSseRpcChannel };