devframe 0.4.1 → 0.5.0

package/README.md

@@ -6,7 +6,7 @@
 [![JSDocs][jsdocs-src]][jsdocs-href]
 [![License][license-src]][license-href]
 
-Framework-neutral foundation for building generic DevTools.
+Framework-neutral foundation for building generic devframes.
 
 Documentation: [https://devfra.me/](https://devfra.me/).
 

package/dist/adapters/build.d.mts

@@ -1,4 +1,4 @@
-import { r as DevframeDefinition } from "../devframe-K4IxpM4a.mjs";
+import { r as DevframeDefinition } from "../devframe-BuR6n9ZD.mjs";
 
 //#region src/adapters/build.d.ts
 interface CreateBuildOptions {
@@ -30,7 +30,7 @@ interface CreateBuildOptions {
  *   - When `def.spa` is configured, also write `<outDir>/spa-loader.json`
  *     describing the SPA's data-loader mode (`'query'` / `'upload'` /
  *     `'none'`). The output is mount-path agnostic — the same bundle
- *     works at `/`, `/devtools/`, or any base, no rewriting required.
+ *     works at `/`, `/devframe/`, or any base, no rewriting required.
  */
 declare function createBuild(d: DevframeDefinition, options?: CreateBuildOptions): Promise<void>;
 //#endregion

package/dist/adapters/build.mjs

@@ -1,9 +1,9 @@
-import { t as collectStaticRpcDump } from "../dump-B1wd4u68.mjs";
+import { t as collectStaticRpcDump } from "../dump-9lKIJTLh.mjs";
 import { n as colors } from "../diagnostics-reporter-CBBZwoMv.mjs";
-import { DEVTOOLS_CONNECTION_META_FILENAME, DEVTOOLS_RPC_DUMP_DIRNAME, DEVTOOLS_RPC_DUMP_MANIFEST_FILENAME } from "../constants.mjs";
+import { DEVFRAME_CONNECTION_META_FILENAME, DEVFRAME_RPC_DUMP_DIRNAME, DEVFRAME_RPC_DUMP_MANIFEST_FILENAME } from "../constants.mjs";
 import { n as strictJsonStringify } from "../serialization-BD_qXGjd.mjs";
 import { n as structuredCloneStringify } from "../structured-clone-jegjz0hM.mjs";
-import { n as createHostContext, t as createH3DevToolsHost } from "../host-h3-Div5Vp8R.mjs";
+import { n as createHostContext, t as createH3DevframeHost } from "../host-h3-Dgpgr1Ul.mjs";
 import { n as resolveBasePath } from "../_shared-CUFqO4kJ.mjs";
 import { existsSync } from "node:fs";
 import process from "node:process";
@@ -21,7 +21,7 @@ import fs$1 from "node:fs/promises";
 *   - When `def.spa` is configured, also write `<outDir>/spa-loader.json`
 *     describing the SPA's data-loader mode (`'query'` / `'upload'` /
 *     `'none'`). The output is mount-path agnostic — the same bundle
-*     works at `/`, `/devtools/`, or any base, no rewriting required.
+*     works at `/`, `/devframe/`, or any base, no rewriting required.
 */
 async function createBuild(d, options = {}) {
 	const outDir = resolve(options.outDir ?? "dist-static");
@@ -34,20 +34,20 @@ async function createBuild(d, options = {}) {
 	const ctx = await createHostContext({
 		cwd: process.cwd(),
 		mode: "build",
-		host: createH3DevToolsHost({
+		host: createH3DevframeHost({
 			origin: "http://localhost",
 			appName: d.id
 		})
 	});
 	await d.setup(ctx);
-	await fs$1.mkdir(resolve(outDir, DEVTOOLS_RPC_DUMP_DIRNAME), { recursive: true });
+	await fs$1.mkdir(resolve(outDir, DEVFRAME_RPC_DUMP_DIRNAME), { recursive: true });
 	const jsonSerializableMethods = [];
 	for (const def of ctx.rpc.definitions.values()) if (def.jsonSerializable === true) jsonSerializableMethods.push(def.name);
-	await fs$1.writeFile(resolve(outDir, DEVTOOLS_CONNECTION_META_FILENAME), JSON.stringify({
+	await fs$1.writeFile(resolve(outDir, DEVFRAME_CONNECTION_META_FILENAME), JSON.stringify({
 		backend: "static",
 		jsonSerializableMethods
 	}, null, 2), "utf-8");
-	console.log(colors.cyan`[devframe] writing RPC dump to ${resolve(outDir, DEVTOOLS_RPC_DUMP_MANIFEST_FILENAME)}`);
+	console.log(colors.cyan`[devframe] writing RPC dump to ${resolve(outDir, DEVFRAME_RPC_DUMP_MANIFEST_FILENAME)}`);
 	const dump = await collectStaticRpcDump(ctx.rpc.definitions.values(), ctx);
 	const indent = options.pretty ? 2 : void 0;
 	for (const [filepath, file] of Object.entries(dump.files)) {
@@ -56,7 +56,7 @@ async function createBuild(d, options = {}) {
 		const text = file.serialization === "structured-clone" ? structuredCloneStringify(file.data) : strictJsonStringify(file.data, file.fnName);
 		await fs$1.writeFile(fullpath, file.serialization === "json" && indent != null ? JSON.stringify(JSON.parse(text), null, indent) : text, "utf-8");
 	}
-	await fs$1.writeFile(resolve(outDir, DEVTOOLS_RPC_DUMP_MANIFEST_FILENAME), JSON.stringify(dump.manifest, null, 2), "utf-8");
+	await fs$1.writeFile(resolve(outDir, DEVFRAME_RPC_DUMP_MANIFEST_FILENAME), JSON.stringify(dump.manifest, null, 2), "utf-8");
 	if (d.spa) {
 		const base = options.base ?? resolveBasePath(d, "standalone");
 		const spaLoader = {

package/dist/adapters/cli.d.mts

@@ -1,4 +1,4 @@
-import { dt as defineCliFlags, ft as parseCliFlags, lt as CliFlagsSchema, r as DevframeDefinition, ut as InferCliFlags } from "../devframe-K4IxpM4a.mjs";
+import { dt as defineCliFlags, ft as parseCliFlags, lt as CliFlagsSchema, r as DevframeDefinition, ut as InferCliFlags } from "../devframe-BuR6n9ZD.mjs";
 import { CAC } from "cac";
 import { H3 } from "h3";
 

package/dist/adapters/cli.mjs

@@ -1,6 +1,6 @@
 import { n as colors } from "../diagnostics-reporter-CBBZwoMv.mjs";
 import { createBuild } from "./build.mjs";
-import { n as resolveDevServerPort, t as createDevServer } from "../dev-C2wjXjGB.mjs";
+import { n as resolveDevServerPort, t as createDevServer } from "../dev-Cv43GfqM.mjs";
 import process from "node:process";
 import cac from "cac";
 import { safeParse } from "valibot";

package/dist/adapters/dev.d.mts

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

package/dist/adapters/dev.mjs

@@ -1,2 +1,2 @@
-import { n as resolveDevServerPort, t as createDevServer } from "../dev-C2wjXjGB.mjs";
+import { n as resolveDevServerPort, t as createDevServer } from "../dev-Cv43GfqM.mjs";
 export { createDevServer, resolveDevServerPort };

package/dist/adapters/embedded.d.mts

@@ -1,9 +1,9 @@
-import { d as DevToolsNodeContext, r as DevframeDefinition } from "../devframe-K4IxpM4a.mjs";
+import { d as DevframeNodeContext, r as DevframeDefinition } from "../devframe-BuR6n9ZD.mjs";
 
 //#region src/adapters/embedded.d.ts
 interface CreateEmbeddedOptions {
   /** Target context the devframe is registered into. Required. */
-  ctx: DevToolsNodeContext;
+  ctx: DevframeNodeContext;
 }
 /**
  * Register a devframe into an already-running devframe/Kit context at

package/dist/adapters/mcp.d.mts

@@ -1,4 +1,4 @@
-import { r as DevframeDefinition } from "../devframe-K4IxpM4a.mjs";
+import { r as DevframeDefinition } from "../devframe-BuR6n9ZD.mjs";
 //#region src/adapters/mcp/build-server.d.ts
 interface CreateMcpServerOptions {
   /**

package/dist/adapters/mcp.mjs

@@ -1,5 +1,5 @@
-import { i as diagnostics } from "../shared-state-CasqoUba.mjs";
-import { n as createHostContext } from "../host-h3-Div5Vp8R.mjs";
+import { i as diagnostics } from "../shared-state-BlBNYziY.mjs";
+import { n as createHostContext } from "../host-h3-Dgpgr1Ul.mjs";
 import { homedir } from "node:os";
 import process from "node:process";
 import { join } from "pathe";
@@ -195,7 +195,7 @@ async function createMcpServer(definition, options = {}) {
 		host: {
 			mountStatic: () => {},
 			resolveOrigin: () => "mcp://devframe",
-			getStorageDir: (scope) => scope === "workspace" ? join(process.cwd(), `node_modules/.${definition.id}/devtools`) : join(homedir(), `.${definition.id}/devtools`)
+			getStorageDir: (scope) => scope === "workspace" ? join(process.cwd(), `node_modules/.${definition.id}/devframe`) : join(homedir(), `.${definition.id}/devframe`)
 		}
 	});
 	await definition.setup(ctx);

package/dist/client/index.d.mts

@@ -1,7 +1,7 @@
-import { T as StreamSink, U as DevToolsRpcClientFunctions, W as DevToolsRpcServerFunctions, g as RpcSharedStateHost, l as ConnectionMeta, ot as EventEmitter, w as StreamReader } from "../devframe-K4IxpM4a.mjs";
-import { C as RpcFunctionsCollector } from "../types-dNW3UmMl.mjs";
-import { C as RpcCacheManager, w as RpcCacheOptions } from "../index-CBSBvT9K.mjs";
-import { t as WsRpcChannelOptions } from "../ws-client-BZptK_Mf.mjs";
+import { T as StreamSink, U as DevframeRpcClientFunctions, W as DevframeRpcServerFunctions, g as RpcSharedStateHost, l as ConnectionMeta, ot as EventEmitter, w as StreamReader } from "../devframe-BuR6n9ZD.mjs";
+import { C as RpcFunctionsCollector } from "../types-BkkQ0Txg.mjs";
+import { C as RpcCacheManager, w as RpcCacheOptions } from "../index-C7M1hnvL.mjs";
+import { t as WsRpcChannelOptions } from "../ws-client-CVYX9niP.mjs";
 import { BirpcOptions, BirpcReturn } from "birpc";
 
 //#region src/client/rpc-streaming.d.ts
@@ -32,20 +32,20 @@ interface RpcStreamingClientHost {
  * registers the two `:chunk` / `:end` event handlers once, then per-stream
  * state lives in a `Map<streamKey, StreamReader>`.
  */
-declare function createRpcStreamingClientHost(rpc: DevToolsRpcClient): RpcStreamingClientHost;
+declare function createRpcStreamingClientHost(rpc: DevframeRpcClient): RpcStreamingClientHost;
 //#endregion
 //#region src/client/rpc.d.ts
-interface DevToolsRpcContext {
+interface DevframeRpcContext {
   /**
    * The RPC client to interact with the server
    */
-  readonly rpc: DevToolsRpcClient;
+  readonly rpc: DevframeRpcClient;
 }
-type DevToolsClientRpcHost = RpcFunctionsCollector<DevToolsRpcClientFunctions, DevToolsRpcContext>;
+type DevframeClientRpcHost = RpcFunctionsCollector<DevframeRpcClientFunctions, DevframeRpcContext>;
 interface RpcClientEvents {
   'rpc:is-trusted:updated': (isTrusted: boolean) => void;
 }
-interface DevToolsRpcClientOptions {
+interface DevframeRpcClientOptions {
   connectionMeta?: ConnectionMeta;
   baseURL?: string | string[];
   /**
@@ -53,13 +53,13 @@ interface DevToolsRpcClientOptions {
    */
   authToken?: string;
   wsOptions?: Partial<WsRpcChannelOptions>;
-  rpcOptions?: Partial<BirpcOptions<DevToolsRpcServerFunctions, DevToolsRpcClientFunctions, boolean>>;
+  rpcOptions?: Partial<BirpcOptions<DevframeRpcServerFunctions, DevframeRpcClientFunctions, boolean>>;
   cacheOptions?: boolean | Partial<RpcCacheOptions>;
 }
-type DevToolsRpcClientCall = BirpcReturn<DevToolsRpcServerFunctions, DevToolsRpcClientFunctions>['$call'];
-type DevToolsRpcClientCallEvent = BirpcReturn<DevToolsRpcServerFunctions, DevToolsRpcClientFunctions>['$callEvent'];
-type DevToolsRpcClientCallOptional = BirpcReturn<DevToolsRpcServerFunctions, DevToolsRpcClientFunctions>['$callOptional'];
-interface DevToolsRpcClient {
+type DevframeRpcClientCall = BirpcReturn<DevframeRpcServerFunctions, DevframeRpcClientFunctions>['$call'];
+type DevframeRpcClientCallEvent = BirpcReturn<DevframeRpcServerFunctions, DevframeRpcClientFunctions>['$callEvent'];
+type DevframeRpcClientCallOptional = BirpcReturn<DevframeRpcServerFunctions, DevframeRpcClientFunctions>['$callOptional'];
+interface DevframeRpcClient {
   /**
    * The events of the client
    */
@@ -92,19 +92,19 @@ interface DevToolsRpcClient {
   /**
    * Call a RPC function on the server
    */
-  call: DevToolsRpcClientCall;
+  call: DevframeRpcClientCall;
   /**
    * Call a RPC event on the server, and does not expect a response
    */
-  callEvent: DevToolsRpcClientCallEvent;
+  callEvent: DevframeRpcClientCallEvent;
   /**
    * Call a RPC optional function on the server
    */
-  callOptional: DevToolsRpcClientCallOptional;
+  callOptional: DevframeRpcClientCallOptional;
   /**
    * The client RPC host
    */
-  client: DevToolsClientRpcHost;
+  client: DevframeClientRpcHost;
   /**
    * The shared state host
    */
@@ -120,18 +120,18 @@ interface DevToolsRpcClient {
    */
   cacheManager: RpcCacheManager;
 }
-interface DevToolsRpcClientMode {
+interface DevframeRpcClientMode {
   readonly isTrusted: boolean;
-  ensureTrusted: DevToolsRpcClient['ensureTrusted'];
-  requestTrust: DevToolsRpcClient['requestTrust'];
-  requestTrustWithToken: DevToolsRpcClient['requestTrustWithToken'];
-  call: DevToolsRpcClient['call'];
-  callEvent: DevToolsRpcClient['callEvent'];
-  callOptional: DevToolsRpcClient['callOptional'];
+  ensureTrusted: DevframeRpcClient['ensureTrusted'];
+  requestTrust: DevframeRpcClient['requestTrust'];
+  requestTrustWithToken: DevframeRpcClient['requestTrustWithToken'];
+  call: DevframeRpcClient['call'];
+  callEvent: DevframeRpcClient['callEvent'];
+  callOptional: DevframeRpcClient['callOptional'];
 }
-declare function getDevToolsRpcClient(options?: DevToolsRpcClientOptions): Promise<DevToolsRpcClient>;
+declare function getDevframeRpcClient(options?: DevframeRpcClientOptions): Promise<DevframeRpcClient>;
 //#endregion
 //#region src/client/index.d.ts
-declare const connectDevframe: typeof getDevToolsRpcClient;
+declare const connectDevframe: typeof getDevframeRpcClient;
 //#endregion
-export { DevToolsClientRpcHost, DevToolsRpcClient, DevToolsRpcClientCall, DevToolsRpcClientCallEvent, DevToolsRpcClientCallOptional, DevToolsRpcClientMode, DevToolsRpcClientOptions, DevToolsRpcContext, RpcClientEvents, RpcStreamingClientHost, StreamingSubscribeOptions, connectDevframe, createRpcStreamingClientHost, getDevToolsRpcClient };
+export { DevframeClientRpcHost, DevframeRpcClient, DevframeRpcClientCall, DevframeRpcClientCallEvent, DevframeRpcClientCallOptional, DevframeRpcClientMode, DevframeRpcClientOptions, DevframeRpcContext, RpcClientEvents, RpcStreamingClientHost, StreamingSubscribeOptions, connectDevframe, createRpcStreamingClientHost, getDevframeRpcClient };

package/dist/client/index.mjs

@@ -10,8 +10,8 @@ import { defineDiagnostics } from "nostics";
 import { ansiFormatter } from "nostics/formatters/ansi";
 import { createBirpc } from "birpc";
 //#region src/constants.ts
-const DEVTOOLS_CONNECTION_META_FILENAME = "__connection.json";
-const DEVTOOLS_RPC_DUMP_MANIFEST_FILENAME = "__rpc-dump/index.json";
+const DEVFRAME_CONNECTION_META_FILENAME = "__connection.json";
+const DEVFRAME_RPC_DUMP_MANIFEST_FILENAME = "__rpc-dump/index.json";
 //#endregion
 //#region src/utils/diagnostics-reporter.ts
 const formatAnsi = ansiFormatter(colors);
@@ -71,14 +71,18 @@ function isPlainErrorShape(value) {
 //#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;
@@ -378,10 +382,10 @@ function createStaticRpcCaller(manifest, fetchJson) {
 		return await queryRecordCache.get(path);
 	}
 	async function call(functionName, args) {
-		if (!(functionName in manifest)) throw new Error(`[devtools-rpc] Function "${functionName}" not found in dump store`);
+		if (!(functionName in manifest)) throw new Error(`[devframe-rpc] Function "${functionName}" not found in dump store`);
 		const entry = manifest[functionName];
 		if (isStaticEntry(entry)) {
-			if (args.length > 0) throw new Error(`[devtools-rpc] No dump match for "${functionName}" with args: ${JSON.stringify(args)}`);
+			if (args.length > 0) throw new Error(`[devframe-rpc] No dump match for "${functionName}" with args: ${JSON.stringify(args)}`);
 			return await loadStatic(entry);
 		}
 		if (isQueryEntry(entry)) {
@@ -389,10 +393,10 @@ function createStaticRpcCaller(manifest, fetchJson) {
 			const recordPath = entry.records[argsHash];
 			if (recordPath) return resolveRecordOutput(await loadQueryRecord(recordPath, entry.serialization));
 			if (entry.fallback) return resolveRecordOutput(await loadQueryRecord(entry.fallback, entry.serialization));
-			throw new Error(`[devtools-rpc] No dump match for "${functionName}" with args: ${JSON.stringify(args)}`);
+			throw new Error(`[devframe-rpc] No dump match for "${functionName}" with args: ${JSON.stringify(args)}`);
 		}
 		if (args.length === 0) return entry;
-		throw new Error(`[devtools-rpc] No dump match for "${functionName}" with args: ${JSON.stringify(args)}`);
+		throw new Error(`[devframe-rpc] No dump match for "${functionName}" with args: ${JSON.stringify(args)}`);
 	}
 	return {
 		call: async (functionName, args) => await call(functionName, args),
@@ -406,7 +410,7 @@ function createStaticRpcCaller(manifest, fetchJson) {
 //#endregion
 //#region src/client/rpc-static.ts
 async function createStaticRpcClientMode(options) {
-	const staticCaller = createStaticRpcCaller(await options.fetchJsonFromBases(DEVTOOLS_RPC_DUMP_MANIFEST_FILENAME), options.fetchJsonFromBases);
+	const staticCaller = createStaticRpcCaller(await options.fetchJsonFromBases(DEVFRAME_RPC_DUMP_MANIFEST_FILENAME), options.fetchJsonFromBases);
 	return {
 		isTrusted: true,
 		requestTrust: async () => true,
@@ -539,7 +543,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) => {
@@ -1789,7 +1793,7 @@ function createWsRpcClientMode(options) {
 			info.os.version,
 			info.device.type
 		].filter((i) => i).join(" ");
-		const result = await serverRpc.$call("vite:anonymous:auth", {
+		const result = await serverRpc.$call("devframe:anonymous:auth", {
 			authToken: token,
 			ua,
 			origin: location.origin
@@ -1835,8 +1839,8 @@ function createWsRpcClientMode(options) {
 }
 //#endregion
 //#region src/client/rpc.ts
-const CONNECTION_META_KEY = "__VITE_DEVTOOLS_CONNECTION_META__";
-const CONNECTION_AUTH_TOKEN_KEY = "__VITE_DEVTOOLS_CONNECTION_AUTH_TOKEN__";
+const CONNECTION_META_KEY = "__DEVFRAME_CONNECTION_META__";
+const CONNECTION_AUTH_TOKEN_KEY = "__DEVFRAME_CONNECTION_AUTH_TOKEN__";
 function getConnectionAuthTokenFromWindows(userAuthToken) {
 	const getters = [
 		() => userAuthToken,
@@ -1866,7 +1870,7 @@ function findConnectionMetaFromWindows() {
 		if (value) return value;
 	} catch {}
 }
-async function getDevToolsRpcClient(options = {}) {
+async function getDevframeRpcClient(options = {}) {
 	const { baseURL = "./", rpcOptions = {}, cacheOptions = false } = options;
 	const events = createEventEmitter();
 	const bases = Array.isArray(baseURL) ? baseURL : [baseURL];
@@ -1883,7 +1887,7 @@ async function getDevToolsRpcClient(options = {}) {
 	if (!connectionMeta) {
 		const errors = [];
 		for (const base of bases) try {
-			connectionMeta = await fetch(resolveBasePath(base, DEVTOOLS_CONNECTION_META_FILENAME)).then((r) => r.json());
+			connectionMeta = await fetch(resolveBasePath(base, DEVFRAME_CONNECTION_META_FILENAME)).then((r) => r.json());
 			resolvedBaseURL = base;
 			globalThis[CONNECTION_META_KEY] = connectionMeta;
 			break;
@@ -1959,7 +1963,7 @@ async function getDevToolsRpcClient(options = {}) {
 	context.rpc = rpc;
 	mode.requestTrust();
 	try {
-		const bc = new BroadcastChannel("vite-devtools-auth");
+		const bc = new BroadcastChannel("devframe-auth");
 		bc.onmessage = (event) => {
 			if (event.data?.type === "auth-update" && event.data.authToken) rpc.requestTrustWithToken(event.data.authToken);
 		};
@@ -1968,6 +1972,6 @@ async function getDevToolsRpcClient(options = {}) {
 }
 //#endregion
 //#region src/client/index.ts
-const connectDevframe = getDevToolsRpcClient;
+const connectDevframe = getDevframeRpcClient;
 //#endregion
-export { connectDevframe, createRpcStreamingClientHost, getDevToolsRpcClient };
+export { connectDevframe, createRpcStreamingClientHost, getDevframeRpcClient };

package/dist/constants.d.mts

@@ -1,17 +1,17 @@
 //#region src/constants.d.ts
-declare const DEVTOOLS_MOUNT_PATH = "/__devtools/";
-declare const DEVTOOLS_MOUNT_PATH_NO_TRAILING_SLASH = "/__devtools";
-declare const DEVTOOLS_DIRNAME = "__devtools";
-declare const DEVTOOLS_CONNECTION_META_FILENAME = "__connection.json";
-declare const DEVTOOLS_RPC_DUMP_MANIFEST_FILENAME = "__rpc-dump/index.json";
-declare const DEVTOOLS_DOCK_IMPORTS_FILENAME = "__client-imports.js";
-declare const DEVTOOLS_DOCK_IMPORTS_VIRTUAL_ID = "/__devtools-client-imports.js";
-declare const DEVTOOLS_RPC_DUMP_DIRNAME = "__rpc-dump";
+declare const DEVFRAME_MOUNT_PATH = "/__devframe/";
+declare const DEVFRAME_MOUNT_PATH_NO_TRAILING_SLASH = "/__devframe";
+declare const DEVFRAME_DIRNAME = "__devframe";
+declare const DEVFRAME_CONNECTION_META_FILENAME = "__connection.json";
+declare const DEVFRAME_RPC_DUMP_MANIFEST_FILENAME = "__rpc-dump/index.json";
+declare const DEVFRAME_DOCK_IMPORTS_FILENAME = "__client-imports.js";
+declare const DEVFRAME_DOCK_IMPORTS_VIRTUAL_ID = "/__devframe-client-imports.js";
+declare const DEVFRAME_RPC_DUMP_DIRNAME = "__rpc-dump";
 /**
  * URL fragment / query parameter name carrying the remote dock
  * connection descriptor (defined as `RemoteConnectionInfo` in
  * `@vitejs/devtools-kit`) injected into remote-UI iframe dock URLs.
  */
-declare const REMOTE_CONNECTION_KEY = "vite-devtools-kit-connection";
+declare const REMOTE_CONNECTION_KEY = "devframe-remote-connection";
 //#endregion
-export { DEVTOOLS_CONNECTION_META_FILENAME, DEVTOOLS_DIRNAME, DEVTOOLS_DOCK_IMPORTS_FILENAME, DEVTOOLS_DOCK_IMPORTS_VIRTUAL_ID, DEVTOOLS_MOUNT_PATH, DEVTOOLS_MOUNT_PATH_NO_TRAILING_SLASH, DEVTOOLS_RPC_DUMP_DIRNAME, DEVTOOLS_RPC_DUMP_MANIFEST_FILENAME, REMOTE_CONNECTION_KEY };
+export { DEVFRAME_CONNECTION_META_FILENAME, DEVFRAME_DIRNAME, DEVFRAME_DOCK_IMPORTS_FILENAME, DEVFRAME_DOCK_IMPORTS_VIRTUAL_ID, DEVFRAME_MOUNT_PATH, DEVFRAME_MOUNT_PATH_NO_TRAILING_SLASH, DEVFRAME_RPC_DUMP_DIRNAME, DEVFRAME_RPC_DUMP_MANIFEST_FILENAME, REMOTE_CONNECTION_KEY };

package/dist/constants.mjs

@@ -1,17 +1,17 @@
 //#region src/constants.ts
-const DEVTOOLS_MOUNT_PATH = "/__devtools/";
-const DEVTOOLS_MOUNT_PATH_NO_TRAILING_SLASH = "/__devtools";
-const DEVTOOLS_DIRNAME = "__devtools";
-const DEVTOOLS_CONNECTION_META_FILENAME = "__connection.json";
-const DEVTOOLS_RPC_DUMP_MANIFEST_FILENAME = "__rpc-dump/index.json";
-const DEVTOOLS_DOCK_IMPORTS_FILENAME = "__client-imports.js";
-const DEVTOOLS_DOCK_IMPORTS_VIRTUAL_ID = "/__devtools-client-imports.js";
-const DEVTOOLS_RPC_DUMP_DIRNAME = "__rpc-dump";
+const DEVFRAME_MOUNT_PATH = "/__devframe/";
+const DEVFRAME_MOUNT_PATH_NO_TRAILING_SLASH = "/__devframe";
+const DEVFRAME_DIRNAME = "__devframe";
+const DEVFRAME_CONNECTION_META_FILENAME = "__connection.json";
+const DEVFRAME_RPC_DUMP_MANIFEST_FILENAME = "__rpc-dump/index.json";
+const DEVFRAME_DOCK_IMPORTS_FILENAME = "__client-imports.js";
+const DEVFRAME_DOCK_IMPORTS_VIRTUAL_ID = "/__devframe-client-imports.js";
+const DEVFRAME_RPC_DUMP_DIRNAME = "__rpc-dump";
 /**
 * URL fragment / query parameter name carrying the remote dock
 * connection descriptor (defined as `RemoteConnectionInfo` in
 * `@vitejs/devtools-kit`) injected into remote-UI iframe dock URLs.
 */
-const REMOTE_CONNECTION_KEY = "vite-devtools-kit-connection";
+const REMOTE_CONNECTION_KEY = "devframe-remote-connection";
 //#endregion
-export { DEVTOOLS_CONNECTION_META_FILENAME, DEVTOOLS_DIRNAME, DEVTOOLS_DOCK_IMPORTS_FILENAME, DEVTOOLS_DOCK_IMPORTS_VIRTUAL_ID, DEVTOOLS_MOUNT_PATH, DEVTOOLS_MOUNT_PATH_NO_TRAILING_SLASH, DEVTOOLS_RPC_DUMP_DIRNAME, DEVTOOLS_RPC_DUMP_MANIFEST_FILENAME, REMOTE_CONNECTION_KEY };
+export { DEVFRAME_CONNECTION_META_FILENAME, DEVFRAME_DIRNAME, DEVFRAME_DOCK_IMPORTS_FILENAME, DEVFRAME_DOCK_IMPORTS_VIRTUAL_ID, DEVFRAME_MOUNT_PATH, DEVFRAME_MOUNT_PATH_NO_TRAILING_SLASH, DEVFRAME_RPC_DUMP_DIRNAME, DEVFRAME_RPC_DUMP_MANIFEST_FILENAME, REMOTE_CONNECTION_KEY };

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

@@ -1,6 +1,6 @@
-import { P as SharedState, d as DevToolsNodeContext } from "./devframe-K4IxpM4a.mjs";
+import { P as SharedState, d as DevframeNodeContext } from "./devframe-BuR6n9ZD.mjs";
 
-//#region src/node/internal/context.d.ts
+//#region src/node/hub-internals/context.d.ts
 interface InternalAnonymousAuthStorage {
   trusted: Record<string, {
     authToken: string;
@@ -15,7 +15,7 @@ interface RemoteTokenRecord {
   origin: string;
   originLock: boolean;
 }
-interface DevToolsInternalContext {
+interface DevframeInternalContext {
   storage: {
     auth: SharedState<InternalAnonymousAuthStorage>;
   };
@@ -45,7 +45,7 @@ interface DevToolsInternalContext {
     /** Full `ws://` or `wss://` URL with host and port. */url: string;
   };
 }
-declare const internalContextMap: WeakMap<DevToolsNodeContext, DevToolsInternalContext>;
-declare function getInternalContext(context: DevToolsNodeContext): DevToolsInternalContext;
+declare const internalContextMap: WeakMap<DevframeNodeContext, DevframeInternalContext>;
+declare function getInternalContext(context: DevframeNodeContext): DevframeInternalContext;
 //#endregion
-export { internalContextMap as a, getInternalContext as i, InternalAnonymousAuthStorage as n, RemoteTokenRecord as r, DevToolsInternalContext as t };
+export { internalContextMap as a, getInternalContext as i, InternalAnonymousAuthStorage as n, RemoteTokenRecord as r, DevframeInternalContext as t };

package/dist/{storage-CZVTPKsw.mjs → context-DaKmhhHY.mjs}

@@ -1,6 +1,7 @@
-import { i as diagnostics, t as createSharedState } from "./shared-state-CasqoUba.mjs";
+import { i as diagnostics, t as createSharedState } from "./shared-state-BlBNYziY.mjs";
+import { n as revokeAuthToken, r as humanId, t as revokeActiveConnectionsForToken } from "./revoke-CL0LSAN9.mjs";
 import fs from "node:fs";
-import { dirname } from "pathe";
+import { dirname, join } from "pathe";
 //#region ../../node_modules/.pnpm/perfect-debounce@2.1.0/node_modules/perfect-debounce/dist/index.mjs
 const DEBOUNCE_DEFAULTS = { trailing: true };
 /**
@@ -116,4 +117,48 @@ function createStorage(options) {
 	return state;
 }
 //#endregion
-export { createStorage as t };
+//#region src/node/hub-internals/context.ts
+const internalContextMap = /* @__PURE__ */ new WeakMap();
+function getInternalContext(context) {
+	if (!internalContextMap.has(context)) {
+		const storage = createStorage({
+			filepath: join(context.host.getStorageDir("global"), "auth.json"),
+			initialValue: { trusted: {} }
+		});
+		const remoteTokens = /* @__PURE__ */ new Map();
+		function revokeRemoteToken(token) {
+			if (!remoteTokens.delete(token)) return;
+			revokeActiveConnectionsForToken(context, token);
+		}
+		const internalContext = {
+			storage: { auth: storage },
+			revokeAuthToken: (token) => revokeAuthToken(context, storage, token),
+			remoteTokens,
+			allocateRemoteToken(dockId, origin, originLock) {
+				const token = humanId();
+				remoteTokens.set(token, {
+					dockId,
+					origin,
+					originLock
+				});
+				return token;
+			},
+			revokeRemoteToken,
+			revokeRemoteTokensForDock(dockId) {
+				const tokensToRevoke = [];
+				for (const [token, record] of remoteTokens) if (record.dockId === dockId) tokensToRevoke.push(token);
+				for (const token of tokensToRevoke) revokeRemoteToken(token);
+			},
+			isRemoteTokenTrusted(token, requestOrigin) {
+				const record = remoteTokens.get(token);
+				if (!record) return false;
+				if (!record.originLock) return true;
+				return !!requestOrigin && record.origin === requestOrigin;
+			}
+		};
+		internalContextMap.set(context, internalContext);
+	}
+	return internalContextMap.get(context);
+}
+//#endregion
+export { internalContextMap as n, createStorage as r, getInternalContext as t };

package/dist/{dev-C2wjXjGB.mjs → dev-Cv43GfqM.mjs}

@@ -1,6 +1,6 @@
-import { DEVTOOLS_CONNECTION_META_FILENAME } from "./constants.mjs";
-import { n as createHostContext, t as createH3DevToolsHost } from "./host-h3-Div5Vp8R.mjs";
-import { t as startHttpAndWs } from "./server-BO8IDVsJ.mjs";
+import { DEVFRAME_CONNECTION_META_FILENAME } from "./constants.mjs";
+import { n as createHostContext, t as createH3DevframeHost } from "./host-h3-Dgpgr1Ul.mjs";
+import { t as startHttpAndWs } from "./server-BBaBJaUL.mjs";
 import { n as resolveBasePath, t as normalizeBasePath } from "./_shared-CUFqO4kJ.mjs";
 import { t as open } from "./open-DiQn6zCH.mjs";
 import { mountStaticHandler } from "./utils/serve-static.mjs";
@@ -269,7 +269,7 @@ async function createDevServer(def, options = {}) {
 	const flags = options.flags ?? {};
 	const basePath = options.basePath ? normalizeBasePath(options.basePath) : resolveBasePath(def, "standalone");
 	const app = options.app ?? new H3();
-	const h3Host = createH3DevToolsHost({
+	const h3Host = createH3DevframeHost({
 		origin: `http://${host}:${port}`,
 		appName: def.id,
 		mount: (base, dir) => {
@@ -283,7 +283,7 @@ async function createDevServer(def, options = {}) {
 	});
 	const setupInfo = { flags };
 	await def.setup(ctx, setupInfo);
-	const connectionMetaPath = `${basePath}${DEVTOOLS_CONNECTION_META_FILENAME}`;
+	const connectionMetaPath = `${basePath}${DEVFRAME_CONNECTION_META_FILENAME}`;
 	app.use(connectionMetaPath, () => ({
 		backend: "websocket",
 		websocket: port