devframe 0.0.0 → 0.1.17

package/dist/when-aBBXAEh5.d.mts

@@ -0,0 +1,401 @@
+//#region ../../../node_modules/.pnpm/whenexpr@0.1.2/node_modules/whenexpr/dist/index.d.mts
+//#region src/paths.d.ts
+/**
+ * Union of valid context paths for `T` — both flat keys (`keyof T`) and
+ * `.`/`:`-separated nested paths. Mirrors the runtime `resolve()` lookup:
+ * first a flat literal key, then a segmented path.
+ *
+ * @example
+ * type P = ContextPaths<{ editor: { lang: string }, debug: boolean }>
+ * // 'editor' | 'debug' | 'editor.lang' | 'editor:lang'
+ */
+type ContextPaths<T, P extends string = ''> = { [K in keyof T & string]: `${P}${K}` | (T[K] extends readonly unknown[] ? never : T[K] extends ((...args: never[]) => unknown) ? never : T[K] extends object ? ContextPaths<T[K], `${P}${K}.`> | ContextPaths<T[K], `${P}${K}:`> : never) }[keyof T & string]; //#endregion
+//#region src/types.d.ts
+/**
+ * Branded error type surfaced at the call site of `evaluateWhen` when the
+ * expression string fails static validation. The embedded message appears in
+ * the TS error tooltip because `WhenExpressionError<M>` is not assignable from a
+ * plain string literal.
+ */
+type WhenExpressionError<M extends string> = string & {
+  readonly __whenExpressionError: M;
+};
+type Ws = ' ' | '\t' | '\n' | '\r';
+type Digit = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9';
+type Lower = 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i' | 'j' | 'k' | 'l' | 'm' | 'n' | 'o' | 'p' | 'q' | 'r' | 's' | 't' | 'u' | 'v' | 'w' | 'x' | 'y' | 'z';
+type Upper = 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'G' | 'H' | 'I' | 'J' | 'K' | 'L' | 'M' | 'N' | 'O' | 'P' | 'Q' | 'R' | 'S' | 'T' | 'U' | 'V' | 'W' | 'X' | 'Y' | 'Z';
+type IdentStart = Lower | Upper | '_' | '$';
+type IdentCont = IdentStart | Digit | '.' | ':';
+type Op = '===' | '!==' | '==' | '!=' | '<=' | '>=' | '&&' | '||' | '<' | '>' | '+' | '-' | '*' | '/' | '%' | '!';
+type Tok = {
+  k: 'num';
+  v: string;
+} | {
+  k: 'str';
+  v: string;
+} | {
+  k: 'id';
+  v: string;
+} | {
+  k: 'bool';
+  v: 'true' | 'false';
+} | {
+  k: 'op';
+  v: Op;
+} | {
+  k: 'lp';
+} | {
+  k: 'rp';
+} | {
+  k: 'eof';
+};
+interface TokErr {
+  __err: string;
+}
+type Tokenize<S extends string, Acc extends Tok[] = []> = S extends '' ? [...Acc, {
+  k: 'eof';
+}] : S extends `${Ws}${infer R}` ? Tokenize<R, Acc> : S extends `===${infer R}` ? Tokenize<R, [...Acc, {
+  k: 'op';
+  v: '===';
+}]> : S extends `!==${infer R}` ? Tokenize<R, [...Acc, {
+  k: 'op';
+  v: '!==';
+}]> : S extends `==${infer R}` ? Tokenize<R, [...Acc, {
+  k: 'op';
+  v: '==';
+}]> : S extends `!=${infer R}` ? Tokenize<R, [...Acc, {
+  k: 'op';
+  v: '!=';
+}]> : S extends `<=${infer R}` ? Tokenize<R, [...Acc, {
+  k: 'op';
+  v: '<=';
+}]> : S extends `>=${infer R}` ? Tokenize<R, [...Acc, {
+  k: 'op';
+  v: '>=';
+}]> : S extends `&&${infer R}` ? Tokenize<R, [...Acc, {
+  k: 'op';
+  v: '&&';
+}]> : S extends `||${infer R}` ? Tokenize<R, [...Acc, {
+  k: 'op';
+  v: '||';
+}]> : S extends `<${infer R}` ? Tokenize<R, [...Acc, {
+  k: 'op';
+  v: '<';
+}]> : S extends `>${infer R}` ? Tokenize<R, [...Acc, {
+  k: 'op';
+  v: '>';
+}]> : S extends `+${infer R}` ? Tokenize<R, [...Acc, {
+  k: 'op';
+  v: '+';
+}]> : S extends `-${infer R}` ? Tokenize<R, [...Acc, {
+  k: 'op';
+  v: '-';
+}]> : S extends `*${infer R}` ? Tokenize<R, [...Acc, {
+  k: 'op';
+  v: '*';
+}]> : S extends `/${infer R}` ? Tokenize<R, [...Acc, {
+  k: 'op';
+  v: '/';
+}]> : S extends `%${infer R}` ? Tokenize<R, [...Acc, {
+  k: 'op';
+  v: '%';
+}]> : S extends `!${infer R}` ? Tokenize<R, [...Acc, {
+  k: 'op';
+  v: '!';
+}]> : S extends `(${infer R}` ? Tokenize<R, [...Acc, {
+  k: 'lp';
+}]> : S extends `)${infer R}` ? Tokenize<R, [...Acc, {
+  k: 'rp';
+}]> : S extends `"${infer R}` ? ConsumeStr<R, '', '"', Acc> : S extends `'${infer R}` ? ConsumeStr<R, '', '\'', Acc> : S extends `${infer C extends Digit}${infer R}` ? ConsumeNum<R, C, Acc> : S extends `${infer C extends IdentStart}${infer R}` ? ConsumeIdent<R, C, Acc> : {
+  __err: `Unexpected character in "${S}"`;
+};
+type ConsumeNum<S extends string, N extends string, Acc extends Tok[]> = S extends `${infer C extends Digit}${infer R}` ? ConsumeNum<R, `${N}${C}`, Acc> : S extends `.${infer C extends Digit}${infer R}` ? ConsumeNumFrac<R, `${N}.${C}`, Acc> : Tokenize<S, [...Acc, {
+  k: 'num';
+  v: N;
+}]>;
+type ConsumeNumFrac<S extends string, N extends string, Acc extends Tok[]> = S extends `${infer C extends Digit}${infer R}` ? ConsumeNumFrac<R, `${N}${C}`, Acc> : Tokenize<S, [...Acc, {
+  k: 'num';
+  v: N;
+}]>;
+type ConsumeIdent<S extends string, N extends string, Acc extends Tok[]> = S extends `${infer C extends IdentCont}${infer R}` ? ConsumeIdent<R, `${N}${C}`, Acc> : Tokenize<S, [...Acc, ClassifyIdent<N>]>;
+type ClassifyIdent<N extends string> = N extends 'true' ? {
+  k: 'bool';
+  v: 'true';
+} : N extends 'false' ? {
+  k: 'bool';
+  v: 'false';
+} : {
+  k: 'id';
+  v: N;
+};
+type ConsumeStr<S extends string, V extends string, Q extends '"' | '\'', Acc extends Tok[]> = S extends `${Q}${infer R}` ? Tokenize<R, [...Acc, {
+  k: 'str';
+  v: V;
+}]> : S extends `\\${infer C}${infer R}` ? ConsumeStr<R, `${V}${C}`, Q, Acc> : S extends `${infer C}${infer R}` ? ConsumeStr<R, `${V}${C}`, Q, Acc> : {
+  __err: 'Unterminated string literal';
+};
+type BinOp = '||' | '&&' | '==' | '!=' | '===' | '!==' | '<' | '>' | '<=' | '>=' | '+' | '-' | '*' | '/' | '%';
+type UnOp = '!' | '-' | '+';
+interface LitNode {
+  t: 'lit';
+  v: string;
+}
+interface KeyNode {
+  t: 'key';
+  v: string;
+}
+interface UnNode {
+  t: 'un';
+  op: UnOp;
+  x: Ast;
+}
+interface BinNode {
+  t: 'bin';
+  op: BinOp;
+  l: Ast;
+  r: Ast;
+}
+type Ast = LitNode | KeyNode | UnNode | BinNode;
+type Parse<Toks extends Tok[]> = ParseOr<Toks>;
+type ParseOr<T extends Tok[]> = OrTail<ParseAnd<T>>;
+type OrTail<R> = R extends [infer L extends Ast, infer Rest extends Tok[]] ? Rest extends [{
+  k: 'op';
+  v: '||';
+}, ...infer After extends Tok[]] ? ParseAnd<After> extends [infer Rh extends Ast, infer Next extends Tok[]] ? OrTail<[{
+  t: 'bin';
+  op: '||';
+  l: L;
+  r: Rh;
+}, Next]> : 'err' : R : R;
+type ParseAnd<T extends Tok[]> = AndTail<ParseEq<T>>;
+type AndTail<R> = R extends [infer L extends Ast, infer Rest extends Tok[]] ? Rest extends [{
+  k: 'op';
+  v: '&&';
+}, ...infer After extends Tok[]] ? ParseEq<After> extends [infer Rh extends Ast, infer Next extends Tok[]] ? AndTail<[{
+  t: 'bin';
+  op: '&&';
+  l: L;
+  r: Rh;
+}, Next]> : 'err' : R : R;
+type ParseEq<T extends Tok[]> = EqTail<ParseRel<T>>;
+type EqTail<R> = R extends [infer L extends Ast, infer Rest extends Tok[]] ? Rest extends [{
+  k: 'op';
+  v: infer O extends '==' | '!=';
+}, ...infer After extends Tok[]] ? ParseValueRhs<After> extends [infer Rh extends Ast, infer Next extends Tok[]] ? EqTail<[{
+  t: 'bin';
+  op: O;
+  l: L;
+  r: Rh;
+}, Next]> : 'err' : Rest extends [{
+  k: 'op';
+  v: infer O extends '===' | '!==';
+}, ...infer After extends Tok[]] ? ParseRel<After> extends [infer Rh extends Ast, infer Next extends Tok[]] ? EqTail<[{
+  t: 'bin';
+  op: O;
+  l: L;
+  r: Rh;
+}, Next]> : 'err' : R : R;
+type ParseValueRhs<T extends Tok[]> = T extends [{
+  k: 'id';
+  v: infer V extends string;
+}, ...infer R extends Tok[]] ? [{
+  t: 'lit';
+  v: V;
+}, R] : T extends [{
+  k: 'str';
+  v: infer V extends string;
+}, ...infer R extends Tok[]] ? [{
+  t: 'lit';
+  v: V;
+}, R] : T extends [{
+  k: 'num';
+  v: infer V extends string;
+}, ...infer R extends Tok[]] ? [{
+  t: 'lit';
+  v: V;
+}, R] : T extends [{
+  k: 'bool';
+  v: infer V extends string;
+}, ...infer R extends Tok[]] ? [{
+  t: 'lit';
+  v: V;
+}, R] : 'err';
+type ParseRel<T extends Tok[]> = RelTail<ParseAdd<T>>;
+type RelTail<R> = R extends [infer L extends Ast, infer Rest extends Tok[]] ? Rest extends [{
+  k: 'op';
+  v: infer O extends '<=' | '>=' | '<' | '>';
+}, ...infer After extends Tok[]] ? ParseAdd<After> extends [infer Rh extends Ast, infer Next extends Tok[]] ? RelTail<[{
+  t: 'bin';
+  op: O;
+  l: L;
+  r: Rh;
+}, Next]> : 'err' : R : R;
+type ParseAdd<T extends Tok[]> = AddTail<ParseMul<T>>;
+type AddTail<R> = R extends [infer L extends Ast, infer Rest extends Tok[]] ? Rest extends [{
+  k: 'op';
+  v: infer O extends '+' | '-';
+}, ...infer After extends Tok[]] ? ParseMul<After> extends [infer Rh extends Ast, infer Next extends Tok[]] ? AddTail<[{
+  t: 'bin';
+  op: O;
+  l: L;
+  r: Rh;
+}, Next]> : 'err' : R : R;
+type ParseMul<T extends Tok[]> = MulTail<ParseUnary<T>>;
+type MulTail<R> = R extends [infer L extends Ast, infer Rest extends Tok[]] ? Rest extends [{
+  k: 'op';
+  v: infer O extends '*' | '/' | '%';
+}, ...infer After extends Tok[]] ? ParseUnary<After> extends [infer Rh extends Ast, infer Next extends Tok[]] ? MulTail<[{
+  t: 'bin';
+  op: O;
+  l: L;
+  r: Rh;
+}, Next]> : 'err' : R : R;
+type ParseUnary<T extends Tok[]> = T extends [{
+  k: 'op';
+  v: infer O extends UnOp;
+}, ...infer Rest extends Tok[]] ? ParseUnary<Rest> extends [infer X extends Ast, infer Next extends Tok[]] ? [{
+  t: 'un';
+  op: O;
+  x: X;
+}, Next] : 'err' : ParsePrimary<T>;
+type ParsePrimary<T extends Tok[]> = T extends [{
+  k: 'num';
+  v: infer V extends string;
+}, ...infer R extends Tok[]] ? [{
+  t: 'lit';
+  v: V;
+}, R] : T extends [{
+  k: 'str';
+  v: infer V extends string;
+}, ...infer R extends Tok[]] ? [{
+  t: 'lit';
+  v: V;
+}, R] : T extends [{
+  k: 'bool';
+  v: infer V extends string;
+}, ...infer R extends Tok[]] ? [{
+  t: 'lit';
+  v: V;
+}, R] : T extends [{
+  k: 'id';
+  v: infer V extends string;
+}, ...infer R extends Tok[]] ? [{
+  t: 'key';
+  v: V;
+}, R] : T extends [{
+  k: 'lp';
+}, ...infer Rest extends Tok[]] ? ParseOr<Rest> extends [infer N extends Ast, infer After extends Tok[]] ? After extends [{
+  k: 'rp';
+}, ...infer Next extends Tok[]] ? [N, Next] : 'err' : 'err' : 'err';
+type CollectKeys<N> = N extends KeyNode ? N['v'] : N extends UnNode ? CollectKeys<N['x']> : N extends {
+  t: 'bin';
+  op: '==' | '!=';
+  l: infer L;
+} ? CollectKeys<L> : N extends BinNode ? CollectKeys<N['l']> | CollectKeys<N['r']> : never;
+/**
+ * Validate a when-clause expression string `S` against context type `T`.
+ * Returns `S` on success, or a `WhenExpressionError<Msg>` branded error string
+ * that surfaces at the call site with a human-readable message.
+ *
+ * - Dynamic `string` expressions skip all validation.
+ * - Wide context types (`object`, `any`, `unknown`, `Record<string, unknown>`,
+ *   empty `{}`, etc.) still run **syntax** checking but skip **key** checking.
+ * - Specific context types run full validation (syntax + keys).
+ */
+type ValidateExpression<S extends string, T> = string extends S ? S : Tokenize<S> extends infer Toks ? Toks extends TokErr ? WhenExpressionError<`Syntax error: ${Toks['__err']}`> : Toks extends Tok[] ? Parse<Toks> extends [infer N extends Ast, [{
+  k: 'eof';
+}]] ? [keyof T] extends [never] ? S : string extends keyof T ? S : Exclude<CollectKeys<N>, ContextPaths<T>> extends infer Missing ? [Missing] extends [never] ? S : WhenExpressionError<`Unknown context key: "${Extract<Missing, string>}"`> : never : WhenExpressionError<'Syntax error in expression'> : never : never;
+/**
+ * A when-clause expression string validated against context type `T`.
+ * Use inside your own typed define helpers to have TypeScript check `when`
+ * fields at the call site.
+ *
+ * @example
+ * interface AppCtx { mode: 'dev' | 'prod', debug: boolean }
+ *
+ * function defineCommand<const W extends string>(cmd: {
+ *   name: string
+ *   title: string
+ *   when?: WhenExpression<AppCtx, W>
+ * }): typeof cmd {
+ *   return cmd
+ * }
+ *
+ * defineCommand({ name: 'x', title: 'X', when: 'debug && mode == dev' })
+ * defineCommand({ name: 'x', title: 'X', when: 'typo' })
+ * //                                            ^^^^^ type error
+ */
+type WhenExpression<T, S extends string> = S & ValidateExpression<S, T>; //#endregion
+//#region src/index.d.ts
+interface EvaluateOptions {
+  /**
+   * If `true`, throw when the expression references a context key that does
+   * not exist. Defaults to `false`, where unknown keys evaluate to `undefined`.
+   */
+  strict?: boolean;
+}
+/**
+ * Evaluate a when-clause expression string against a context object.
+ * Equivalent to `evaluate(parse(expression), ctx, options)`.
+ *
+ * Supports a JS-expression subset:
+ * - Literals: booleans, numbers, strings (quoted with `"` or `'`)
+ * - Identifiers: bare keys, including namespaced (`vite.mode`, `vite:buildMode`)
+ * - Logical: `&&`, `||`, `!`
+ * - Equality: `==`, `!=` (string comparison, bare identifier RHS treated as string),
+ *             `===`, `!==` (JS strict equality with full expression RHS)
+ * - Relational: `<`, `<=`, `>`, `>=`
+ * - Arithmetic: `+`, `-`, `*`, `/`, `%`, unary `-` / `+`
+ * - Grouping: `(` … `)`
+ *
+ * When `ctx` has a specific type with known keys, the expression string is
+ * **statically validated** — unknown context keys and syntax errors surface
+ * as TypeScript errors at the call site. Pass `ctx` typed as
+ * `Record<string, unknown>`, or the expression as `string`, to opt out of
+ * static checking (e.g. for dynamic expressions).
+ *
+ * With `{ strict: true }`, referencing an unknown context key at runtime
+ * throws. Short-circuit evaluation still applies — keys not reached are not
+ * checked.
+ */
+declare function evaluateWhen<T extends object, const E extends string>(expression: E & ValidateExpression<E, T>, ctx: T, options?: EvaluateOptions): boolean;
+/**
+ * Resolve a context value by key. Supports namespaced keys with `.` or `:` separators.
+ *
+ * Lookup order:
+ * 1. Exact match — `ctx['plugin.mode']` or `ctx['plugin:mode']`
+ * 2. Nested path — e.g. `plugin.mode` falls back to `ctx.plugin?.mode`
+ *
+ * Returns `undefined` for unknown keys.
+ */
+declare function resolveContextValue<T extends Record<string, unknown>>(key: string, ctx: T): unknown; //#endregion
+//#endregion
+//#region src/utils/when.d.ts
+/**
+ * Context object for evaluating `when` expressions.
+ *
+ * Built-in variables:
+ * - `clientType` — `'embedded' | 'standalone'`
+ * - `dockOpen` — whether the dock panel is open
+ * - `paletteOpen` — whether the command palette is open
+ * - `dockSelectedId` — ID of the selected dock entry (empty string if none)
+ *
+ * Plugins can add namespaced variables using dot or colon separators:
+ * - `vite.mode`, `vite:mode` — stored as `{ 'vite.mode': 'development' }` or nested `{ vite: { mode: 'development' } }`
+ *
+ * The expression language — including all operators and precedence — is provided by
+ * the [`whenexpr`](https://github.com/antfu/whenexpr) package. In addition to the
+ * VS-Code-style `!`/`==`/`!=`/`&&`/`||` operators, parentheses, strict equality
+ * (`===`/`!==`), relational (`<`/`<=`/`>`/`>=`), arithmetic (`+ - * / %`), and
+ * number/string literals are supported.
+ */
+interface WhenContext {
+  clientType: 'embedded' | 'standalone';
+  dockOpen: boolean;
+  paletteOpen: boolean;
+  dockSelectedId: string;
+  /** Allow custom context variables from plugins */
+  [key: string]: unknown;
+}
+//#endregion
+export { resolveContextValue as i, WhenExpression as n, evaluateWhen as r, WhenContext as t };

package/dist/ws-client-CDGmViwt.d.mts

@@ -0,0 +1,26 @@
+import { g as RpcFunctionDefinitionAny } from "./types-BkyzI9r4.mjs";
+import { ChannelOptions } from "birpc";
+
+//#region src/rpc/transports/ws-client.d.ts
+interface WsRpcChannelOptions {
+  url: string;
+  onConnected?: (e: Event) => void;
+  onError?: (e: Error) => void;
+  onDisconnected?: (e: CloseEvent) => void;
+  authToken?: string;
+  /**
+   * RPC function definitions (or just the `jsonSerializable` flag per
+   * method) used to dispatch the per-call wire serializer. Pass an
+   * empty / partial map on clients that don't have the full registry —
+   * encoding falls back to structured-clone (the safer superset) and
+   * decoding still routes correctly via the wire prefix.
+   */
+  definitions?: ReadonlyMap<string, Pick<RpcFunctionDefinitionAny, 'jsonSerializable'>>;
+}
+/**
+ * Build a birpc `ChannelOptions` object backed by a browser `WebSocket`.
+ * Pass the result straight to `createRpcClient`'s `channel` option.
+ */
+declare function createWsRpcChannel(options: WsRpcChannelOptions): ChannelOptions;
+//#endregion
+export { createWsRpcChannel as n, WsRpcChannelOptions as t };

package/dist/ws-server-Cu8tmZcF.d.mts

@@ -0,0 +1,49 @@
+import { g as RpcFunctionDefinitionAny } from "./types-BkyzI9r4.mjs";
+import { BirpcGroup, ChannelOptions } from "birpc";
+import { ServerOptions } from "node:https";
+import { WebSocket, WebSocketServer } from "ws";
+import { IncomingMessage } from "node:http";
+
+//#region src/rpc/transports/ws-server.d.ts
+interface DevToolsNodeRpcSessionMeta {
+  id: number;
+  ws?: WebSocket;
+  clientAuthToken?: string;
+  isTrusted?: boolean;
+  subscribedStates: Set<string>;
+}
+interface WsRpcTransportOptions {
+  /** Attach to an existing WebSocketServer. When provided, `port`, `host`, and `https` are ignored. */
+  wss?: WebSocketServer;
+  /** Port for a newly-created WebSocketServer. */
+  port?: number;
+  /** Host for a newly-created WebSocketServer. Defaults to `localhost`. */
+  host?: string;
+  /** When set, a new https.Server is created and the WebSocketServer is attached to it. */
+  https?: ServerOptions;
+  /**
+   * RPC function definitions, used by the per-call wire serializer to
+   * dispatch between strict-JSON and structured-clone encoding based
+   * on each function's `jsonSerializable` flag.
+   *
+   * When omitted, all messages fall back to structured-clone — safe but
+   * loses dev-time validation for `jsonSerializable: true` declarations.
+   */
+  definitions?: ReadonlyMap<string, Pick<RpcFunctionDefinitionAny, 'jsonSerializable'>>;
+  onConnected?: (ws: WebSocket, req: IncomingMessage, meta: DevToolsNodeRpcSessionMeta) => void;
+  onDisconnected?: (ws: WebSocket, meta: DevToolsNodeRpcSessionMeta) => void;
+  /** Override the default per-call serializer. Most callers should leave this unset. */
+  serialize?: ChannelOptions['serialize'];
+  /** Override the default per-call deserializer. Most callers should leave this unset. */
+  deserialize?: ChannelOptions['deserialize'];
+}
+/**
+ * Attach a WebSocket transport to an existing RPC group. Either pass an
+ * existing `WebSocketServer` via `wss`, or let this helper create one from
+ * `port` / `host` / `https`.
+ */
+declare function attachWsRpcTransport<ClientFunctions extends object, ServerFunctions extends object>(rpcGroup: BirpcGroup<ClientFunctions, ServerFunctions, false>, options?: WsRpcTransportOptions): {
+  wss: WebSocketServer;
+};
+//#endregion
+export { WsRpcTransportOptions as n, attachWsRpcTransport as r, DevToolsNodeRpcSessionMeta as t };

package/package.json

@@ -1,13 +1,121 @@
 {
   "name": "devframe",
-  "version": "0.0.0",
-  "packageManager": "pnpm@10.33.0",
-  "description": "",
-  "author": "Anthony Fu",
+  "type": "module",
+  "version": "0.1.17",
+  "description": "Framework for building generic DevTools",
+  "author": "Anthony Fu <anthonyfu117@hotmail.com>",
   "license": "MIT",
-  "keywords": [],
-  "main": "index.js",
+  "homepage": "https://github.com/vitejs/devtools#readme",
+  "repository": {
+    "directory": "devframe/packages/devframe",
+    "type": "git",
+    "url": "git+https://github.com/vitejs/devtools.git"
+  },
+  "bugs": "https://github.com/vitejs/devtools/issues",
+  "keywords": [
+    "devtools",
+    "rpc",
+    "toolbox"
+  ],
+  "sideEffects": false,
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./adapters/build": "./dist/adapters/build.mjs",
+    "./adapters/cli": "./dist/adapters/cli.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",
+    "./helpers/nuxt": "./dist/helpers/nuxt/index.mjs",
+    "./helpers/nuxt/runtime/plugin.client": "./dist/helpers/nuxt/runtime/plugin.client.mjs",
+    "./node": "./dist/node/index.mjs",
+    "./recipes/open-helpers": "./dist/recipes/open-helpers.mjs",
+    "./rpc": "./dist/rpc/index.mjs",
+    "./rpc/client": "./dist/rpc/client.mjs",
+    "./rpc/server": "./dist/rpc/server.mjs",
+    "./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/events": "./dist/utils/events.mjs",
+    "./utils/human-id": "./dist/utils/human-id.mjs",
+    "./utils/nanoid": "./dist/utils/nanoid.mjs",
+    "./utils/promise": "./dist/utils/promise.mjs",
+    "./utils/shared-state": "./dist/utils/shared-state.mjs",
+    "./utils/state": "./dist/utils/state.mjs",
+    "./utils/when": "./dist/utils/when.mjs",
+    "./package.json": "./package.json"
+  },
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "peerDependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "@nuxt/kit": "^3.0.0 || ^4.0.0",
+    "launch-editor": "^2.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@modelcontextprotocol/sdk": {
+      "optional": true
+    },
+    "@nuxt/kit": {
+      "optional": true
+    },
+    "launch-editor": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "@valibot/to-json-schema": "^1.6.0",
+    "ansis": "^4.2.0",
+    "birpc": "^4.0.0",
+    "cac": "^7.0.0",
+    "h3": "^1.15.11",
+    "logs-sdk": "^0.0.6",
+    "ohash": "^2.0.11",
+    "pathe": "^2.0.3",
+    "sirv": "^3.0.2",
+    "structured-clone-es": "^2.0.0",
+    "valibot": "^1.3.1",
+    "ws": "^8.20.0"
+  },
+  "devDependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@nuxt/kit": "^4.4.4",
+    "launch-editor": "^2.13.2",
+    "tsdown": "^0.21.10",
+    "whenexpr": "^0.1.2"
+  },
+  "inlinedDependencies": {
+    "acorn": "8.16.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.4",
+    "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",
+    "obug": "2.1.1",
+    "open": "11.0.0",
+    "p-limit": "7.3.0",
+    "perfect-debounce": "2.1.0",
+    "powershell-utils": "0.1.0",
+    "run-applescript": "7.1.0",
+    "tinyexec": "1.1.2",
+    "ua-parser-modern": "0.1.1",
+    "whenexpr": "0.1.2",
+    "wsl-utils": "0.3.1",
+    "yocto-queue": "1.2.2"
+  },
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "build": "tsdown",
+    "watch": "tsdown --watch"
   }
-}
+}