devframe 0.4.0 → 0.5.0

package/dist/node/{internal.d.mts → hub-internals.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-BuR6n9ZD.mjs";
+import { a as internalContextMap, i as getInternalContext, n as InternalAnonymousAuthStorage, r as RemoteTokenRecord, t as DevframeInternalContext } from "../context-DTRcO_UH.mjs";
 
 //#region src/adapters/_shared.d.ts
 /**
@@ -13,4 +13,4 @@ import { a as internalContextMap, i as getInternalContext, n as InternalAnonymou
 declare function resolveBasePath(def: DevframeDefinition, kind: DevframeDeploymentKind): string;
 declare function normalizeBasePath(base: string): string;
 //#endregion
-export { type DevToolsInternalContext, type InternalAnonymousAuthStorage, type RemoteTokenRecord, getInternalContext, internalContextMap, normalizeBasePath, resolveBasePath };
+export { type DevframeInternalContext, type InternalAnonymousAuthStorage, type RemoteTokenRecord, getInternalContext, internalContextMap, normalizeBasePath, resolveBasePath };

package/dist/node/hub-internals.mjs

@@ -0,0 +1,3 @@
+import { n as internalContextMap, t as getInternalContext } from "../context-DaKmhhHY.mjs";
+import { n as resolveBasePath, t as normalizeBasePath } from "../_shared-CUFqO4kJ.mjs";
+export { getInternalContext, internalContextMap, normalizeBasePath, resolveBasePath };

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 DevframeHost, P as SharedState, Q as AgentManifest, U as DevframeRpcClientFunctions, W as DevframeRpcServerFunctions, X as DevframeDiagnosticsLogger, Y as DevframeDiagnosticsHost$1, Z as AgentHandle, at as DevframeAgentHostEvents, d as DevframeNodeContext, et as AgentResourceContent, f as DevframeNodeRpcSession, g as RpcSharedStateHost, it as DevframeAgentHost$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 DevframeViewHost$1 } from "../devframe-BuR6n9ZD.mjs";
+import { _ as RpcFunctionDefinitionAny } from "../types-BkkQ0Txg.mjs";
+import { S as RpcFunctionsCollectorBase } from "../index-C7M1hnvL.mjs";
+import { t as DevframeNodeRpcSessionMeta } from "../ws-server-C1LjmRnp.mjs";
+import { n as StartedServer, r as startHttpAndWs, t as StartHttpAndWsOptions } from "../server-wHlpcdZ9.mjs";
 import { BirpcGroup } from "birpc";
 import { AsyncLocalStorage } from "node:async_hooks";
 
@@ -11,7 +11,7 @@ interface CreateHostContextOptions {
   cwd: string;
   workspaceRoot?: string;
   mode: 'dev' | 'build';
-  host: DevToolsHost;
+  host: DevframeHost;
   /**
    * Built-in RPC declarations to register on the host. Framework
    * adapters (vite, rolldown, cli) can pass the ones they need; the
@@ -20,14 +20,14 @@ interface CreateHostContextOptions {
   builtinRpcDeclarations?: readonly RpcFunctionDefinitionAny[];
 }
 /**
- * Framework- and build-tool-agnostic core of the DevTools node context.
+ * Framework- and build-tool-agnostic core of the Devframe node context.
  * Wires the RPC host, view (HTTP file-serving) host, diagnostics, and
  * agent subsystems. Host adapters can wrap this to augment `ctx` with
  * extra surfaces — for example, `@vitejs/devtools-kit`'s
  * `createKitContext` attaches `docks`, `terminals`, `messages`,
  * `commands`, and `createJsonRenderer` when mounted into Vite DevTools.
  */
-declare function createHostContext(options: CreateHostContextOptions): Promise<DevToolsNodeContext>;
+declare function createHostContext(options: CreateHostContextOptions): Promise<DevframeNodeContext>;
 //#endregion
 //#region src/node/host-agent.d.ts
 /**
@@ -38,13 +38,13 @@ declare function createHostContext(options: CreateHostContextOptions): Promise<D
  *
  * @experimental
  */
-declare class DevToolsAgentHost implements DevToolsAgentHost$1 {
-  readonly context: DevToolsNodeContext;
-  readonly events: EventEmitter<DevToolsAgentHostEvents>;
+declare class DevframeAgentHost implements DevframeAgentHost$1 {
+  readonly context: DevframeNodeContext;
+  readonly events: EventEmitter<DevframeAgentHostEvents>;
   private readonly tools;
   private readonly resources;
   private _rpcUnsubscribe;
-  constructor(context: DevToolsNodeContext);
+  constructor(context: DevframeNodeContext);
   registerTool(input: AgentToolInput): AgentHandle;
   unregisterTool(id: string): boolean;
   registerResource(input: AgentResourceInput): AgentHandle;
@@ -64,23 +64,23 @@ declare class DevToolsAgentHost implements DevToolsAgentHost$1 {
 }
 //#endregion
 //#region src/node/host-diagnostics.d.ts
-declare class DevToolsDiagnosticsHost implements DevToolsDiagnosticsHost$1 {
-  readonly context: DevToolsNodeContext;
+declare class DevframeDiagnosticsHost implements DevframeDiagnosticsHost$1 {
+  readonly context: DevframeNodeContext;
   private _registry;
-  readonly logger: DevToolsDiagnosticsLogger;
-  readonly defineDiagnostics: DevToolsDiagnosticsHost$1['defineDiagnostics'];
-  constructor(context: DevToolsNodeContext, initialDefinitions?: Array<Record<string, unknown>>);
+  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-functions.d.ts
-declare class RpcFunctionsHost extends RpcFunctionsCollectorBase<DevToolsRpcServerFunctions, DevToolsNodeContext> implements RpcFunctionsHost$1 {
+declare class RpcFunctionsHost extends RpcFunctionsCollectorBase<DevframeRpcServerFunctions, DevframeNodeContext> implements RpcFunctionsHost$1 {
   /**
    * @internal
    */
-  _rpcGroup: BirpcGroup<DevToolsRpcClientFunctions, DevToolsRpcServerFunctions, false>;
-  _asyncStorage: AsyncLocalStorage<DevToolsNodeRpcSession>;
-  constructor(context: DevToolsNodeContext);
+  _rpcGroup: BirpcGroup<DevframeRpcClientFunctions, DevframeRpcServerFunctions, false>;
+  _asyncStorage: AsyncLocalStorage<DevframeNodeRpcSession>;
+  constructor(context: DevframeNodeContext);
   sharedState: RpcSharedStateHost;
   streaming: RpcStreamingHost;
   /**
@@ -90,14 +90,14 @@ declare class RpcFunctionsHost extends RpcFunctionsCollectorBase<DevToolsRpcServ
    *
    * @internal
    */
-  _emitSessionDisconnected(meta: DevToolsNodeRpcSessionMeta): void;
-  invokeLocal<T extends keyof DevToolsRpcServerFunctions, Args extends Parameters<DevToolsRpcServerFunctions[T]>>(method: T, ...args: Args): Promise<Awaited<ReturnType<DevToolsRpcServerFunctions[T]>>>;
-  broadcast<T extends keyof DevToolsRpcClientFunctions, Args extends Parameters<DevToolsRpcClientFunctions[T]>>(options: RpcBroadcastOptions<T, Args>): Promise<void>;
-  getCurrentRpcSession(): DevToolsNodeRpcSession | undefined;
+  _emitSessionDisconnected(meta: DevframeNodeRpcSessionMeta): void;
+  invokeLocal<T extends keyof DevframeRpcServerFunctions, Args extends Parameters<DevframeRpcServerFunctions[T]>>(method: T, ...args: Args): Promise<Awaited<ReturnType<DevframeRpcServerFunctions[T]>>>;
+  broadcast<T extends keyof DevframeRpcClientFunctions, Args extends Parameters<DevframeRpcClientFunctions[T]>>(options: RpcBroadcastOptions<T, Args>): Promise<void>;
+  getCurrentRpcSession(): DevframeNodeRpcSession | undefined;
 }
 //#endregion
 //#region src/node/host-h3.d.ts
-interface CreateH3DevToolsHostOptions {
+interface CreateH3DevframeHostOptions {
   /** The h3 app instance — registered once the CLI adapter lands. */
   app?: unknown;
   /**
@@ -113,8 +113,8 @@ interface CreateH3DevToolsHostOptions {
   mount?: (base: string, distDir: string) => void | Promise<void>;
   /**
    * Namespace for storage paths returned by `getStorageDir`. Workspace
-   * state lives under `${workspaceRoot}/node_modules/.<appName>/devtools/`
-   * and global state under `${homedir()}/.<appName>/devtools/`. Pick the
+   * state lives 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.
    */
@@ -126,13 +126,13 @@ interface CreateH3DevToolsHostOptions {
   workspaceRoot?: string;
 }
 /**
- * h3-backed {@link DevToolsHost} — used by the standalone CLI adapter.
+ * h3-backed {@link DevframeHost} — used by the standalone CLI adapter.
  */
-declare function createH3DevToolsHost(options: CreateH3DevToolsHostOptions): DevToolsHost;
+declare function createH3DevframeHost(options: CreateH3DevframeHostOptions): DevframeHost;
 //#endregion
 //#region src/node/host-views.d.ts
-declare class DevToolsViewHost implements DevToolsViewHost$1 {
-  readonly context: DevToolsNodeContext;
+declare class DevframeViewHost implements DevframeViewHost$1 {
+  readonly context: DevframeNodeContext;
   /**
    * @internal
    */
@@ -140,7 +140,7 @@ declare class DevToolsViewHost implements DevToolsViewHost$1 {
     baseUrl: string;
     distDir: string;
   }[];
-  constructor(context: DevToolsNodeContext);
+  constructor(context: DevframeNodeContext);
   hostStatic(baseUrl: string, distDir: string): void;
 }
 //#endregion
@@ -169,4 +169,4 @@ declare function createStorage<T extends object>(options: CreateStorageOptions<T
 declare function isObject(value: unknown): value is Record<string, any>;
 declare function normalizeHttpServerUrl(host: string, port: number | string): string;
 //#endregion
-export { CreateH3DevToolsHostOptions, CreateHostContextOptions, CreateStorageOptions, DevToolsAgentHost, DevToolsDiagnosticsHost, DevToolsViewHost, RpcFunctionsHost, StartHttpAndWsOptions, StartedServer, createH3DevToolsHost, createHostContext, createRpcSharedStateServerHost, createRpcStreamingServerHost, createStorage, isObject, normalizeHttpServerUrl, startHttpAndWs };
+export { CreateH3DevframeHostOptions, CreateHostContextOptions, CreateStorageOptions, DevframeAgentHost, DevframeDiagnosticsHost, DevframeViewHost, RpcFunctionsHost, StartHttpAndWsOptions, StartedServer, createH3DevframeHost, createHostContext, createRpcSharedStateServerHost, createRpcStreamingServerHost, createStorage, isObject, normalizeHttpServerUrl, startHttpAndWs };

package/dist/node/index.mjs

@@ -1,6 +1,6 @@
-import { a as createRpcStreamingServerHost, c as DevToolsAgentHost, i as RpcFunctionsHost, n as createHostContext, o as createRpcSharedStateServerHost, r as DevToolsViewHost, s as DevToolsDiagnosticsHost, t as createH3DevToolsHost } from "../host-h3-Div5Vp8R.mjs";
-import { t as startHttpAndWs } from "../server-BO8IDVsJ.mjs";
-import { t as createStorage } from "../storage-CZVTPKsw.mjs";
+import { a as createRpcStreamingServerHost, c as DevframeAgentHost, i as RpcFunctionsHost, n as createHostContext, o as createRpcSharedStateServerHost, r as DevframeViewHost, s as DevframeDiagnosticsHost, t as createH3DevframeHost } from "../host-h3-Dgpgr1Ul.mjs";
+import { r as createStorage } from "../context-DaKmhhHY.mjs";
+import { t as startHttpAndWs } from "../server-BBaBJaUL.mjs";
 import { isIP } from "node:net";
 //#region src/node/utils.ts
 function isObject(value) {
@@ -10,4 +10,4 @@ function normalizeHttpServerUrl(host, port) {
 	return `http://${host === "127.0.0.1" ? "localhost" : isIP(host) === 6 ? `[${host}]` : host}:${port}`;
 }
 //#endregion
-export { DevToolsAgentHost, DevToolsDiagnosticsHost, DevToolsViewHost, RpcFunctionsHost, createH3DevToolsHost, createHostContext, createRpcSharedStateServerHost, createRpcStreamingServerHost, createStorage, isObject, normalizeHttpServerUrl, startHttpAndWs };
+export { DevframeAgentHost, DevframeDiagnosticsHost, DevframeViewHost, RpcFunctionsHost, createH3DevframeHost, createHostContext, createRpcSharedStateServerHost, createRpcStreamingServerHost, createStorage, isObject, normalizeHttpServerUrl, startHttpAndWs };

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-BkkQ0Txg.mjs";
 import * as v from "valibot";
 
 //#region src/recipes/open-helpers.d.ts
@@ -31,7 +31,7 @@ declare const openInEditor: {
   handler?: ((args_0: string) => void) | undefined;
   dump?: RpcDump<[string], void, undefined> | undefined;
   snapshot?: boolean;
-  __resolved?: RpcFunctionSetupResult<[string], void> | undefined;
+  __cache?: WeakMap<object, Thenable<RpcFunctionSetupResult<[string], void>>> | undefined;
   __promise?: Thenable<RpcFunctionSetupResult<[string], void>> | undefined;
 };
 /**
@@ -57,7 +57,7 @@ declare const openInFinder: {
   handler?: ((args_0: string) => void) | undefined;
   dump?: RpcDump<[string], void, undefined> | undefined;
   snapshot?: boolean;
-  __resolved?: RpcFunctionSetupResult<[string], void> | undefined;
+  __cache?: WeakMap<object, Thenable<RpcFunctionSetupResult<[string], void>>> | undefined;
   __promise?: Thenable<RpcFunctionSetupResult<[string], void>> | undefined;
 };
 /**
@@ -82,7 +82,7 @@ declare const openHelpers: readonly [{
   handler?: ((args_0: string) => void) | undefined;
   dump?: RpcDump<[string], void, undefined> | undefined;
   snapshot?: boolean;
-  __resolved?: RpcFunctionSetupResult<[string], void> | undefined;
+  __cache?: WeakMap<object, Thenable<RpcFunctionSetupResult<[string], void>>> | undefined;
   __promise?: Thenable<RpcFunctionSetupResult<[string], void>> | undefined;
 }, {
   name: "devframe:open-in-finder";
@@ -96,7 +96,7 @@ declare const openHelpers: readonly [{
   handler?: ((args_0: string) => void) | undefined;
   dump?: RpcDump<[string], void, undefined> | undefined;
   snapshot?: boolean;
-  __resolved?: RpcFunctionSetupResult<[string], void> | undefined;
+  __cache?: WeakMap<object, Thenable<RpcFunctionSetupResult<[string], void>>> | undefined;
   __promise?: Thenable<RpcFunctionSetupResult<[string], void>> | undefined;
 }];
 //#endregion

package/dist/{human-id-Dq-qgtES.mjs → revoke-CL0LSAN9.mjs}

@@ -1,37 +1,3 @@
-//#region src/node/auth/revoke.ts
-/**
-* Flip `isTrusted` to false on any live WS clients connected with `token`
-* and broadcast the `auth:revoked` event so they can react.
-*
-* Shared between persisted-auth revocation and remote-dock token revocation.
-*/
-async function revokeActiveConnectionsForToken(context, token) {
-	const rpcHost = context.rpc;
-	if (!rpcHost?._rpcGroup) return;
-	const affectedSessionIds = /* @__PURE__ */ new Set();
-	for (const client of rpcHost._rpcGroup.clients) if (client.$meta.clientAuthToken === token) {
-		affectedSessionIds.add(client.$meta.id);
-		client.$meta.isTrusted = false;
-		client.$meta.clientAuthToken = void 0;
-	}
-	if (affectedSessionIds.size === 0) return;
-	await rpcHost.broadcast({
-		method: "devframe:auth:revoked",
-		args: [],
-		filter: (client) => affectedSessionIds.has(client.$meta.id)
-	});
-}
-/**
-* Revoke an auth token: remove from storage and notify all connected clients
-* using this token that they are no longer trusted.
-*/
-async function revokeAuthToken(context, storage, token) {
-	storage.mutate((state) => {
-		delete state.trusted[token];
-	});
-	await revokeActiveConnectionsForToken(context, token);
-}
-//#endregion
 //#region src/utils/human-id.ts
 const adjectives = [
 	"afraid",
@@ -800,4 +766,38 @@ function humanId() {
 	return `${pick(adjectives)}-${pick(nouns)}-${pick(verbs)}`;
 }
 //#endregion
-export { revokeActiveConnectionsForToken as n, revokeAuthToken as r, humanId as t };
+//#region src/node/auth/revoke.ts
+/**
+* Flip `isTrusted` to false on any live WS clients connected with `token`
+* and broadcast the `auth:revoked` event so they can react.
+*
+* Shared between persisted-auth revocation and remote-dock token revocation.
+*/
+async function revokeActiveConnectionsForToken(context, token) {
+	const rpcHost = context.rpc;
+	if (!rpcHost?._rpcGroup) return;
+	const affectedSessionIds = /* @__PURE__ */ new Set();
+	for (const client of rpcHost._rpcGroup.clients) if (client.$meta.clientAuthToken === token) {
+		affectedSessionIds.add(client.$meta.id);
+		client.$meta.isTrusted = false;
+		client.$meta.clientAuthToken = void 0;
+	}
+	if (affectedSessionIds.size === 0) return;
+	await rpcHost.broadcast({
+		method: "devframe:auth:revoked",
+		args: [],
+		filter: (client) => affectedSessionIds.has(client.$meta.id)
+	});
+}
+/**
+* Revoke an auth token: remove from storage and notify all connected clients
+* using this token that they are no longer trusted.
+*/
+async function revokeAuthToken(context, storage, token) {
+	storage.mutate((state) => {
+		delete state.trusted[token];
+	});
+	await revokeActiveConnectionsForToken(context, token);
+}
+//#endregion
+export { revokeAuthToken as n, humanId as r, revokeActiveConnectionsForToken as t };

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-DH2sBIwd.mjs";
 export { StaticRpcDumpCollection, StaticRpcDumpFile, StaticRpcDumpManifest, StaticRpcDumpManifestQueryEntry, StaticRpcDumpManifestStaticEntry, StaticRpcDumpManifestValue, StaticRpcDumpSerialization, collectStaticRpcDump, createClientFromDump, dumpFunctions, getDefinitionsWithDumps, reviveDumpError, serializeDumpError };

package/dist/rpc/dump.mjs

@@ -1,2 +1,2 @@
-import { a as dumpFunctions, c as serializeDumpError, i as createClientFromDump, o as getDefinitionsWithDumps, s as reviveDumpError, t as collectStaticRpcDump } from "../dump-B1wd4u68.mjs";
+import { a as dumpFunctions, c as serializeDumpError, i as createClientFromDump, o as getDefinitionsWithDumps, s as reviveDumpError, t as collectStaticRpcDump } from "../dump-9lKIJTLh.mjs";
 export { 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-BkkQ0Txg.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-C7M1hnvL.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/index.mjs

@@ -1,4 +1,4 @@
-import { a as dumpFunctions$1, c as serializeDumpError$1, d as hash, i as createClientFromDump$1, l as validateDefinition, n as getRpcHandler, o as getDefinitionsWithDumps$1, r as getRpcResolvedSetupResult, s as reviveDumpError$1, t as collectStaticRpcDump$1, u as validateDefinitions } from "../dump-B1wd4u68.mjs";
+import { a as dumpFunctions$1, c as serializeDumpError$1, d as hash, i as createClientFromDump$1, l as validateDefinition, n as getRpcHandler, o as getDefinitionsWithDumps$1, r as getRpcResolvedSetupResult, s as reviveDumpError$1, t as collectStaticRpcDump$1, u as validateDefinitions } from "../dump-9lKIJTLh.mjs";
 import { t as diagnostics } from "../diagnostics-GitRGKbr.mjs";
 import { n as defineRpcFunction, t as createDefineWrapperWithContext } from "../define-CW9gLnyG.mjs";
 import { n as strictJsonStringify, t as STRUCTURED_CLONE_PREFIX } from "../serialization-BD_qXGjd.mjs";

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-CVYX9niP.mjs";
 export { WsRpcChannelOptions, createWsRpcChannel };

package/dist/rpc/transports/ws-client.mjs

@@ -9,7 +9,7 @@ const EMPTY_DEFS = /* @__PURE__ */ new Map();
 */
 function createWsRpcChannel(options) {
 	let url = options.url;
-	if (options.authToken) url = `${url}?vite_devtools_auth_token=${encodeURIComponent(options.authToken)}`;
+	if (options.authToken) url = `${url}?devframe_auth_token=${encodeURIComponent(options.authToken)}`;
 	const ws = new WebSocket(url);
 	const { onConnected = NOOP, onError = NOOP, onDisconnected = NOOP, definitions = EMPTY_DEFS } = options;
 	ws.addEventListener("open", (e) => {

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";
-export { DevToolsNodeRpcSessionMeta, WsRpcTransportOptions, attachWsRpcTransport };
+import { n as WsRpcTransportOptions, r as attachWsRpcTransport, t as DevframeNodeRpcSessionMeta } from "../../ws-server-C1LjmRnp.mjs";
+export { DevframeNodeRpcSessionMeta, WsRpcTransportOptions, attachWsRpcTransport };

package/dist/{server-BO8IDVsJ.mjs → server-BBaBJaUL.mjs}

@@ -1,5 +1,6 @@
 import { createRpcServer } from "./rpc/server.mjs";
 import { attachWsRpcTransport } from "./rpc/transports/ws-server.mjs";
+import { t as getInternalContext } from "./context-DaKmhhHY.mjs";
 import { WebSocketServer } from "ws";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { createServer } from "node:http";
@@ -39,8 +40,8 @@ async function startHttpAndWs(options) {
 	rpcHost._rpcGroup = rpcGroup;
 	rpcHost._asyncStorage = asyncStorage;
 	rpcHost._authDisabled = options.auth === false;
-	if (options.auth === false && !rpcHost.definitions.has("vite:anonymous:auth")) rpcHost.register({
-		name: "vite:anonymous:auth",
+	if (options.auth === false && !rpcHost.definitions.has("devframe:anonymous:auth")) rpcHost.register({
+		name: "devframe:anonymous:auth",
 		type: "action",
 		handler: () => {
 			const session = rpcHost.getCurrentRpcSession();
@@ -51,15 +52,20 @@ async function startHttpAndWs(options) {
 	await new Promise((resolveListen) => {
 		httpServer.listen(port, bindHost, () => resolveListen());
 	});
-	const origin = `http://${bindHost}:${port}`;
+	const address = httpServer.address();
+	const resolvedPort = typeof address === "object" && address ? address.port : port;
+	const origin = `http://${bindHost}:${resolvedPort}`;
+	const internal = getInternalContext(context);
+	const wsUrl = origin.replace(/^http/, "ws");
+	internal.wsEndpoint = { url: wsUrl };
 	if (options.onReady) await options.onReady({
 		origin,
-		port,
+		port: resolvedPort,
 		app
 	});
 	return {
 		origin,
-		port,
+		port: resolvedPort,
 		app,
 		wss,
 		rpcGroup,
@@ -67,6 +73,7 @@ async function startHttpAndWs(options) {
 			for (const ws of wss.clients) ws.terminate();
 			await new Promise((r) => wss.close(() => r()));
 			await new Promise((r) => httpServer.close(() => r()));
+			if (getInternalContext(context).wsEndpoint?.url === wsUrl) getInternalContext(context).wsEndpoint = void 0;
 		}
 	};
 }

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

@@ -1,11 +1,11 @@
-import { E as DevToolsRpcServerFunctions, T as DevToolsRpcClientFunctions, d as DevToolsNodeContext } from "./devframe-xC8Q-xyt.mjs";
+import { U as DevframeRpcClientFunctions, W as DevframeRpcServerFunctions, d as DevframeNodeContext } from "./devframe-BuR6n9ZD.mjs";
 import { BirpcGroup } from "birpc";
 import { WebSocketServer } from "ws";
 import { H3 } from "h3";
 
 //#region src/node/server.d.ts
 interface StartHttpAndWsOptions {
-  context: DevToolsNodeContext;
+  context: DevframeNodeContext;
   host?: string;
   port: number;
   /**
@@ -42,7 +42,7 @@ interface StartedServer {
   port: number;
   app: H3;
   wss: WebSocketServer;
-  rpcGroup: BirpcGroup<DevToolsRpcClientFunctions, DevToolsRpcServerFunctions, false>;
+  rpcGroup: BirpcGroup<DevframeRpcClientFunctions, DevframeRpcServerFunctions, false>;
   close: () => Promise<void>;
 }
 /**

package/dist/{shared-state-CasqoUba.mjs → shared-state-BlBNYziY.mjs}

@@ -6,7 +6,7 @@ const diagnostics = defineDiagnostics({
 	reporters: [devframeReporter],
 	codes: {
 		DF0006: { why: (p) => `RPC function "${p.name}" is not registered` },
-		DF0007: { why: "AsyncLocalStorage is not set, it likely to be an internal bug of the DevTools foundation" },
+		DF0007: { why: "AsyncLocalStorage is not set, it likely to be an internal bug of the Devframe foundation" },
 		DF0008: { why: (p) => `distDir ${p.distDir} does not exist` },
 		DF0012: { why: (p) => `Failed to parse storage file: ${p.filepath}, falling back to defaults.` },
 		DF0013: { why: (p) => `Shared state of "${p.key}" is not found, please provide an initial value for the first time` },

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";
-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 };
+import { $ as AgentResource, B as EntriesToObject, G as DevframeRpcSharedStates, H as Thenable, J as DevframeDiagnosticsDefinition, K as DevframeHost, Q as AgentManifest, U as DevframeRpcClientFunctions, V as PartialWithoutId, W as DevframeRpcServerFunctions, X as DevframeDiagnosticsLogger, Y as DevframeDiagnosticsHost, Z as AgentHandle, _ as RpcStreamingChannel, a as DevframeRuntime, at as DevframeAgentHostEvents, c as defineDevframe, ct as EventsMap, d as DevframeNodeContext, et as AgentResourceContent, f as DevframeNodeRpcSession, g as RpcSharedStateHost, h as RpcSharedStateGetOptions, i as DevframeDeploymentKind, it as DevframeAgentHost, l as ConnectionMeta, m as RpcFunctionsHost, n as DevframeCliOptions, nt as AgentTool, o as DevframeSetupInfo, ot as EventEmitter, p as RpcBroadcastOptions, q as DevframeDefineDiagnosticsOptions, r as DevframeDefinition, rt as AgentToolInput, s as DevframeSpaOptions, st as EventUnsubscribe, t as DevframeBrowserContext, tt as AgentResourceInput, u as DevframeCapabilities, v as RpcStreamingChannelOptions, y as RpcStreamingHost, z as DevframeViewHost } from "../devframe-BuR6n9ZD.mjs";
+import { h as RpcFunctionAgentOptions } from "../types-BkkQ0Txg.mjs";
+import { t as DevframeNodeRpcSessionMeta } from "../ws-server-C1LjmRnp.mjs";
+export { AgentHandle, AgentManifest, AgentResource, AgentResourceContent, AgentResourceInput, AgentTool, AgentToolInput, ConnectionMeta, DevframeAgentHost, DevframeAgentHostEvents, DevframeBrowserContext, DevframeCapabilities, DevframeCliOptions, DevframeDefineDiagnosticsOptions, DevframeDefinition, DevframeDeploymentKind, DevframeDiagnosticsDefinition, DevframeDiagnosticsHost, DevframeDiagnosticsLogger, DevframeHost, DevframeNodeContext, DevframeNodeRpcSession, DevframeNodeRpcSessionMeta, DevframeRpcClientFunctions, DevframeRpcServerFunctions, DevframeRpcSharedStates, DevframeRuntime, DevframeSetupInfo, DevframeSpaOptions, DevframeViewHost, EntriesToObject, EventEmitter, EventUnsubscribe, EventsMap, PartialWithoutId, RpcBroadcastOptions, RpcFunctionAgentOptions, RpcFunctionsHost, RpcSharedStateGetOptions, RpcSharedStateHost, RpcStreamingChannel, RpcStreamingChannelOptions, RpcStreamingHost, Thenable, defineDevframe };

package/dist/{types-BXL7EIDM.d.mts → types-BkkQ0Txg.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 */
@@ -234,8 +234,8 @@ type RpcFunctionDefinition<NAME extends string, TYPE extends RpcFunctionType = '
    * to the same snapshot. Only valid on `query` (or untyped)
    * functions — `static` already has equivalent default behavior.
    */
-  snapshot?: boolean;
-  __resolved?: RpcFunctionSetupResult<ARGS, RETURN>;
+  snapshot?: boolean; /** Per-context setup-result cache, populated by `getRpcResolvedSetupResult`. @internal */
+  __cache?: WeakMap<object, Thenable<RpcFunctionSetupResult<ARGS, RETURN>>>; /** Single-slot fallback for primitive contexts. @internal */
   __promise?: Thenable<RpcFunctionSetupResult<ARGS, RETURN>>;
 } : {
   /** Function name (unique identifier) */name: NAME; /** Function type (static, action, event, or query) */
@@ -271,8 +271,8 @@ type RpcFunctionDefinition<NAME extends string, TYPE extends RpcFunctionType = '
    * 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>>;
+  snapshot?: boolean; /** Per-context setup-result cache, populated by `getRpcResolvedSetupResult`. @internal */
+  __cache?: WeakMap<object, Thenable<RpcFunctionSetupResult<InferArgsType<AS>, InferReturnType<RS>>>>; /** Single-slot fallback for primitive contexts. @internal */
   __promise?: Thenable<RpcFunctionSetupResult<InferArgsType<AS>, InferReturnType<RS>>>;
 };
 type RpcFunctionDefinitionToFunction<T extends RpcFunctionDefinitionAny> = T extends {

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-BuR6n9ZD.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-BuR6n9ZD.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-BuR6n9ZD.mjs";
 export { BufferedChunk, CreateStreamReaderOptions, CreateStreamSinkOptions, StreamErrorPayload, StreamReader, StreamSink, StreamSinkEvents, createStreamReader, createStreamSink };

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

@@ -0,0 +1,26 @@
+import { _ as RpcFunctionDefinitionAny } from "./types-BkkQ0Txg.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-C1LjmRnp.d.mts}

@@ -1,11 +1,11 @@
-import { _ as RpcFunctionDefinitionAny } from "./types-BXL7EIDM.mjs";
+import { _ as RpcFunctionDefinitionAny } from "./types-BkkQ0Txg.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 {
+interface DevframeNodeRpcSessionMeta {
   id: number;
   ws?: WebSocket;
   clientAuthToken?: string;
@@ -42,8 +42,8 @@ interface WsRpcTransportOptions {
    * loses dev-time validation for `jsonSerializable: true` declarations.
    */
   definitions?: ReadonlyMap<string, Pick<RpcFunctionDefinitionAny, 'jsonSerializable'>>;
-  onConnected?: (ws: WebSocket, req: IncomingMessage, meta: DevToolsNodeRpcSessionMeta) => void;
-  onDisconnected?: (ws: WebSocket, meta: DevToolsNodeRpcSessionMeta) => void;
+  onConnected?: (ws: WebSocket, req: IncomingMessage, meta: DevframeNodeRpcSessionMeta) => void;
+  onDisconnected?: (ws: WebSocket, meta: DevframeNodeRpcSessionMeta) => void;
   /** Override the default per-call serializer. Most callers should leave this unset. */
   serialize?: ChannelOptions['serialize'];
   /** Override the default per-call deserializer. Most callers should leave this unset. */
@@ -58,4 +58,4 @@ declare function attachWsRpcTransport<ClientFunctions extends object, ServerFunc
   wss: WebSocketServer;
 };
 //#endregion
-export { WsRpcTransportOptions as n, attachWsRpcTransport as r, DevToolsNodeRpcSessionMeta as t };
+export { WsRpcTransportOptions as n, attachWsRpcTransport as r, DevframeNodeRpcSessionMeta as t };