@devframes/vite 0.9.0-beta.3

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-PRESENT Anthony Fu <https://github.com/antfu>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/dev-spa.d.mts

@@ -0,0 +1,135 @@
+import { IncomingMessage, ServerResponse } from "node:http";
+import { DevframeDefinition, McpRouteOptions } from "devframe";
+import { DevframeAuthHandler } from "devframe/node/auth";
+import { Plugin } from "vite";
+//#region src/dev-spa.d.ts
+/**
+ * The slice of a Vite dev server these plugins touch — deliberately
+ * narrower than Vite's real `ViteDevServer` (which carries the module
+ * graph, watcher, transform pipeline, …) so a host can hand a plugin
+ * anything shaped like this, and a test double only needs to fake two
+ * fields. A real `ViteDevServer` satisfies this structurally, so each
+ * plugin's `configureServer(server: ViteDevServer)` hook (typed against
+ * the real `Plugin` below) is still fully type-safe.
+ */
+interface DevframeViteDevServerLike {
+  middlewares: {
+    use: ((path: string, handler: (req: IncomingMessage, res: ServerResponse, next?: (err?: unknown) => void) => void) => void) & ((handler: (req: IncomingMessage, res: ServerResponse, next?: (err?: unknown) => void) => void) => void);
+  };
+  /**
+   * Deliberately structural (just the one event these plugins listen for)
+   * rather than `NodeHttpServer` — Vite's real `ViteDevServer.httpServer`
+   * is `http.Server | Http2SecureServer | null`, and `Http2SecureServer`
+   * doesn't satisfy `http.Server`'s full shape.
+   */
+  httpServer?: {
+    once: (event: 'close', listener: () => void) => unknown;
+  } | null;
+}
+/** A devframe Vite plugin — a real Vite `Plugin`, scoped to its `serve`-only hooks. */
+type DevframeVitePlugin = Plugin;
+interface DevframeVitePluginOptions {
+  /**
+   * Mount base. Defaults to `def.basePath ?? '/__<id>/'` for this hosted
+   * adapter — the devframe shares the origin with the host Vite app.
+   *
+   * Relative spellings like `'./'` (common for base-agnostic Nuxt builds)
+   * are normalized to absolute paths so they compose with Vite's connect
+   * router.
+   */
+  base?: string;
+}
+/**
+ * Statically mount a devframe's built SPA (`def.cli.distDir`) at
+ * `options.base` inside an existing Vite dev server. No RPC server is
+ * started — reach for {@link devframeViteBridge} when the mounted UI
+ * needs a live RPC/WebSocket connection back to the devframe.
+ *
+ * Use this when the devframe ships its own pre-built UI and the host
+ * only needs to serve it alongside its own app (e.g. a devtools dock
+ * whose backend runs elsewhere, or a hub that only wants the static
+ * assets).
+ */
+declare function devframeVitePlugin(d: DevframeDefinition, options?: DevframeVitePluginOptions): DevframeVitePlugin;
+interface DevframeViteBridgeOptions {
+  /**
+   * Mount base. Defaults to `def.basePath ?? '/__<id>/'` for this hosted
+   * adapter — the devframe shares the origin with the host Vite app.
+   *
+   * Relative spellings like `'./'` (common for base-agnostic Nuxt builds)
+   * are normalized to absolute paths so they compose with Vite's connect
+   * router.
+   */
+  base?: string;
+  /**
+   * Pin a side-car port for the RPC socket instead of sharing Vite's
+   * server. Default: share Vite's HTTP server (side-car only when Vite
+   * has none).
+   */
+  port?: number;
+  /** Override the side-car bind host. Default: `def.cli?.host ?? 'localhost'`. */
+  host?: string;
+  /** Flag bag forwarded to `def.setup(ctx, { flags })`. */
+  flags?: Record<string, unknown>;
+  /**
+   * Whether the bridged devframe runs its own auth gate. The RPC endpoint is
+   * reachable by anything that can open its socket, so it **gates by
+   * default**: when unset, authentication resolves through devframe's
+   * interactive OTP gate (unless the definition's `cli.auth` opts out), and
+   * the bridge prints its code/link banner to stdout. Pass a
+   * {@link DevframeAuthHandler} to install a custom scheme, or `false` to opt
+   * out for a single-user localhost host that owns the trust boundary
+   * another way.
+   *
+   * @default gated (devframe's interactive OTP, unless `cli.auth` opts out)
+   */
+  auth?: boolean | DevframeAuthHandler;
+  /**
+   * Expose the bridge's route-based MCP server (Streamable-HTTP) at
+   * `<base>__mcp` — on the Vite app's own origin — and advertise it in the
+   * bridge's `__connection.json`. Overrides `def.cli?.mcp`, `undefined`
+   * falls through to it, `false` disables the route regardless.
+   */
+  mcp?: boolean | McpRouteOptions;
+}
+/**
+ * Bridge a devframe's RPC + WebSocket backend into an existing Vite dev
+ * server: the host app owns the SPA (`distDir` is never mounted), and this
+ * plugin serves discovery (`<base>__connection.json`), the WebSocket RPC
+ * upgrade (`<base>__ws`, shared on Vite's own HTTP server), and the
+ * optional MCP route through {@link initDevframe}'s node middleware — so
+ * the host-served SPA can discover the endpoint via `connectDevframe`.
+ *
+ * The bridge **gates by default** (devframe's interactive OTP unless the
+ * definition's `cli.auth` opts out), printing its code/link banner to
+ * stdout, so a bridged devframe isn't silently reachable by anything that
+ * can open its socket. Pass `options.auth: false` to opt out for a
+ * single-user localhost host, or a {@link DevframeAuthHandler} for a
+ * custom scheme.
+ *
+ * Use this when integrating with frameworks that own the SPA (Nuxt, Astro,
+ * SolidStart, plain Vite apps). Reach for {@link devframeVitePlugin} instead
+ * when the devframe just needs to serve its own pre-built UI with no live
+ * backend, or `createCac` (`devframe/adapters/cac`) for the all-in-one
+ * `dev` / `build` / `mcp` shell.
+ */
+declare function devframeViteBridge(d: DevframeDefinition, options?: DevframeViteBridgeOptions): DevframeVitePlugin;
+interface DevframeViteOptions extends DevframeViteBridgeOptions {
+  /**
+   * Start devframe's RPC/WS bridge ({@link devframeViteBridge}) instead of
+   * statically mounting the built SPA ({@link devframeVitePlugin}).
+   *
+   * @default false (static mount, no server)
+   */
+  bridge?: boolean;
+}
+/**
+ * Convenience wrapper around {@link devframeVitePlugin} /
+ * {@link devframeViteBridge}, picked via `options.bridge`. Reach for the
+ * two underlying plugins directly when a devframe needs both mounted at
+ * once (e.g. a bridge for RPC alongside a static mount serving its own
+ * bundled UI).
+ */
+declare function devframeVite(d: DevframeDefinition, options?: DevframeViteOptions): DevframeVitePlugin;
+//#endregion
+export { DevframeViteBridgeOptions, DevframeViteDevServerLike, DevframeViteOptions, DevframeVitePlugin, DevframeVitePluginOptions, devframeVite, devframeViteBridge, devframeVitePlugin };

package/dist/dev-spa.mjs

@@ -0,0 +1,111 @@
+import { initDevframe } from "devframe/initiate";
+import { diagnostics, normalizeBasePath, resolveBasePath } from "devframe/internal";
+import { serveStaticNodeMiddleware } from "devframe/utils/serve-static";
+import { resolve } from "pathe";
+//#region src/dev-spa.ts
+/**
+* Statically mount a devframe's built SPA (`def.cli.distDir`) at
+* `options.base` inside an existing Vite dev server. No RPC server is
+* started — reach for {@link devframeViteBridge} when the mounted UI
+* needs a live RPC/WebSocket connection back to the devframe.
+*
+* Use this when the devframe ships its own pre-built UI and the host
+* only needs to serve it alongside its own app (e.g. a devtools dock
+* whose backend runs elsewhere, or a hub that only wants the static
+* assets).
+*/
+function devframeVitePlugin(d, options = {}) {
+	const base = normalizeMountBase(options.base ?? resolveBasePath(d, "hosted"));
+	const distDir = d.cli?.distDir;
+	return {
+		name: `devframe:${d.id}`,
+		apply: "serve",
+		configureServer(server) {
+			if (!distDir) return;
+			server.middlewares.use(base, serveStaticNodeMiddleware(resolve(distDir)));
+		}
+	};
+}
+/**
+* Bridge a devframe's RPC + WebSocket backend into an existing Vite dev
+* server: the host app owns the SPA (`distDir` is never mounted), and this
+* plugin serves discovery (`<base>__connection.json`), the WebSocket RPC
+* upgrade (`<base>__ws`, shared on Vite's own HTTP server), and the
+* optional MCP route through {@link initDevframe}'s node middleware — so
+* the host-served SPA can discover the endpoint via `connectDevframe`.
+*
+* The bridge **gates by default** (devframe's interactive OTP unless the
+* definition's `cli.auth` opts out), printing its code/link banner to
+* stdout, so a bridged devframe isn't silently reachable by anything that
+* can open its socket. Pass `options.auth: false` to opt out for a
+* single-user localhost host, or a {@link DevframeAuthHandler} for a
+* custom scheme.
+*
+* Use this when integrating with frameworks that own the SPA (Nuxt, Astro,
+* SolidStart, plain Vite apps). Reach for {@link devframeVitePlugin} instead
+* when the devframe just needs to serve its own pre-built UI with no live
+* backend, or `createCac` (`devframe/adapters/cac`) for the all-in-one
+* `dev` / `build` / `mcp` shell.
+*/
+function devframeViteBridge(d, options = {}) {
+	const base = normalizeMountBase(options.base ?? resolveBasePath(d, "hosted"));
+	let instance;
+	return {
+		name: `devframe:${d.id}`,
+		apply: "serve",
+		async configureServer(server) {
+			await instance?.close().catch(() => {});
+			instance = void 0;
+			try {
+				const created = initDevframe(d, {
+					base,
+					distDir: false,
+					flags: options.flags,
+					host: options.host,
+					...options.port != null ? { ws: { port: options.port } } : server.httpServer ? { server: server.httpServer } : { ws: { sidecar: true } },
+					auth: options.auth,
+					mcp: options.mcp
+				});
+				server.middlewares.use(created.nodeMiddleware);
+				await created.ready;
+				instance = created;
+			} catch (e) {
+				diagnostics.DF0033({
+					id: d.id,
+					reason: String(e),
+					cause: e
+				}, { method: "warn" });
+				return;
+			}
+			server.httpServer?.once("close", () => {
+				instance?.close().catch(() => {});
+			});
+		},
+		async closeBundle() {
+			await instance?.close().catch(() => {});
+			instance = void 0;
+		}
+	};
+}
+/**
+* Convenience wrapper around {@link devframeVitePlugin} /
+* {@link devframeViteBridge}, picked via `options.bridge`. Reach for the
+* two underlying plugins directly when a devframe needs both mounted at
+* once (e.g. a bridge for RPC alongside a static mount serving its own
+* bundled UI).
+*/
+function devframeVite(d, options = {}) {
+	const { bridge, ...rest } = options;
+	return bridge ? devframeViteBridge(d, rest) : devframeVitePlugin(d, { base: rest.base });
+}
+/**
+* Make `base` safe for `server.middlewares.use(path, …)`. Vite's connect
+* router matches by absolute URL prefix, so relative spellings like
+* `'./'` (commonly used for base-agnostic Nuxt builds) collapse to the
+* origin root before the shared leading/trailing-slash normalization.
+*/
+function normalizeMountBase(base) {
+	return normalizeBasePath(base.replace(/^\.\/?/, "/"));
+}
+//#endregion
+export { devframeVite, devframeViteBridge, devframeVitePlugin };

package/dist/hub-client.d.mts

@@ -0,0 +1,26 @@
+import { DevframeClientHost, DevframeClientHost as DevframeClientHost$1, DevframeClientHostOptions, DevframeClientHostOptions as DevframeClientHostOptions$1 } from "@devframes/hub/client";
+//#region src/hub-client.d.ts
+interface MountDevframeHubClientOptions extends DevframeClientHostOptions$1 {
+  /**
+   * Hub mount base to connect to. Forwarded as `connect.baseURL` when no
+   * `rpc` / `connect.baseURL` is supplied.
+   *
+   * @default '/__devframes/'
+   */
+  base?: string;
+}
+/**
+ * Boot the devframes-hub **client runtime** in the host page — the browser
+ * half of {@link import('./hub').viteDevframeHub}. Connects RPC to the hub
+ * (defaulting `base` to `/__devframes/`), assembles the shared
+ * `DevframeClientContext`, and imports each dock's client script into the
+ * page. A thin default-applying wrapper over `@devframes/hub/client`'s
+ * `createDevframeClientHost`.
+ *
+ * Only needed when you render your own dock UI (or override the hub's `ui`).
+ * With the default `@devframes/hub-ui`, its injected `embedded.js` boots the
+ * client for you, so the host page needs no client code.
+ */
+declare function mountDevframeHubClient(options?: MountDevframeHubClientOptions): Promise<DevframeClientHost$1>;
+//#endregion
+export { type DevframeClientHost, type DevframeClientHostOptions, MountDevframeHubClientOptions, mountDevframeHubClient };

package/dist/hub-client.mjs

@@ -0,0 +1,28 @@
+import { createDevframeClientHost } from "@devframes/hub/client";
+//#region src/hub-client.ts
+/** Default hub mount base — mirrors `@devframes/hub`'s `DEVFRAMES_HUB_BASE`. */
+const DEVFRAMES_HUB_BASE = "/__devframes/";
+/**
+* Boot the devframes-hub **client runtime** in the host page — the browser
+* half of {@link import('./hub').viteDevframeHub}. Connects RPC to the hub
+* (defaulting `base` to `/__devframes/`), assembles the shared
+* `DevframeClientContext`, and imports each dock's client script into the
+* page. A thin default-applying wrapper over `@devframes/hub/client`'s
+* `createDevframeClientHost`.
+*
+* Only needed when you render your own dock UI (or override the hub's `ui`).
+* With the default `@devframes/hub-ui`, its injected `embedded.js` boots the
+* client for you, so the host page needs no client code.
+*/
+function mountDevframeHubClient(options = {}) {
+	const { base = DEVFRAMES_HUB_BASE, connect, ...rest } = options;
+	return createDevframeClientHost({
+		...rest,
+		...rest.rpc ? {} : { connect: {
+			baseURL: base,
+			...connect
+		} }
+	});
+}
+//#endregion
+export { mountDevframeHubClient };

package/dist/hub.d.mts

@@ -0,0 +1,100 @@
+import { DevframeHubUi, DockRendererRegistration, InitHubOptions } from "@devframes/hub/initiate";
+import { Plugin } from "vite";
+import { DevframeHubContext } from "@devframes/hub/node";
+import { ClientScriptEntry } from "@devframes/hub/types";
+//#region src/hub.d.ts
+interface ViteDevframeHubOptions {
+  /**
+   * Mount base the hub answers under — every frame lives at `<base><id>/`.
+   * Default: `/__devframes/`.
+   */
+  base?: string;
+  /**
+   * Pin a side-car port for the RPC/WS server. By default the WebSocket
+   * shares Vite's own HTTP server, upgrading at `<base>__ws`.
+   */
+  port?: number;
+  /** Bind host for a pinned side-car server. Default: `localhost`. */
+  host?: string;
+  /**
+   * Devframes to mount as docks. Wrap an entry in `{ devframe, dock }` to
+   * customize its synthesized iframe dock (category, `frameId`, `subTabs`, …).
+   */
+  devframes?: InitHubOptions['devframes'];
+  /**
+   * Per-dock client scripts, keyed by devframe id. Attached to the mounted
+   * iframe dock so the hub client runtime imports them into the host page
+   * (e.g. the a11y inspector's in-page agent).
+   */
+  clientScripts?: Record<string, ClientScriptEntry>;
+  /**
+   * Prebuilt dock-renderer modules forwarded to `initHub({ renderers })` —
+   * each served at `<base>__renderers/<type>.mjs` and published in the
+   * renderer manifest (e.g. `jsonRenderUiRenderer()` from
+   * `@devframes/json-render-ui/hub`).
+   */
+  renderers?: readonly DockRendererRegistration[];
+  /**
+   * Extra RPC declarations registered at context creation, alongside the hub
+   * built-ins.
+   */
+  rpcDeclarations?: InitHubOptions['rpcDeclarations'];
+  /**
+   * Runs once the context exists and every `devframes` entry is mounted —
+   * register docks, commands, terminals, and messages surfaces here.
+   */
+  configure?: (ctx: DevframeHubContext) => void | Promise<void>;
+  /**
+   * The hub's UI slot. Defaults to `@devframes/hub-ui`'s `createUi()` (the
+   * reference floating dock + standalone viewer) when omitted — install
+   * `@devframes/hub-ui` for that default. Pass your own {@link DevframeHubUi}
+   * to swap the viewer, or `false` for a headless hub (serve your own UI
+   * against `@devframes/hub/client`).
+   */
+  ui?: DevframeHubUi | false;
+  /**
+   * The hub's single auth gate. Gates by default (interactive OTP); `false`
+   * opts out for a single-user localhost host.
+   */
+  auth?: InitHubOptions['auth'];
+  /**
+   * Expose the aggregate MCP endpoint at `<base>__mcp`.
+   */
+  mcp?: InitHubOptions['mcp'];
+  /** Publish this hub in the global instance registry. Default: off. */
+  register?: InitHubOptions['register'];
+  /** Public origin the host app is reachable at, or a getter. */
+  origin?: InitHubOptions['origin'];
+  /** Working directory for the hub context. Default: Vite's project root. */
+  cwd?: string;
+  /** Override where persisted devframe state lives. */
+  getStorageDir?: InitHubOptions['getStorageDir'];
+  /** Name for the hub instance (logs, diagnostics, MCP server). */
+  name?: string;
+  /** Version for the hub instance (logs, diagnostics, MCP server). */
+  version?: string;
+  /**
+   * Silence the notice recommending Vite DevTools. See {@link viteDevframeHub}.
+   *
+   * @default false
+   */
+  quiet?: boolean;
+}
+/**
+ * Mount a whole **devframes-hub** — many integrations under one namespace,
+ * one merged RPC registry, one WebSocket — inside an existing Vite dev
+ * server. One `initHub()` call, mounted as connect middleware; the WebSocket
+ * shares Vite's own HTTP server (upgrading at `<base>__ws`) unless a `port`
+ * pins a side-car. The UI defaults to `@devframes/hub-ui` (its `embedded.js`
+ * bootstrap is injected into the host page automatically); pass `ui` to swap
+ * it or `ui: false` for a headless hub you drive with `@devframes/hub/client`.
+ *
+ * This mounts one integration-agnostic hub. Vite DevTools
+ * (`@vitejs/devtools-kit`) integrates the same hub protocol natively and is
+ * the recommended path for a Vite app, so this plugin emits a one-time notice
+ * to that effect (silence it with `{ quiet: true }`). For dev-serving a
+ * single devframe's own SPA, reach for `@devframes/vite/dev-spa` instead.
+ */
+declare function viteDevframeHub(options?: ViteDevframeHubOptions): Plugin;
+//#endregion
+export { ViteDevframeHubOptions, viteDevframeHub };

package/dist/hub.mjs

@@ -0,0 +1,126 @@
+import { Server } from "node:http";
+import process from "node:process";
+import { DEVFRAMES_HUB_BASE, initHub } from "@devframes/hub/initiate";
+//#region src/hub.ts
+let recommendedViteDevtools = false;
+function recommendViteDevtools() {
+	if (recommendedViteDevtools) return;
+	recommendedViteDevtools = true;
+	console.warn("[@devframes/vite/hub] Serving a devframes-hub directly inside Vite works, but Vite DevTools (`@vitejs/devtools-kit`) integrates the hub protocol natively — prefer it for a first-class, multi-integration experience. Pass `{ quiet: true }` to silence this notice.");
+}
+/**
+* Mount a whole **devframes-hub** — many integrations under one namespace,
+* one merged RPC registry, one WebSocket — inside an existing Vite dev
+* server. One `initHub()` call, mounted as connect middleware; the WebSocket
+* shares Vite's own HTTP server (upgrading at `<base>__ws`) unless a `port`
+* pins a side-car. The UI defaults to `@devframes/hub-ui` (its `embedded.js`
+* bootstrap is injected into the host page automatically); pass `ui` to swap
+* it or `ui: false` for a headless hub you drive with `@devframes/hub/client`.
+*
+* This mounts one integration-agnostic hub. Vite DevTools
+* (`@vitejs/devtools-kit`) integrates the same hub protocol natively and is
+* the recommended path for a Vite app, so this plugin emits a one-time notice
+* to that effect (silence it with `{ quiet: true }`). For dev-serving a
+* single devframe's own SPA, reach for `@devframes/vite/dev-spa` instead.
+*/
+function viteDevframeHub(options = {}) {
+	const base = normalizeBase(options.base ?? DEVFRAMES_HUB_BASE);
+	let viteConfig;
+	let instance;
+	let embeddedSrc;
+	const teardown = async () => {
+		const previous = instance;
+		instance = void 0;
+		await previous?.close().catch(() => {});
+	};
+	return {
+		name: "devframes:hub",
+		apply: "serve",
+		configResolved(config) {
+			viteConfig = config;
+		},
+		async configureServer(server) {
+			if (!options.quiet) recommendViteDevtools();
+			await teardown();
+			const cwd = options.cwd ?? viteConfig?.root ?? process.cwd();
+			const ui = options.ui === false ? void 0 : options.ui ?? await loadDefaultUi();
+			const devframes = attachClientScripts(options.devframes, options.clientScripts);
+			const httpServer = server.httpServer instanceof Server ? server.httpServer : void 0;
+			const hub = initHub({
+				base,
+				cwd,
+				origin: options.origin ?? (() => {
+					const resolved = server.resolvedUrls?.local?.[0];
+					return resolved ? new URL(resolved).origin : "";
+				}),
+				auth: options.auth,
+				server: httpServer,
+				...options.port != null ? { ws: { port: options.port } } : httpServer ? {} : { ws: { sidecar: true } },
+				...options.host != null ? { host: options.host } : {},
+				...ui ? { ui } : {},
+				...options.renderers ? { renderers: options.renderers } : {},
+				...options.rpcDeclarations ? { rpcDeclarations: options.rpcDeclarations } : {},
+				...options.mcp != null ? { mcp: options.mcp } : {},
+				...options.register != null ? { register: options.register } : {},
+				...options.getStorageDir ? { getStorageDir: options.getStorageDir } : {},
+				...options.name != null ? { name: options.name } : {},
+				...options.version != null ? { version: options.version } : {},
+				devframes,
+				...options.configure ? { configure: options.configure } : {}
+			});
+			instance = hub;
+			embeddedSrc = ui?.embedded ? `${base}embedded.js` : void 0;
+			server.middlewares.use(hub.nodeMiddleware);
+			server.httpServer?.once("close", () => {
+				if (instance !== hub) return;
+				teardown();
+			});
+		},
+		transformIndexHtml() {
+			if (!embeddedSrc) return;
+			return [{
+				tag: "script",
+				attrs: {
+					type: "module",
+					src: embeddedSrc
+				},
+				injectTo: "body"
+			}];
+		},
+		async closeBundle() {
+			await teardown();
+		}
+	};
+}
+/** Lazy-load `@devframes/hub-ui`'s default UI so it stays an optional dep. */
+async function loadDefaultUi() {
+	const { createUi } = await import("@devframes/hub-ui");
+	return createUi();
+}
+/** Attach per-id client scripts to their devframe mount entries. */
+function attachClientScripts(devframes, clientScripts) {
+	if (!devframes || !clientScripts) return devframes;
+	return devframes.map((entry) => {
+		if (typeof entry === "function" || entry instanceof Promise) return entry;
+		const def = entry && typeof entry === "object" && "devframe" in entry ? entry.devframe : entry;
+		const clientScript = def ? clientScripts[def.id] : void 0;
+		if (!def || !clientScript) return entry;
+		return "devframe" in entry ? {
+			...entry,
+			dock: {
+				clientScript,
+				...entry.dock
+			}
+		} : {
+			devframe: def,
+			dock: { clientScript }
+		};
+	});
+}
+function normalizeBase(base) {
+	let out = base.startsWith("/") ? base : `/${base}`;
+	if (!out.endsWith("/")) out = `${out}/`;
+	return out;
+}
+//#endregion
+export { viteDevframeHub };

package/dist/index.d.mts

@@ -0,0 +1 @@
+export {}

package/dist/index.mjs

@@ -0,0 +1,4 @@
+//#region src/index.ts
+throw new Error("[@devframes/vite] has no root export. Import from a scoped subpath instead:\n  • \"@devframes/vite/dev-spa\" — dev-serve one devframe's SPA with Vite\n  • \"@devframes/vite/hub\"     — mount a devframes-hub inside a Vite app\n");
+//#endregion
+export {};

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@devframes/vite",
+  "type": "module",
+  "version": "0.9.0-beta.3",
+  "description": "Vite plugin for mounting a devframe inside any Vite-based host (Astro, SolidStart, Nuxt, plain Vite apps).",
+  "author": "Anthony Fu <anthonyfu117@hotmail.com>",
+  "license": "MIT",
+  "homepage": "https://github.com/devframes/devframe#readme",
+  "repository": {
+    "directory": "packages/vite",
+    "type": "git",
+    "url": "git+https://github.com/devframes/devframe.git"
+  },
+  "bugs": "https://github.com/devframes/devframe/issues",
+  "keywords": [
+    "devframe",
+    "vite",
+    "devtools"
+  ],
+  "sideEffects": false,
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./dev-spa": "./dist/dev-spa.mjs",
+    "./hub": "./dist/hub.mjs",
+    "./hub/client": "./dist/hub-client.mjs",
+    "./package.json": "./package.json"
+  },
+  "types": "./dist/index.d.mts",
+  "files": [
+    "dist"
+  ],
+  "peerDependencies": {
+    "vite": "^7.0.0 || ^8.0.0",
+    "@devframes/hub": "0.9.0-beta.3",
+    "devframe": "0.9.0-beta.3",
+    "@devframes/hub-ui": "0.9.0-beta.3"
+  },
+  "peerDependenciesMeta": {
+    "@devframes/hub": {
+      "optional": true
+    },
+    "@devframes/hub-ui": {
+      "optional": true
+    },
+    "vite": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "pathe": "^2.0.3"
+  },
+  "devDependencies": {
+    "@modelcontextprotocol/client": "^2.0.0",
+    "@types/node": "^26.2.0",
+    "get-port-please": "^3.2.0",
+    "tsdown": "^0.22.14",
+    "vite": "^8.2.1",
+    "vitest": "^4.1.10",
+    "devframe": "0.9.0-beta.3",
+    "@devframes/hub-ui": "0.9.0-beta.3",
+    "@devframes/hub": "0.9.0-beta.3"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "watch": "tsdown --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  }
+}