devframe 0.1.20 → 0.1.22

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "devframe",
   "type": "module",
-  "version": "0.1.20",
+  "version": "0.1.22",
   "description": "Framework for building generic DevTools",
   "author": "Anthony Fu <anthonyfu117@hotmail.com>",
   "license": "MIT",
@@ -24,12 +24,13 @@
     "./adapters/cli": "./dist/adapters/cli.mjs",
     "./adapters/dev": "./dist/adapters/dev.mjs",
     "./adapters/embedded": "./dist/adapters/embedded.mjs",
-    "./adapters/kit": "./dist/adapters/kit.mjs",
     "./adapters/mcp": "./dist/adapters/mcp.mjs",
     "./adapters/vite": "./dist/adapters/vite.mjs",
     "./client": "./dist/client/index.mjs",
     "./constants": "./dist/constants.mjs",
     "./node": "./dist/node/index.mjs",
+    "./node/auth": "./dist/node/auth.mjs",
+    "./node/internal": "./dist/node/internal.mjs",
     "./recipes/open-helpers": "./dist/recipes/open-helpers.mjs",
     "./rpc": "./dist/rpc/index.mjs",
     "./rpc/client": "./dist/rpc/client.mjs",
@@ -37,13 +38,18 @@
     "./rpc/transports/ws-client": "./dist/rpc/transports/ws-client.mjs",
     "./rpc/transports/ws-server": "./dist/rpc/transports/ws-server.mjs",
     "./types": "./dist/types/index.mjs",
+    "./utils/colors": "./dist/utils/colors.mjs",
     "./utils/events": "./dist/utils/events.mjs",
+    "./utils/hash": "./dist/utils/hash.mjs",
     "./utils/human-id": "./dist/utils/human-id.mjs",
+    "./utils/launch-editor": "./dist/utils/launch-editor.mjs",
     "./utils/nanoid": "./dist/utils/nanoid.mjs",
+    "./utils/open": "./dist/utils/open.mjs",
     "./utils/promise": "./dist/utils/promise.mjs",
+    "./utils/serve-static": "./dist/utils/serve-static.mjs",
     "./utils/shared-state": "./dist/utils/shared-state.mjs",
-    "./utils/state": "./dist/utils/state.mjs",
     "./utils/streaming-channel": "./dist/utils/streaming-channel.mjs",
+    "./utils/structured-clone": "./dist/utils/structured-clone.mjs",
     "./utils/when": "./dist/utils/when.mjs",
     "./package.json": "./package.json"
   },
@@ -62,46 +68,50 @@
   },
   "dependencies": {
     "@valibot/to-json-schema": "^1.7.0",
-    "ansis": "^4.2.0",
     "birpc": "^4.0.0",
     "cac": "^7.0.0",
     "h3": "^1.15.11",
-    "immer": "^11.1.7",
-    "launch-editor": "^2.13.2",
     "logs-sdk": "^0.0.6",
-    "ohash": "^2.0.11",
+    "mrmime": "^2.0.1",
     "pathe": "^2.0.3",
-    "sirv": "^3.0.2",
-    "structured-clone-es": "^2.0.0",
     "valibot": "^1.4.0",
     "ws": "^8.20.0"
   },
   "devDependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
+    "ansis": "^4.2.0",
+    "immer": "^11.1.8",
     "launch-editor": "^2.13.2",
-    "tsdown": "^0.21.10",
+    "ohash": "^2.0.11",
+    "open": "^11.0.0",
+    "structured-clone-es": "^2.0.0",
+    "tsdown": "^0.22.0",
     "whenexpr": "^0.1.2"
   },
   "inlinedDependencies": {
-    "acorn": "8.16.0",
+    "ansis": "4.2.0",
     "bundle-name": "4.1.0",
     "default-browser": "5.4.0",
     "default-browser-id": "5.0.1",
     "define-lazy-prop": "3.0.0",
     "get-port-please": "3.2.0",
     "human-id": "4.1.3",
+    "immer": "11.1.8",
     "is-docker": "3.0.0",
     "is-in-ssh": "1.0.0",
     "is-inside-container": "1.0.0",
     "is-wsl": "3.1.0",
-    "mlly": "1.8.2",
+    "launch-editor": "2.13.2",
     "obug": "2.1.1",
+    "ohash": "2.0.11",
     "open": "11.0.0",
     "p-limit": "7.3.0",
     "perfect-debounce": "2.1.0",
+    "picocolors": "1.1.1",
     "powershell-utils": "0.1.0",
     "run-applescript": "7.1.0",
-    "tinyexec": "1.1.2",
+    "shell-quote": "1.8.3",
+    "structured-clone-es": "2.0.0",
     "ua-parser-modern": "0.1.1",
     "whenexpr": "0.1.2",
     "wsl-utils": "0.3.1",

package/skills/devframe/SKILL.md

@@ -1,26 +1,31 @@
 ---
 name: devframe
 description: >
-  Use when building devtools with devframe — the framework-neutral
-  foundation that powers Vite DevTools. Covers DevtoolDefinition,
-  picking the right adapter (cli / build / spa / vite / kit / embedded /
-  mcp), designing RPC contracts, registering docks / commands / logs /
-  terminals, exposing an agent-native surface over MCP, and wiring the
-  author's SPA client. Triggers on `devframe` imports, `defineDevtool`,
-  `createCli`, `createMcpServer`, `connectDevtool`, and on migrations of
-  existing inspectors (eslint-config-inspector, unocss-inspector,
-  node-modules-inspector-style tools) to devframe.
+  Use when building one devtool integration with devframe — the
+  portable, framework-neutral container for a single tool. Covers
+  DevframeDefinition, picking the right deployment adapter
+  (cli / build / spa / vite / embedded / mcp), designing RPC
+  contracts, exposing an agent-native surface over MCP, and wiring
+  the author's SPA client. Hub-only concerns (docks, terminals,
+  commands, the unified messages dock) belong to
+  `@vitejs/devtools-kit` — see the `vite-devtools-kit` skill for
+  those. Triggers on `devframe` imports, `defineDevframe`,
+  `createCli`, `createMcpServer`, `connectDevframe`, and on
+  migrations of existing inspectors (eslint-config-inspector,
+  unocss-inspector, node-modules-inspector-style tools) to devframe.
 ---
 
 # devframe skill
 
-A devtool built on devframe is a **single `DevtoolDefinition`** plus an author-provided SPA. Use one of seven adapters to ship it. `devframe` must not depend on Vite or any `@vitejs/*` package — it's the lowest-level layer in the monorepo, and the Kit / core packages build on top.
+**Devframe is the container for one devtool integration, portable across viewers.** A devtool built on devframe is a single `DevframeDefinition` plus an author-provided SPA — the same definition deploys as a standalone CLI, a static report, an embedded SPA, an MCP server, or as a dock entry inside the Vite DevTools hub via `createPluginFromDevframe`.
+
+Devframe deliberately stops at the boundary of one tool. Anything that only matters across multiple integrations — docks, terminals, command palette, cross-tool toasts — lives in `@vitejs/devtools-kit`, the hub layer. `devframe` must not depend on Vite, any `@vitejs/*` package, or hub-only concepts; it's the lowest-level layer in the monorepo.
 
 Full reference: [devfra.me/](https://devfra.me/).
 
 ## When to use devframe
 
-All adapter factories share the shape `createXxx(devtoolDef, options?)`.
+All adapter factories share the shape `createXxx(devframeDef, options?)`.
 
 | Author goal | Factory | Entry |
 |-------------|---------|-------|
@@ -28,18 +33,18 @@ All adapter factories share the shape `createXxx(devtoolDef, options?)`.
 | Run the dev server programmatically (any CLI framework) | `createDevServer(def, options?)` | `devframe/adapters/dev` |
 | Mount a SPA in an existing Vite dev server | `createVitePlugin(def, options?)` | `devframe/adapters/vite` |
 | Self-contained static deploy with baked data | `createBuild(def, options?)` | `devframe/adapters/build` |
-| Integrate into Vite DevTools | `createKitPlugin(def, options?)` | `devframe/adapters/kit` |
+| Integrate into Vite DevTools | `createPluginFromDevframe(def, options?)` | `@vitejs/devtools-kit/node` |
 | Register dynamically at runtime | `createEmbedded(def, { ctx })` | `devframe/adapters/embedded` |
 | Expose to coding agents (MCP) | `createMcpServer(def, options?)` | `devframe/adapters/mcp` *(experimental)* |
 
-The same `DevtoolDefinition` runs under every adapter — pick based on deployment, not on what the tool does.
+The same `DevframeDefinition` runs under every adapter — pick based on deployment, not on what the tool does.
 
-## Minimum viable devtool
+## Minimum viable devframe
 
 ```ts
-import { defineDevtool, defineRpcFunction } from 'devframe'
+import { defineDevframe, defineRpcFunction } from 'devframe'
 
-export default defineDevtool({
+export default defineDevframe({
   id: 'my-inspector',
   name: 'My Inspector',
   icon: 'ph:magnifying-glass-duotone',
@@ -50,46 +55,39 @@ export default defineDevtool({
       type: 'static',
       handler: () => ({ count: 42 }),
     }))
-    ctx.docks.register({
-      id: 'my-inspector',
-      title: 'My Inspector',
-      icon: 'ph:magnifying-glass-duotone',
-      type: 'iframe',
-      url: '/.devtools/',
-    })
   },
 })
 ```
 
-See `templates/counter-devtool.ts` for a runnable counter example, `templates/spa-devtool.ts` for an SPA-ready shape, and `templates/vite-client.ts` for the author's client entry.
+`setup(ctx)` registers RPC functions, shared state, diagnostics, and any other devframe-level wiring. It does **not** receive `docks` / `terminals` / `messages` / `commands` — those are hub features. When mounted into Vite DevTools via `createPluginFromDevframe(d)`, the kit auto-derives an iframe dock entry from `id` / `name` / `icon` / `basePath`; for richer hub-side behaviour (custom-render, terminals, palette commands) pass `options.setup` to `createPluginFromDevframe`.
+
+See `templates/counter-devframe.ts` for a runnable counter example, `templates/spa-devframe.ts` for an SPA-ready shape, and `templates/vite-client.ts` for the author's client entry.
 
 ## Namespacing
 
-**Always prefix** RPC names, dock IDs, command IDs, shared-state keys, and agent tool IDs with the devtool `id`:
+**Always prefix** RPC names, dock IDs, command IDs, shared-state keys, and agent tool IDs with the devframe `id`:
 
 ```ts
 'my-inspector:get-modules' // ✓
 'my-inspector:state' // ✓
-'get-modules' // ✗ — may collide with other devtools sharing the host
+'get-modules' // ✗ — may collide with other devframes sharing the host
 ```
 
 ## DevToolsNodeContext at a glance
 
-`setup(ctx)` receives the full server-side surface. Each host corresponds to a [docs](https://devfra.me/) page:
+`setup(ctx)` receives the framework-neutral server-side surface. Each host corresponds to a [docs](https://devfra.me/) page:
 
 | Host | Purpose |
 |------|---------|
-| `ctx.rpc` | Register RPC functions, broadcast, shared state |
-| `ctx.docks` | Dock entries (iframe / action / custom-render / launcher / json-render) |
+| `ctx.rpc` | Register RPC functions, broadcast, shared state, streaming channels |
 | `ctx.views` | Serve static files via `hostStatic(base, distDir)` |
-| `ctx.commands` | Command palette entries with keybindings + `when` gating |
-| `ctx.messages` | Structured message entries, toasts, file / element positions |
 | `ctx.diagnostics` | Structured diagnostics host (logs-sdk) — register custom error codes |
-| `ctx.terminals` | Spawn and stream child processes |
 | `ctx.agent` | Expose tools + resources to coding agents (experimental) |
 | `ctx.host` | Runtime abstraction — `mountStatic`, `resolveOrigin`, `getStorageDir` |
 | `ctx.mode` | `'dev'` or `'build'` — gate setup work per runtime |
 
+> Hub-only hosts (`ctx.docks`, `ctx.terminals`, `ctx.messages`, `ctx.commands`, `ctx.createJsonRenderer`) only exist when the devframe is mounted into Vite DevTools via `createPluginFromDevframe`. See the [`vite-devtools-kit` skill](../../skills/vite-devtools-kit) for those.
+
 ## RPC contracts
 
 ```ts
@@ -240,84 +238,36 @@ Readable.fromWeb(reader.readable).pipe(targetNodeWritable)
 
 For chat-style UIs that combine both: keep the **conversation log** in shared state (survives reconnects), and use a streaming channel for **active responses**. The action that starts a response appends a placeholder to shared state; on producer close, commit the joined content back to shared state. Working example: [`devframe/examples/devframe-streaming-chat`](https://github.com/vitejs/devtools/tree/main/devframe/examples/devframe-streaming-chat).
 
-## Dock entries
+## Mounting into Vite DevTools
 
-Five entry types: `iframe` (full panel), `action` (client script on click), `custom-render` (mount into panel DOM), `launcher` (setup card + server callback), `json-render` (UI from a JSON spec, zero client code).
+A portable devframe definition is dropped into the Vite DevTools hub via `createPluginFromDevframe`:
 
 ```ts
-// Iframe — most common:
-ctx.docks.register({
-  id: 'my-inspector',
-  title: 'My Inspector',
-  icon: 'ph:magnifying-glass-duotone',
-  type: 'iframe',
-  url: '/.my-inspector/',
-})
-
-ctx.views.hostStatic('/.my-inspector/', clientDist)
+// vite.config.ts
+import { createPluginFromDevframe } from '@vitejs/devtools-kit/node'
+import myInspector from './my-inspector'
+
+export default {
+  plugins: [
+    createPluginFromDevframe(myInspector, {
+      // Optional kit-only setup — runs after the auto-derived dock entry.
+      setup(kitCtx) {
+        kitCtx.commands.register({
+          id: 'my-inspector:clear-cache',
+          title: 'Clear Cache',
+          handler: () => { /* ... */ },
+        })
+      },
+    }),
+  ],
+}
 ```
 
-All entries accept `when` for conditional visibility and `badge` for short indicator text. See `/devframe/dock-system` for the full type reference.
-
-### Remote docks
-
-Set `remote: true` on an iframe dock to turn a hosted URL into a live DevFrame client. DevFrame injects an auth-approved connection descriptor into the iframe URL; on the hosted page, `connectDevtool()` parses it and returns a fully connected client — no extra wiring. Dev-mode only.
-
-## Commands
-
-```ts
-import { defineCommand } from 'devframe'
-
-ctx.commands.register(defineCommand({
-  id: 'my-inspector:clear-cache',
-  title: 'Clear Cache',
-  icon: 'ph:trash-duotone',
-  keybindings: [{ key: 'Mod+Shift+C' }],
-  when: 'clientType == embedded',
-  handler: async () => clearCache(),
-}))
-```
-
-- Two-level hierarchy (parent + `children`) max.
-- Use `Mod` for platform-aware modifier (Cmd on macOS, Ctrl elsewhere).
-- `ctx.commands.execute(id, ...args)` runs a command programmatically.
-- `when` is a whenexpr expression — see below.
-
-## Logs & notifications
-
-```ts
-// Fire-and-forget
-ctx.messages.add({ message: 'Scan complete', level: 'success', notify: true })
-
-// With handle for in-place updates
-const handle = await ctx.messages.add({
-  id: 'my-inspector:build',
-  message: 'Building…',
-  level: 'info',
-  status: 'loading',
-})
-await handle.update({ message: 'Built', level: 'success', status: 'idle' })
-```
-
-`notify: true` also renders a toast. `filePosition: { file, line, column }` makes the entry click-to-editor. `elementPosition: { selector, boundingBox }` highlights a DOM element. Re-adding with the same `id` updates the existing entry (deduplication pattern).
-
-## Terminals
-
-```ts
-const session = await ctx.terminals.startChildProcess(
-  { command: 'vite', args: ['build', '--watch'], cwd: process.cwd() },
-  { id: 'my-inspector:build', title: 'Build', icon: 'ph:terminal-duotone' },
-)
-
-await session.terminate()
-await session.restart()
-```
-
-Color is enabled automatically (`FORCE_COLOR=true`). Output streams into the built-in Terminals panel and is buffered for late-joining clients.
+The kit auto-derives an iframe dock entry from `id` / `name` / `icon` / `basePath`. For dock variations (custom-render, launcher, action, json-render), terminals, palette commands, and toasts, use the `options.setup` hook — those APIs live on the kit-augmented context, not on the devframe-level `setup`. See the [`vite-devtools-kit` skill](../../skills/vite-devtools-kit) for the hub-side reference.
 
 ## When clauses
 
-Gate dock / command visibility with VS Code-style expressions (evaluated by the external `whenexpr` package):
+Gate kit-side dock / command visibility with VS Code-style expressions. The runtime + types ship bundled from `devframe/utils/when` — no separate install. The consumers (`when` field on docks and commands) live in the kit:
 
 ```ts
 when: 'clientType == embedded'
@@ -325,7 +275,7 @@ when: 'dockOpen && !paletteOpen'
 when: 'my-inspector.ready && count >= 10'
 ```
 
-Built-in context: `clientType` (`'embedded' | 'standalone'`), `dockOpen`, `paletteOpen`, `dockSelectedId`. Plugins can add namespaced keys (`.` or `:` separators). Both the types (`WhenExpression<Ctx, S>`) and runtime (`evaluateWhen`, `resolveContextValue`) are re-exported from `devframe/utils/when`.
+Built-in context: `clientType` (`'embedded' | 'standalone'`), `dockOpen`, `paletteOpen`, `dockSelectedId`. Plugins can add namespaced keys (`.` or `:` separators). Both the types (`WhenExpression<Ctx, S>`) and runtime (`evaluateWhen`, `resolveContextValue`) come from `devframe/utils/when`.
 
 ## Agent-native surface (experimental)
 
@@ -369,25 +319,25 @@ Expose via MCP:
 ```ts
 import { createMcpServer } from 'devframe/adapters/mcp'
 
-await createMcpServer(devtool, { transport: 'stdio' })
+await createMcpServer(devframe, { transport: 'stdio' })
 ```
 
-`@modelcontextprotocol/sdk` is a peer dependency. The CLI adapter also exposes `my-devtool mcp` — route host logs to stderr (stdout is the MCP transport). Safety classifications (`'read' | 'action' | 'destructive'`) drive MCP hint annotations that agent clients use to prompt for confirmation.
+`@modelcontextprotocol/sdk` is a peer dependency. The CLI adapter also exposes `my-devframe mcp` — route host logs to stderr (stdout is the MCP transport). Safety classifications (`'read' | 'action' | 'destructive'`) drive MCP hint annotations that agent clients use to prompt for confirmation.
 
 ## Author SPA
 
 Authors bring their own SPA (any framework or plain HTML). Client entry:
 
 ```ts
-import { connectDevtool } from 'devframe/client'
+import { connectDevframe } from 'devframe/client'
 
-const rpc = await connectDevtool()
+const rpc = await connectDevframe()
 // await rpc.ensureTrusted() // WS mode only — blocks until server accepts
 
 const data = await rpc.call('my-inspector:get-stats', { limit: 10 })
 ```
 
-`connectDevtool` auto-detects the backend via `/.devtools/.connection.json`:
+`connectDevframe` auto-detects the backend via `/.devtools/.connection.json`:
 
 - **websocket** (dev mode) — full read/write, requires auth handshake. Listen for token updates on the `vite-devtools-auth` BroadcastChannel.
 - **static** (build / spa output) — read-only, resolves calls from the baked RPC dump.
@@ -416,7 +366,7 @@ At runtime, static clients look up the argument hash in the dump; misses resolve
 
 ## CLI adapter subcommands
 
-`createCli(devtool).parse()` gives the tool four subcommands out of the box:
+`createCli(devframe).parse()` gives the tool four subcommands out of the box:
 
 | Subcommand | Action |
 |------------|--------|
@@ -427,26 +377,52 @@ At runtime, static clients look up the argument hash in the dump; misses resolve
 
 **Bring your own CLI framework?** `createCli` is just a cac wrapper around three peer factories — `createDevServer` (`devframe/adapters/dev`), `createBuild` (`devframe/adapters/build`), and `createMcpServer` (`devframe/adapters/mcp`). Use them directly with commander/yargs/oclif when `createCli`'s baked-in command structure doesn't fit. `createDevServer` returns a `StartedServer` handle (`origin`, `port`, `app`, `wss`, `close()`) so you can wire SIGINT / hot-reload teardown into the surrounding program. `parseCliFlags(schema, raw)` and `defineCliFlags(...)` (both from `devframe/adapters/cli`) validate an arbitrary flag bag against a `CliFlagsSchema` — typed flags aren't tied to cac.
 
+## Bundled utilities
+
+Devframe re-exports a curated set of helpers under `devframe/utils/*`. They are bundled — never add the underlying packages to a devtool's own `package.json`:
+
+| Import | Wraps | Use for |
+|--------|-------|---------|
+| `colors` from `devframe/utils/colors` | `ansis` | Terminal ANSI colors (`c.red`, `c.green`, tagged templates) |
+| `open` from `devframe/utils/open` | `open` | Open URLs / files in the OS default handler |
+| `launchEditor` from `devframe/utils/launch-editor` | `launch-editor` | Open `file:line:column` in the user's editor (optional `editor` arg) |
+| `hash` from `devframe/utils/hash` | `ohash` | Stable structural hash — cache keys, dedup |
+| `structuredClone{Serialize,Deserialize,Stringify,Parse}` from `devframe/utils/structured-clone` | `structured-clone-es` | JSON-safe round-trip of `Map` / `Set` / `Date` / `BigInt` / cycles |
+| `humanId` from `devframe/utils/human-id` | `human-id` | Human-readable IDs (`bright-orange-tiger`) |
+| `nanoid` from `devframe/utils/nanoid` | (vendored) | URL-safe random IDs |
+| `promiseWithResolver` from `devframe/utils/promise` | — | Externally-controlled `Promise` |
+| `createEventEmitter` from `devframe/utils/events` | — | Typed event bus |
+| `createSharedState` from `devframe/utils/shared-state` | (immer internal) | Immutable state container (see `ctx.rpc.sharedState`) |
+| `createStreamSink` / `createStreamReader` from `devframe/utils/streaming-channel` | — | Low-level streaming primitives |
+| `evaluateWhen` / `WhenExpression` from `devframe/utils/when` | `whenexpr` | When-clause expressions |
+
+For "open file in editor" + "reveal in finder", prefer the prebuilt `openHelpers` RPC recipe — it wires the two utilities into named RPC functions ready to register.
+
 ## Testing
 
 - Unit-test host classes with fake contexts.
-- Run `templates/counter-devtool.ts` under each adapter for integration coverage.
+- Run `templates/counter-devframe.ts` under each adapter for integration coverage.
 - Snapshot the build-static RPC dump (`<outDir>/.devtools/.rpc-dump/index.json`) to catch accidental drift in `static` function outputs.
 
 ## Further reading
 
-All of the above has a dedicated page at [devfra.me](https://devfra.me/):
+Devframe-level pages (one-tool, portable surface):
 
-- [Devtool Definition](https://devfra.me/devtool-definition) — fields, runtime flags, multi-adapter wiring
-- [Adapters](https://devfra.me/adapters) — full reference for all seven adapters
+- [Devframe Definition](https://devfra.me/devframe-definition) — fields, runtime flags, multi-adapter wiring
+- [Adapters](https://devfra.me/adapters) — full reference for all deployment adapters
 - [RPC](https://devfra.me/rpc) — types, schema, broadcasts, dumps
 - [Shared State](https://devfra.me/shared-state) — patches, events, client-side mutation
 - [Streaming](https://devfra.me/streaming) — chunked feeds, uploads, replay, Web/Node Streams interop
-- [Dock System](https://devfra.me/dock-system) — every entry type + remote docks
-- [Commands](https://devfra.me/commands) — palette, keybindings, sub-commands
 - [When Clauses](https://devfra.me/when-clauses) — syntax, context, type-safe wrappers
-- [Messages & Notifications](https://devfra.me/messages) — entry fields, positional hints
 - [Structured Diagnostics](https://devfra.me/diagnostics) — coded errors via `ctx.diagnostics`, register custom codes
-- [Terminals](https://devfra.me/terminals) — child processes, external sessions
+- [Utilities](https://devfra.me/utilities) — bundled `devframe/utils/*` helpers (colors, hash, launchEditor, structured-clone, …)
 - [Client](https://devfra.me/client) — auth handshake, modes, discovery
 - [Agent-Native](https://devfra.me/agent-native) — agent field, tools/resources, MCP + Claude Desktop
+
+Hub-only surfaces (Vite DevTools Kit — only available when mounted into the hub):
+
+- [Vite DevTools Kit overview](https://devtools.vite.dev/kit/)
+- [Dock System](https://devtools.vite.dev/kit/dock-system) — every entry type + remote docks
+- [Commands](https://devtools.vite.dev/kit/commands) — palette, keybindings, sub-commands
+- [Messages & Notifications](https://devtools.vite.dev/kit/messages) — entry fields, positional hints
+- [Terminals](https://devtools.vite.dev/kit/terminals) — child processes, external sessions

package/skills/devframe/templates/{counter-devtool.ts → counter-devframe.ts}

@@ -1,9 +1,11 @@
-// Smallest possible devtool.
-import { defineDevtool, defineRpcFunction } from 'devframe'
+// Smallest possible devframe. The dock entry is auto-derived from
+// `id` / `name` / `icon` when this definition is mounted into Vite
+// DevTools via `createPluginFromDevframe(devframe)`.
+import { defineDevframe, defineRpcFunction } from 'devframe'
 
 let counter = 0
 
-export default defineDevtool({
+export default defineDevframe({
   id: 'counter',
   name: 'Counter',
   icon: 'ph:counter-duotone',
@@ -18,12 +20,5 @@ export default defineDevtool({
       type: 'action',
       handler: () => ({ count: ++counter }),
     }))
-    ctx.docks.register({
-      id: 'counter',
-      title: 'Counter',
-      icon: 'ph:counter-duotone',
-      type: 'iframe',
-      url: '/counter/',
-    })
   },
 })

package/skills/devframe/templates/{spa-devtool.ts → spa-devframe.ts}

@@ -1,8 +1,10 @@
-// Devtool with setupBrowser + SPA query-loader — deployable as a static site.
-import { defineDevtool, defineRpcFunction } from 'devframe'
+// Devframe with setupBrowser + SPA query-loader — deployable as a static site.
+// When mounted into Vite DevTools via `createPluginFromDevframe`, the kit
+// auto-derives an iframe dock from `id` / `name` / `icon`.
+import { defineDevframe, defineRpcFunction } from 'devframe'
 import * as v from 'valibot'
 
-export default defineDevtool({
+export default defineDevframe({
   id: 'my-inspector',
   name: 'My Inspector',
   icon: 'ph:magnifying-glass-duotone',
@@ -16,13 +18,6 @@ export default defineDevtool({
         return { url, verdict: 'ok' as const }
       },
     }))
-    ctx.docks.register({
-      id: 'my-inspector',
-      title: 'My Inspector',
-      icon: 'ph:magnifying-glass-duotone',
-      type: 'iframe',
-      url: '/my-inspector/',
-    })
   },
   setupBrowser() {
     // Browser-side implementation — used by the SPA adapter so the

package/skills/devframe/templates/vite-client.ts

@@ -1,8 +1,8 @@
 // Minimum SPA client that talks to a devframe-hosted RPC.
-import { connectDevtool } from 'devframe/client'
+import { connectDevframe } from 'devframe/client'
 
 async function main() {
-  const rpc = await connectDevtool()
+  const rpc = await connectDevframe()
   // The method names below are just examples — replace with your own.
   const data = await rpc.call('my-inspector:getStats' as any)
   document.getElementById('root')!.textContent = JSON.stringify(data)

package/dist/adapters/kit.d.mts

@@ -1,23 +0,0 @@
-import { r as DevtoolDefinition } from "../devtool-Bm6zZAw5.mjs";
-
-//#region src/adapters/kit.d.ts
-interface CreateKitPluginOptions {
-  /**
-   * Optional plugin name override. Defaults to `devframe:<devtool-id>`.
-   */
-  name?: string;
-}
-interface KitPlugin {
-  name: string;
-  devtools: {
-    setup: DevtoolDefinition['setup'];
-    capabilities?: DevtoolDefinition['capabilities'];
-  };
-}
-/**
- * Produce a Vite plugin object that Kit's plugin-scan picks up via
- * `Plugin.devtools`.
- */
-declare function createKitPlugin(d: DevtoolDefinition, options?: CreateKitPluginOptions): KitPlugin;
-//#endregion
-export { CreateKitPluginOptions, KitPlugin, createKitPlugin };

package/dist/adapters/kit.mjs

@@ -1,16 +0,0 @@
-//#region src/adapters/kit.ts
-/**
-* Produce a Vite plugin object that Kit's plugin-scan picks up via
-* `Plugin.devtools`.
-*/
-function createKitPlugin(d, options = {}) {
-	return {
-		name: options.name ?? `devframe:${d.id}`,
-		devtools: {
-			setup: d.setup,
-			capabilities: d.capabilities
-		}
-	};
-}
-//#endregion
-export { createKitPlugin };