devframe 0.4.0 → 0.5.0

package/dist/{devframe-xC8Q-xyt.d.mts → devframe-BuR6n9ZD.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-C7M1hnvL.mjs";
+import { t as DevframeNodeRpcSessionMeta } from "./ws-server-C1LjmRnp.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
 /**
@@ -148,7 +148,7 @@ interface AgentTool {
   }[];
 }
 /**
- * Input accepted by `DevToolsAgentHost.registerTool()`. Handler is
+ * Input accepted by `DevframeAgentHost.registerTool()`. Handler is
  * stripped from the serializable `AgentTool` projection.
  *
  * @experimental
@@ -170,7 +170,7 @@ interface AgentToolInput {
 }
 /**
  * Serializable description of an agent-readable resource. Resources
- * surface structured or textual snapshots of devtools state.
+ * surface structured or textual snapshots of devframe state.
  *
  * @experimental
  */
@@ -184,7 +184,7 @@ interface AgentResource {
   mimeType?: string;
 }
 /**
- * Input accepted by `DevToolsAgentHost.registerResource()`.
+ * Input accepted by `DevframeAgentHost.registerResource()`.
  *
  * @experimental
  */
@@ -227,11 +227,11 @@ interface AgentHandle {
   unregister: () => void;
 }
 /**
- * Events emitted by `DevToolsAgentHost`.
+ * Events emitted by `DevframeAgentHost`.
  *
  * @experimental
  */
-interface DevToolsAgentHostEvents {
+interface DevframeAgentHostEvents {
   'agent:tool:registered': (tool: AgentTool) => void;
   'agent:tool:unregistered': (id: string) => void;
   'agent:resource:registered': (resource: AgentResource) => void;
@@ -251,8 +251,8 @@ interface DevToolsAgentHostEvents {
  * @experimental The agent-native surface is experimental and may change
  * without a major version bump until it stabilizes.
  */
-interface DevToolsAgentHost {
-  readonly events: EventEmitter<DevToolsAgentHostEvents>;
+interface DevframeAgentHost {
+  readonly events: EventEmitter<DevframeAgentHostEvents>;
   /**
    * Register a tool not backed by an RPC function. Use this when you
    * want a plain agent action (e.g. a synthesized summary) that
@@ -292,7 +292,7 @@ interface DevToolsAgentHost {
  * types don't allow assigning a narrow-keyed result to a generically-keyed
  * one. The host stores them in a heterogeneous registry.
  */
-type DevToolsDiagnosticsDefinition = ReturnType<typeof defineDiagnostics<any, any>>;
+type DevframeDiagnosticsDefinition = ReturnType<typeof defineDiagnostics<any, any>>;
 /**
  * The shared diagnostics lookup exposed by the host. A `Proxy` that resolves
  * any registered code name to its `nostics` handle (a callable that builds
@@ -300,13 +300,13 @@ type DevToolsDiagnosticsDefinition = ReturnType<typeof defineDiagnostics<any, an
  * because it spans heterogeneous definitions registered by different
  * integrations.
  */
-type DevToolsDiagnosticsLogger = Record<string, any>;
+type DevframeDiagnosticsLogger = Record<string, any>;
 /**
  * Options accepted by the host's `defineDiagnostics()` factory — mirrors
  * `nostics`'s shape but the host pre-wires its ANSI console reporter, so
  * plugins typically omit `reporters`.
  */
-interface DevToolsDefineDiagnosticsOptions<Codes extends Record<string, DiagnosticDefinition>> {
+interface DevframeDefineDiagnosticsOptions<Codes extends Record<string, DiagnosticDefinition>> {
   docsBase?: string | ((code: keyof Codes) => string | undefined);
   codes: Codes;
   reporters?: ReadonlyArray<(d: Diagnostic, o?: any) => void>;
@@ -334,7 +334,7 @@ interface DevToolsDefineDiagnosticsOptions<Codes extends Record<string, Diagnost
  * throw myDiagnostics.MYP0001()
  * ```
  */
-interface DevToolsDiagnosticsHost {
+interface DevframeDiagnosticsHost {
   /**
    * Proxy-backed lookup of every registered diagnostic handle by code name.
    * Resolves to a `nostics` `DiagnosticHandle` — a callable that builds a
@@ -342,7 +342,7 @@ interface DevToolsDiagnosticsHost {
    * `throw` to raise. Loosely typed — for autocompletion, keep a reference
    * to the typed result of `defineDiagnostics()` instead.
    */
-  readonly logger: DevToolsDiagnosticsLogger;
+  readonly logger: DevframeDiagnosticsLogger;
   /**
    * Register additional diagnostic definitions with this host. After
    * registration, codes from the new definition are reachable via
@@ -356,14 +356,14 @@ interface DevToolsDiagnosticsHost {
    * pre-wired. Mirrors `nostics`'s `defineDiagnostics` so integrations don't
    * need to take a direct dependency on `nostics`.
    */
-  defineDiagnostics: <const Codes extends Record<string, DiagnosticDefinition>>(options: DevToolsDefineDiagnosticsOptions<Codes>) => ReturnType<typeof defineDiagnostics<Codes, any>>;
+  defineDiagnostics: <const Codes extends Record<string, DiagnosticDefinition>>(options: DevframeDefineDiagnosticsOptions<Codes>) => ReturnType<typeof defineDiagnostics<Codes, any>>;
 }
 //#endregion
 //#region src/types/host.d.ts
-interface DevToolsHost {
+interface DevframeHost {
   /**
    * Serve a static directory at the given URL base. Called by
-   * `DevToolsViewHost.hostStatic`. Implementations map this to whatever
+   * `DevframeViewHost.hostStatic`. Implementations map this to whatever
    * the underlying runtime expects (Vite middleware, h3 handler, no-op
    * for build snapshots).
    */
@@ -377,16 +377,16 @@ interface DevToolsHost {
    */
   resolveOrigin: () => string;
   /**
-   * Resolve a directory the host owns for persisted devtools state.
+   * Resolve a directory the host owns for persisted devframe state.
    * Each host picks its own app-name namespace so storage doesn't
-   * collide between, say, the Vite host (`.vite/devtools`) and a
-   * standalone CLI host (`.<appName>/devtools`).
+   * collide between, say, the Vite host (`.vite/devframe`) and a
+   * standalone CLI host (`.<appName>/devframe`).
    *
    *   - `workspace` — per-project state (settings, caches). Typically
-   *     under `${workspaceRoot}/node_modules/.<appName>/devtools/`.
+   *     under `${workspaceRoot}/node_modules/.<appName>/devframe/`.
    *   - `global`    — per-user state (auth tokens, machine-wide
    *     preferences). Typically under
-   *     `${homedir()}/.<appName>/devtools/`.
+   *     `${homedir()}/.<appName>/devframe/`.
    *
    * Implementations should ensure the directory exists or be safe to
    * pass to a downstream `createStorage(...)` call that creates it
@@ -399,7 +399,7 @@ interface DevToolsHost {
 /**
  * To be extended
  */
-interface DevToolsRpcClientFunctions {
+interface DevframeRpcClientFunctions {
   /**
    * Streaming chunk pushed from server to subscribed clients. Wired by
    * `RpcStreamingHost`; do not register manually.
@@ -428,7 +428,7 @@ interface DevToolsRpcClientFunctions {
 /**
  * To be extended
  */
-interface DevToolsRpcServerFunctions {
+interface DevframeRpcServerFunctions {
   /**
    * Subscribe a client to a shared-state key. Wired by
    * `RpcSharedStateHost`; do not register manually.
@@ -501,7 +501,7 @@ interface DevToolsRpcServerFunctions {
 /**
  * To be extended
  */
-interface DevToolsRpcSharedStates {}
+interface DevframeRpcSharedStates {}
 //#endregion
 //#region src/types/utils.d.ts
 type Thenable<T> = T | Promise<T>;
@@ -513,7 +513,7 @@ type PartialWithoutId<T extends {
 };
 //#endregion
 //#region src/types/views.d.ts
-interface DevToolsViewHost {
+interface DevframeViewHost {
   /**
    * @internal
    */
@@ -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,36 +696,48 @@ 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 {
-  meta: DevToolsNodeRpcSessionMeta;
-  rpc: BirpcReturn<DevToolsRpcClientFunctions, DevToolsRpcServerFunctions, false>;
+interface DevframeNodeRpcSession {
+  meta: DevframeNodeRpcSessionMeta;
+  rpc: BirpcReturn<DevframeRpcClientFunctions, DevframeRpcServerFunctions, false>;
 }
 interface RpcBroadcastOptions<METHOD, Args extends any[]> {
   method: METHOD;
   args: Args;
   optional?: boolean;
   event?: boolean;
-  filter?: (client: BirpcReturn<DevToolsRpcClientFunctions, DevToolsRpcServerFunctions, false>) => boolean | void;
+  filter?: (client: BirpcReturn<DevframeRpcClientFunctions, DevframeRpcServerFunctions, false>) => boolean | void;
 }
-type RpcFunctionsHost = RpcFunctionsCollectorBase<DevToolsRpcServerFunctions, DevToolsNodeContext> & {
+type RpcFunctionsHost = RpcFunctionsCollectorBase<DevframeRpcServerFunctions, DevframeNodeContext> & {
   /**
    * Invoke a locally registered server RPC function directly.
    *
    * This bypasses transport and is useful for server-side cross-function calls.
    */
-  invokeLocal: <T extends keyof DevToolsRpcServerFunctions, Args extends Parameters<DevToolsRpcServerFunctions[T]>>(method: T, ...args: Args) => Promise<Awaited<ReturnType<DevToolsRpcServerFunctions[T]>>>;
+  invokeLocal: <T extends keyof DevframeRpcServerFunctions, Args extends Parameters<DevframeRpcServerFunctions[T]>>(method: T, ...args: Args) => Promise<Awaited<ReturnType<DevframeRpcServerFunctions[T]>>>;
   /**
    * Broadcast a message to all connected clients
    */
-  broadcast: <T extends keyof DevToolsRpcClientFunctions, Args extends Parameters<DevToolsRpcClientFunctions[T]>>(options: RpcBroadcastOptions<T, Args>) => Promise<void>;
+  broadcast: <T extends keyof DevframeRpcClientFunctions, Args extends Parameters<DevframeRpcClientFunctions[T]>>(options: RpcBroadcastOptions<T, Args>) => Promise<void>;
   /**
    * Get the current RPC client
    *
    * Available in RPC functions to get the current RPC client
    */
-  getCurrentRpcSession: () => DevToolsNodeRpcSession | undefined;
+  getCurrentRpcSession: () => DevframeNodeRpcSession | undefined;
   /**
    * The shared state host
    */
@@ -706,7 +755,7 @@ interface RpcSharedStateGetOptions<T> {
   initialValue?: T;
 }
 interface RpcSharedStateHost {
-  get: <T extends keyof DevToolsRpcSharedStates>(key: T, options?: RpcSharedStateGetOptions<DevToolsRpcSharedStates[T]>) => Promise<SharedState<DevToolsRpcSharedStates[T]>>;
+  get: <T extends keyof DevframeRpcSharedStates>(key: T, options?: RpcSharedStateGetOptions<DevframeRpcSharedStates[T]>) => Promise<SharedState<DevframeRpcSharedStates[T]>>;
   keys: () => string[];
   /**
    * Subscribe to new shared-state keys becoming available. Fires when
@@ -817,11 +866,11 @@ interface RpcStreamingHost {
    *
    * @internal
    */
-  _onSessionDisconnected: (meta: DevToolsNodeRpcSessionMeta) => void;
+  _onSessionDisconnected: (meta: DevframeNodeRpcSessionMeta) => void;
 }
 //#endregion
 //#region src/types/context.d.ts
-interface DevToolsCapabilities {
+interface DevframeCapabilities {
   rpc?: boolean;
   views?: boolean;
 }
@@ -832,7 +881,7 @@ interface DevToolsCapabilities {
  * `createKitContext` adds `docks`, `terminals`, `messages`, and
  * `commands` when mounted into Vite DevTools.
  */
-interface DevToolsNodeContext {
+interface DevframeNodeContext {
   readonly workspaceRoot: string;
   readonly cwd: string;
   /**
@@ -854,20 +903,20 @@ interface DevToolsNodeContext {
    * Host runtime abstraction — exposes `mountStatic` / `resolveOrigin` /
    * `getStorageDir`.
    */
-  host: DevToolsHost;
+  host: DevframeHost;
   rpc: RpcFunctionsHost;
-  views: DevToolsViewHost;
+  views: DevframeViewHost;
   /**
    * Structured diagnostics host — wraps `nostics` and lets integrations
    * register their own coded errors/warnings into the shared lookup.
    */
-  diagnostics: DevToolsDiagnosticsHost;
+  diagnostics: DevframeDiagnosticsHost;
   /**
    * Agent host — aggregates the agent-exposed surface of this devtool.
    *
    * @experimental
    */
-  agent: DevToolsAgentHost;
+  agent: DevframeAgentHost;
 }
 interface ConnectionMeta {
   backend: 'websocket' | 'static';
@@ -999,7 +1048,7 @@ interface DevframeDefinition {
     spa?: boolean | Record<string, boolean>;
   };
   /** Server-side setup — the primary entrypoint. Runs in every runtime. */
-  setup: (ctx: DevToolsNodeContext, info?: DevframeSetupInfo) => void | Promise<void>;
+  setup: (ctx: DevframeNodeContext, info?: DevframeSetupInfo) => void | Promise<void>;
   /** Browser-only setup for the SPA adapter (bundled into the client). */
   setupBrowser?: (ctx: DevframeBrowserContext) => void | Promise<void>;
   cli?: DevframeCliOptions;
@@ -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, DevframeRpcSharedStates as G, Thenable as H, SharedStateOptions as I, DevframeDiagnosticsDefinition as J, DevframeHost 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, DevframeRpcClientFunctions as U, PartialWithoutId as V, DevframeRpcServerFunctions as W, DevframeDiagnosticsLogger as X, DevframeDiagnosticsHost as Y, AgentHandle as Z, RpcStreamingChannel as _, DevframeRuntime as a, DevframeAgentHostEvents as at, BufferedChunk as b, defineDevframe as c, EventsMap as ct, DevframeNodeContext as d, defineCliFlags as dt, AgentResourceContent as et, DevframeNodeRpcSession as f, parseCliFlags as ft, RpcSharedStateHost as g, RpcSharedStateGetOptions as h, DevframeDeploymentKind as i, DevframeAgentHost 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, DevframeDefineDiagnosticsOptions as q, DevframeDefinition as r, AgentToolInput as rt, DevframeSpaOptions as s, EventUnsubscribe as st, DevframeBrowserContext as t, AgentResourceInput as tt, DevframeCapabilities as u, InferCliFlags as ut, RpcStreamingChannelOptions as v, StreamReader as w, CreateStreamReaderOptions as x, RpcStreamingHost as y, DevframeViewHost as z };

package/dist/{dump-B1wd4u68.mjs → dump-9lKIJTLh.mjs}

@@ -1,5 +1,5 @@
 import { t as diagnostics } from "./diagnostics-GitRGKbr.mjs";
-import { DEVTOOLS_RPC_DUMP_DIRNAME } from "./constants.mjs";
+import { DEVFRAME_RPC_DUMP_DIRNAME } from "./constants.mjs";
 import { createHash } from "node:crypto";
 //#region ../../node_modules/.pnpm/ohash@2.0.11/node_modules/ohash/dist/shared/ohash.D__AXeF1.mjs
 function serialize(o) {
@@ -498,14 +498,18 @@ function getDefinitionsWithDumps(definitions) {
 //#endregion
 //#region src/rpc/handler.ts
 async function getRpcResolvedSetupResult(definition, context) {
-	if (definition.__resolved) return definition.__resolved;
 	if (!definition.setup) return {};
-	definition.__promise ??= Promise.resolve(definition.setup(context)).then((r) => {
-		definition.__resolved = r;
-		definition.__promise = void 0;
-		return r;
-	});
-	return definition.__resolved ??= await definition.__promise;
+	if (typeof context === "object" && context !== null) {
+		definition.__cache ??= /* @__PURE__ */ new WeakMap();
+		let promise = definition.__cache.get(context);
+		if (!promise) {
+			promise = Promise.resolve(definition.setup(context));
+			definition.__cache.set(context, promise);
+		}
+		return await promise;
+	}
+	definition.__promise ??= Promise.resolve(definition.setup(context));
+	return await definition.__promise;
 }
 async function getRpcHandler(definition, context) {
 	if (definition.handler) return definition.handler;
@@ -519,13 +523,13 @@ function makeDumpKey(name) {
 	return encodeURIComponent(name.replaceAll(":", "~"));
 }
 function makeStaticPath(name) {
-	return `${DEVTOOLS_RPC_DUMP_DIRNAME}/${makeDumpKey(name)}.static.json`;
+	return `${DEVFRAME_RPC_DUMP_DIRNAME}/${makeDumpKey(name)}.static.json`;
 }
 function makeQueryRecordPath(name, hash) {
-	return `${DEVTOOLS_RPC_DUMP_DIRNAME}/${makeDumpKey(name)}.record.${hash}.json`;
+	return `${DEVFRAME_RPC_DUMP_DIRNAME}/${makeDumpKey(name)}.record.${hash}.json`;
 }
 function makeQueryFallbackPath(name) {
-	return `${DEVTOOLS_RPC_DUMP_DIRNAME}/${makeDumpKey(name)}.fallback.json`;
+	return `${DEVFRAME_RPC_DUMP_DIRNAME}/${makeDumpKey(name)}.fallback.json`;
 }
 async function resolveRecord(record) {
 	return typeof record === "function" ? await record() : record;

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-BuR6n9ZD.mjs";
 
 //#region src/helpers/vite.d.ts
 interface ViteDevBridgeOptions {

package/dist/helpers/vite.mjs

@@ -1,8 +1,8 @@
-import { DEVTOOLS_CONNECTION_META_FILENAME } from "../constants.mjs";
-import { i as diagnostics } from "../shared-state-CasqoUba.mjs";
+import { DEVFRAME_CONNECTION_META_FILENAME } from "../constants.mjs";
+import { i as diagnostics } from "../shared-state-BlBNYziY.mjs";
 import { n as resolveBasePath } from "../_shared-CUFqO4kJ.mjs";
 import { serveStaticNodeMiddleware } from "../utils/serve-static.mjs";
-import { n as resolveDevServerPort, t as createDevServer } from "../dev-C2wjXjGB.mjs";
+import { n as resolveDevServerPort, t as createDevServer } from "../dev-Cv43GfqM.mjs";
 import { resolve } from "pathe";
 //#region src/helpers/vite.ts
 /**
@@ -61,7 +61,7 @@ function viteDevBridge(d, options = {}) {
 				}, { method: "warn" });
 				return;
 			}
-			const metaPath = `${base}${DEVTOOLS_CONNECTION_META_FILENAME}`;
+			const metaPath = `${base}${DEVFRAME_CONNECTION_META_FILENAME}`;
 			server.middlewares.use(metaPath, (_req, res) => {
 				res.setHeader("Content-Type", "application/json");
 				res.end(JSON.stringify({

package/dist/{host-h3-Div5Vp8R.mjs → host-h3-Dgpgr1Ul.mjs}

@@ -2,7 +2,7 @@ import { t as devframeReporter } from "./diagnostics-reporter-CBBZwoMv.mjs";
 import { t as diagnostics } from "./diagnostics-GitRGKbr.mjs";
 import { RpcFunctionsCollectorBase } from "./rpc/index.mjs";
 import { defineRpcFunction } from "./index.mjs";
-import { i as diagnostics$1, n as nanoid, r as createEventEmitter, t as createSharedState } from "./shared-state-CasqoUba.mjs";
+import { i as diagnostics$1, n as nanoid, r as createEventEmitter, t as createSharedState } from "./shared-state-BlBNYziY.mjs";
 import { defineDiagnostics } from "nostics";
 import { isatty } from "node:tty";
 import { formatWithOptions, inspect } from "node:util";
@@ -19,7 +19,7 @@ import { join } from "pathe";
 *
 * @experimental
 */
-var DevToolsAgentHost = class {
+var DevframeAgentHost = class {
 	context;
 	events = createEventEmitter();
 	tools = /* @__PURE__ */ new Map();
@@ -184,7 +184,7 @@ function hasPositionalKeys(obj) {
 }
 //#endregion
 //#region src/node/host-diagnostics.ts
-var DevToolsDiagnosticsHost = class {
+var DevframeDiagnosticsHost = class {
 	context;
 	_registry = {};
 	logger = new Proxy({}, { get: (_, code) => this._registry[code] });
@@ -458,8 +458,8 @@ function createDebug(namespace, options) {
 enable(process.env.DEBUG || "");
 //#endregion
 //#region src/node/rpc-shared-state.ts
-const debug$1 = createDebug("vite:devtools:rpc:state:changed");
-const debugSubscribe = createDebug("vite:devtools:rpc:state:subscribe");
+const debug$1 = createDebug("devframe:rpc:state:changed");
+const debugSubscribe = createDebug("devframe:rpc:state:subscribe");
 function createRpcSharedStateServerHost(rpc) {
 	const sharedState = /* @__PURE__ */ new Map();
 	const keyAddedListeners = /* @__PURE__ */ new Set();
@@ -817,7 +817,7 @@ function toErrorPayload(reason) {
 }
 //#endregion
 //#region src/node/rpc-streaming.ts
-const debug = createDebug("vite:devtools:rpc:streaming");
+const debug = createDebug("devframe:rpc:streaming");
 const STREAM_KEY_SEPARATOR = "";
 function streamKey(channel, id) {
 	return `${channel}${STREAM_KEY_SEPARATOR}${id}`;
@@ -1117,7 +1117,7 @@ function createRpcStreamingServerHost(rpc) {
 }
 //#endregion
 //#region src/node/host-functions.ts
-const debugBroadcast = createDebug("vite:devtools:rpc:broadcast");
+const debugBroadcast = createDebug("devframe:rpc:broadcast");
 var RpcFunctionsHost = class extends RpcFunctionsCollectorBase {
 	/**
 	* @internal
@@ -1165,7 +1165,7 @@ var RpcFunctionsHost = class extends RpcFunctionsCollectorBase {
 };
 //#endregion
 //#region src/node/host-views.ts
-var DevToolsViewHost = class {
+var DevframeViewHost = class {
 	context;
 	/**
 	* @internal
@@ -1242,7 +1242,7 @@ const BUILTIN_AGENT_RPC = [
 //#endregion
 //#region src/node/context.ts
 /**
-* 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
@@ -1262,12 +1262,12 @@ async function createHostContext(options) {
 		agent: void 0
 	};
 	const rpcHost = new RpcFunctionsHost(context);
-	const viewsHost = new DevToolsViewHost(context);
-	const diagnosticsHost = new DevToolsDiagnosticsHost(context, [diagnostics$1, diagnostics]);
+	const viewsHost = new DevframeViewHost(context);
+	const diagnosticsHost = new DevframeDiagnosticsHost(context, [diagnostics$1, diagnostics]);
 	context.rpc = rpcHost;
 	context.views = viewsHost;
 	context.diagnostics = diagnosticsHost;
-	context.agent = new DevToolsAgentHost(context);
+	context.agent = new DevframeAgentHost(context);
 	for (const fn of BUILTIN_AGENT_RPC) rpcHost.register(fn);
 	for (const fn of builtinRpcDeclarations) rpcHost.register(fn);
 	return context;
@@ -1275,9 +1275,9 @@ async function createHostContext(options) {
 //#endregion
 //#region src/node/host-h3.ts
 /**
-* h3-backed {@link DevToolsHost} — used by the standalone CLI adapter.
+* h3-backed {@link DevframeHost} — used by the standalone CLI adapter.
 */
-function createH3DevToolsHost(options) {
+function createH3DevframeHost(options) {
 	const workspaceRoot = options.workspaceRoot ?? process$1.cwd();
 	return {
 		mountStatic(base, distDir) {
@@ -1287,10 +1287,10 @@ function createH3DevToolsHost(options) {
 			return options.origin;
 		},
 		getStorageDir(scope) {
-			const namespace = `.${options.appName}/devtools`;
+			const namespace = `.${options.appName}/devframe`;
 			return scope === "workspace" ? join(workspaceRoot, "node_modules", namespace) : join(homedir(), namespace);
 		}
 	};
 }
 //#endregion
-export { createRpcStreamingServerHost as a, DevToolsAgentHost as c, RpcFunctionsHost as i, createHostContext as n, createRpcSharedStateServerHost as o, DevToolsViewHost as r, DevToolsDiagnosticsHost as s, createH3DevToolsHost as t };
+export { createRpcStreamingServerHost as a, DevframeAgentHost as c, RpcFunctionsHost as i, createHostContext as n, createRpcSharedStateServerHost as o, DevframeViewHost as r, DevframeDiagnosticsHost as s, createH3DevframeHost as t };

package/dist/{index-CTK6fuXs.d.mts → index-C7M1hnvL.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-BkkQ0Txg.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-DH2sBIwd.mjs";
 
 //#region src/rpc/cache.d.ts
 interface RpcCacheOptions {

package/dist/{index-C5PmWqBf.d.mts → index-DH2sBIwd.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-BkkQ0Txg.mjs";
 
 //#region src/rpc/dump/static.d.ts
 type StaticRpcDumpSerialization = 'json' | 'structured-clone';

package/dist/index.d.mts

@@ -1,8 +1,8 @@
-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 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 { S as RpcFunctionType, g as RpcFunctionDefinition, h as RpcFunctionAgentOptions, i as RpcArgsSchema, w as RpcReturnSchema } from "./types-BkkQ0Txg.mjs";
+import { t as DevframeNodeRpcSessionMeta } from "./ws-server-C1LjmRnp.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>;
+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, DevframeNodeContext>) => RpcFunctionDefinition<NAME, TYPE, ARGS, RETURN, AS, RS, DevframeNodeContext>;
 //#endregion
-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, defineRpcFunction };
+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, defineRpcFunction };

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 DevframeNodeContext, f as DevframeNodeRpcSession } from "../devframe-BuR6n9ZD.mjs";
+import { n as InternalAnonymousAuthStorage } from "../context-DTRcO_UH.mjs";
 
 //#region src/node/auth/revoke.d.ts
 /**
@@ -8,17 +8,17 @@ import { n as InternalAnonymousAuthStorage } from "../context-Ca70YtrW.mjs";
  *
  * Shared between persisted-auth revocation and remote-dock token revocation.
  */
-declare function revokeActiveConnectionsForToken(context: DevToolsNodeContext, token: string): Promise<void>;
+declare function revokeActiveConnectionsForToken(context: DevframeNodeContext, token: string): Promise<void>;
 /**
  * Revoke an auth token: remove from storage and notify all connected clients
  * using this token that they are no longer trusted.
  */
-declare function revokeAuthToken(context: DevToolsNodeContext, storage: SharedState<InternalAnonymousAuthStorage>, token: string): Promise<void>;
+declare function revokeAuthToken(context: DevframeNodeContext, storage: SharedState<InternalAnonymousAuthStorage>, token: string): Promise<void>;
 //#endregion
 //#region src/node/auth/state.d.ts
 interface PendingAuthRequest {
   clientAuthToken: string;
-  session: DevToolsNodeRpcSession;
+  session: DevframeNodeRpcSession;
   ua: string;
   origin: string;
   resolve: (result: {

package/dist/node/auth.mjs

@@ -1,4 +1,4 @@
-import { n as revokeActiveConnectionsForToken, r as revokeAuthToken, t as humanId } from "../human-id-Dq-qgtES.mjs";
+import { n as revokeAuthToken, r as humanId, t as revokeActiveConnectionsForToken } from "../revoke-CL0LSAN9.mjs";
 //#region src/node/auth/state.ts
 let pendingAuth = null;
 let tempAuthToken = generateTempId();