devframe 0.1.21 → 0.2.0

package/skills/devframe/SKILL.md

@@ -1,50 +1,53 @@
 ---
 name: devframe
 description: >
-  Use when building one devtool integration with devframe — the
-  portable, framework-neutral container for a single tool. Covers
-  DevtoolDefinition, picking the right deployment adapter
+  Use when building a devtool with devframe — the
+  framework- and build-tool-agnostic foundation for defining a
+  devtool once and serving it in many places. 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, `defineDevtool`,
-  `createCli`, `createMcpServer`, `connectDevtool`, and on
-  migrations of existing inspectors (eslint-config-inspector,
-  unocss-inspector, node-modules-inspector-style tools) to devframe.
+  contracts, exposing an agent-native surface over MCP, and
+  wiring the author's SPA client. For host-level features (docks,
+  terminals, palette, etc.), the devframe can be mounted into a
+  host that provides them — Vite DevTools is one supported target,
+  reached via the `vite` adapter. 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
 
-**Devframe is the container for one devtool integration, portable across viewers.** A devtool built on devframe is a single `DevtoolDefinition` 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 is an asset: define your devtool once, serve it anywhere.** A devtool built on devframe is a single `DevframeDefinition` plus an author-provided SPA — the same definition deploys through a set of pluggable adapters (standalone CLI, static report, embedded SPA, MCP server, mounted into a host, etc.). Devframe is framework- and build-tool-agnostic; it has no Vite dependency and makes no UI-framework assumption.
 
-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.
+Devframe describes one tool. If you need host-level features (cross-tool palette, integrated terminals, dock aggregation), mount the devframe into a host that provides them — [Vite DevTools](https://devtools.vite.dev/) is the canonical example, reached via the `vite` adapter — or build your own host adapter. `devframe` itself must not depend on Vite or any `@vitejs/*` package.
 
 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 |
 |-------------|---------|-------|
 | Standalone CLI for local use | `createCli(def, options?)` | `devframe/adapters/cli` |
 | 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 | `createPluginFromDevframe(def, options?)` | `@vitejs/devtools-kit/node` |
+| Mount into a host (Vite DevTools or any compatible host) | `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
+For Vite-based hosts that don't use the kit (Nuxt, Astro, SolidStart, plain Vite apps), `devframe/helpers/vite` exports `viteDevBridge(def, options?)` — a Vite plugin that mounts the SPA (static mode) or starts the RPC + WS bridge alongside the host's dev server (`devMiddleware: true`). Not an adapter; just a Vite integration helper.
+
+## 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',
@@ -59,18 +62,18 @@ export default defineDevtool({
 })
 ```
 
-`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`.
+`setup(ctx)` registers RPC functions, shared state, diagnostics, and any other devframe-level wiring. Host adapters can augment `ctx` with extra surfaces — for example, mounting into Vite DevTools via `createPluginFromDevframe(d)` exposes `docks`, `terminals`, `messages`, and `commands` on the augmented context, and the kit auto-derives an iframe dock entry from `id` / `name` / `icon` / `basePath`. For richer host-side behaviour (custom-render, terminals, palette commands) pass `options.setup` to `createPluginFromDevframe`.
 
-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.
+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
@@ -86,7 +89,7 @@ See `templates/counter-devtool.ts` for a runnable counter example, `templates/sp
 | `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`) only exist when the devtool is mounted into Vite DevTools via `createPluginFromDevframe`. See the [`vite-devtools-kit` skill](../../skills/vite-devtools-kit) for those.
+> Hosts can augment `ctx` with additional surfaces (e.g. Vite DevTools' `docks`, `terminals`, `messages`, `commands`, `createJsonRenderer`). Consult the host's docs — for Vite DevTools, see the [`vite-devtools-kit` skill](../../skills/vite-devtools-kit).
 
 ## RPC contracts
 
@@ -238,9 +241,9 @@ 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).
 
-## Mounting into Vite DevTools
+## Mounting into a host (Vite DevTools example)
 
-A portable devframe definition is dropped into the Vite DevTools hub via `createPluginFromDevframe`:
+A portable devframe can be mounted into any host that ships an adapter for it. Vite DevTools is one supported target — `createPluginFromDevframe` is the Vite-DevTools-specific bridge; other hosts can implement equivalent factories. Example:
 
 ```ts
 // vite.config.ts
@@ -263,11 +266,11 @@ export default {
 }
 ```
 
-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.
+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 host-augmented context, not on the devframe-level `setup`. See the [`vite-devtools-kit` skill](../../skills/vite-devtools-kit) for the Vite-DevTools-specific reference.
 
 ## When clauses
 
-Gate kit-side dock / command visibility with VS Code-style expressions evaluated by the external `whenexpr` package. The runtime + types ship from `devframe/utils/when`, but the consumers (`when` field on docks and commands) live in the kit:
+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'
@@ -275,7 +278,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)
 
@@ -319,25 +322,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.
@@ -366,7 +369,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 |
 |------------|--------|
@@ -377,27 +380,49 @@ 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
 
 Devframe-level pages (one-tool, portable surface):
 
-- [Devtool Definition](https://devfra.me/devtool-definition) — fields, runtime flags, multi-adapter wiring
+- [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
 - [When Clauses](https://devfra.me/when-clauses) — syntax, context, type-safe wrappers
 - [Structured Diagnostics](https://devfra.me/diagnostics) — coded errors via `ctx.diagnostics`, register custom codes
+- [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):
+Host-specific extras (when mounting into Vite DevTools — other hosts have their own equivalents):
 
 - [Vite DevTools Kit overview](https://devtools.vite.dev/kit/)
 - [Dock System](https://devtools.vite.dev/kit/dock-system) — every entry type + remote docks

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

@@ -1,11 +1,11 @@
-// Smallest possible devtool. The dock entry is auto-derived from
+// Smallest possible devframe. The dock entry is auto-derived from
 // `id` / `name` / `icon` when this definition is mounted into Vite
-// DevTools via `createPluginFromDevframe(devtool)`.
-import { defineDevtool, defineRpcFunction } from 'devframe'
+// 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',

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

@@ -1,10 +1,10 @@
-// Devtool 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 { defineDevtool, defineRpcFunction } from 'devframe'
+// Devframe with setupBrowser + SPA query-loader — deployable as a static site.
+// Host adapters (e.g. the `vite` adapter for Vite DevTools) auto-derive their
+// mount entry 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',

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/vite.d.mts

@@ -1,33 +0,0 @@
-import { r as DevtoolDefinition } from "../devtool-CNvLs2_Y.mjs";
-
-//#region src/adapters/vite.d.ts
-interface CreateVitePluginOptions {
-  /**
-   * Mount base. Defaults to `def.basePath ?? '/__<id>/'` for this hosted
-   * adapter — the devtool shares the origin with the host Vite app.
-   */
-  base?: string;
-}
-interface DevframeVitePlugin {
-  name: string;
-  apply: 'serve';
-  configureServer: (server: {
-    middlewares: {
-      use: (path: string, handler: any) => void;
-    };
-  }) => void;
-}
-/**
- * Plain Vite plugin — mounts a devframe devtool's SPA into a user's
- * Vite dev server at `options.base` (default: `def.basePath ?? '/__<id>/'`).
- * Use this for tools that want the Vite dev experience without
- * pulling the full Vite DevTools Kit.
- *
- * Note: this does not yet spin up the RPC WS server — for the full
- * RPC path, use `createPluginFromDevframe` from
- * `@vitejs/devtools-kit/node` alongside `@vitejs/devtools`, or the
- * standalone `createCli`.
- */
-declare function createVitePlugin(d: DevtoolDefinition, options?: CreateVitePluginOptions): DevframeVitePlugin;
-//#endregion
-export { CreateVitePluginOptions, DevframeVitePlugin, createVitePlugin };

package/dist/adapters/vite.mjs

@@ -1,32 +0,0 @@
-import { n as resolveBasePath } from "../_shared-iZy45oG3.mjs";
-import { resolve } from "pathe";
-import sirv from "sirv";
-//#region src/adapters/vite.ts
-/**
-* Plain Vite plugin — mounts a devframe devtool's SPA into a user's
-* Vite dev server at `options.base` (default: `def.basePath ?? '/__<id>/'`).
-* Use this for tools that want the Vite dev experience without
-* pulling the full Vite DevTools Kit.
-*
-* Note: this does not yet spin up the RPC WS server — for the full
-* RPC path, use `createPluginFromDevframe` from
-* `@vitejs/devtools-kit/node` alongside `@vitejs/devtools`, or the
-* standalone `createCli`.
-*/
-function createVitePlugin(d, options = {}) {
-	const base = 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, sirv(resolve(distDir), {
-				dev: true,
-				single: true
-			}));
-		}
-	};
-}
-//#endregion
-export { createVitePlugin };

package/dist/internal/index.d.mts

@@ -1,16 +0,0 @@
-import { i as DevtoolDeploymentKind, r as DevtoolDefinition } from "../devtool-CNvLs2_Y.mjs";
-import { a as internalContextMap, i as getInternalContext, n as InternalAnonymousAuthStorage, r as RemoteTokenRecord, t as DevToolsInternalContext } from "../context-internal-saIAfNVw.mjs";
-
-//#region src/adapters/_shared.d.ts
-/**
- * Resolve the mount base path for a devtool's SPA. Hosted adapters
- * (`vite`, `kit`, `embedded`) default to `/__<id>/` so they don't
- * collide with the host app; standalone adapters (`cli`, `spa`,
- * `build`) default to `/` because they own the origin.
- *
- * The devtool author can override with `basePath` on the definition.
- */
-declare function resolveBasePath(def: DevtoolDefinition, kind: DevtoolDeploymentKind): string;
-declare function normalizeBasePath(base: string): string;
-//#endregion
-export { type DevToolsInternalContext, type InternalAnonymousAuthStorage, type RemoteTokenRecord, getInternalContext, internalContextMap, normalizeBasePath, resolveBasePath };

package/dist/internal/index.mjs

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

package/dist/utils/state.d.mts

@@ -1,50 +0,0 @@
-import { ct as EventEmitter } from "../devtool-CNvLs2_Y.mjs";
-import { Objectish, Patch } from "immer";
-
-//#region src/utils/state.d.ts
-type ImmutablePrimitive = undefined | null | boolean | string | number | Function;
-type Immutable<T> = T extends ImmutablePrimitive ? T : T extends Array<infer U> ? ImmutableArray<U> : T extends Map<infer K, infer V> ? ImmutableMap<K, V> : T extends Set<infer M> ? ImmutableSet<M> : ImmutableObject<T>;
-type ImmutableArray<T> = ReadonlyArray<Immutable<T>>;
-type ImmutableMap<K, V> = ReadonlyMap<Immutable<K>, Immutable<V>>;
-type ImmutableSet<T> = ReadonlySet<Immutable<T>>;
-type ImmutableObject<T> = { readonly [K in keyof T]: Immutable<T[K]> };
-/**
- * State host that is immutable by default with explicit mutate.
- */
-interface SharedState<T> {
-  /**
-   * Get the current state. Immutable.
-   */
-  get: () => Immutable<T>;
-  /**
-   * Subscribe to state changes.
-   */
-  on: EventEmitter<SharedStateEvents<T>>['on'];
-  /**
-   * Mutate the state.
-   */
-  mutate: (fn: (state: T) => void) => void;
-  /**
-   * Apply patches to the state.
-   */
-  patch: (patches: Patch[]) => void;
-}
-interface SharedStateEvents<T> {
-  updated: (state: T) => void;
-  patches: (patches: Patch[]) => void;
-}
-interface SharedStateOptions<T> {
-  /**
-   * Initial state.
-   */
-  initialState: T;
-  /**
-   * Enable patches.
-   *
-   * @default false
-   */
-  enablePatches?: boolean;
-}
-declare function createSharedState<T extends Objectish>(options: SharedStateOptions<T>): SharedState<T>;
-//#endregion
-export { Immutable, ImmutableArray, ImmutableMap, ImmutableObject, ImmutableSet, SharedState, SharedStateEvents, SharedStateOptions, createSharedState };

package/dist/utils/state.mjs

@@ -1,26 +0,0 @@
-import { createEventEmitter } from "./events.mjs";
-import { applyPatches, produce, produceWithPatches } from "immer";
-//#region src/utils/state.ts
-function createSharedState(options) {
-	const { enablePatches = false } = options;
-	const events = createEventEmitter();
-	let state = options.initialState;
-	return {
-		on: events.on,
-		get: () => state,
-		patch: (patches) => {
-			state = applyPatches(state, patches);
-			events.emit("updated", state);
-		},
-		mutate: (fn) => {
-			if (enablePatches) {
-				const [newState, patches] = produceWithPatches(state, fn);
-				state = newState;
-				events.emit("patches", patches);
-			} else state = produce(state, fn);
-			events.emit("updated", state);
-		}
-	};
-}
-//#endregion
-export { createSharedState };

package/dist/{host-h3-9jeHcltx.mjs → host-h3-Dz8YnFgu.mjs}

@@ -1,6 +1,6 @@
-import { join } from "pathe";
 import { homedir } from "node:os";
 import process from "node:process";
+import { join } from "pathe";
 //#region src/node/host-h3.ts
 /**
 * h3-backed {@link DevToolsHost} — used by the standalone CLI adapter.