devframe 0.9.18 → 0.9.19

package/dist/{types-Dq4i156u.d.mts → types-D2vGd7-2.d.mts}

@@ -149,28 +149,47 @@ type RpcDumpGetter<ARGS extends any[] = any[], RETURN = any, CONTEXT = any> = (c
  * Dump configuration (static object or dynamic function).
  */
 type RpcDump<ARGS extends any[] = any[], RETURN = any, CONTEXT = any> = RpcDumpDefinition<ARGS, RETURN> | RpcDumpGetter<ARGS, RETURN, CONTEXT>;
-/**
- * Base function definition metadata.
- */
-interface RpcFunctionDefinitionBase {
+/** Shared fields for an RPC function definition. */
+interface RpcFunctionDefinitionBase<NAME extends string = string, TYPE extends RpcFunctionType = RpcFunctionType, ARGS extends any[] = any[], RETURN = any, CONTEXT = any> {
   /** Function name (unique identifier) */
-  name: string;
+  name: NAME;
   /** Function type (static, action, event, or query) */
-  type?: RpcFunctionType;
+  type?: TYPE;
+  /** Whether the function results should be cached */
+  cacheable?: boolean;
   /**
-   * Declares whether this function's args/return are JSON-serializable,
-   * i.e. no `Map`, `Set`, `Date`, `BigInt`, class instances, circular
-   * references, `undefined` leaves, `Symbol`, or `Function` values.
+   * Selects the serialization format for arguments and return values.
    *
-   * - `true`: args and return are encoded with strict `JSON.stringify`
-   *   on the wire and on disk. Misshapen values throw `DF0019` at the
-   *   sender, surfacing the bug *during the offending call* rather than
-   *   silently coercing to `{}` later. Required for `agent` exposure.
-   * - `false` (default): payloads use `structured-clone-es`, which
-   *   round-trips Maps/Sets/cycles. Functions in this mode cannot be
-   *   exposed via the `agent` field; registration throws `DF0018`.
+   * - `true`: uses strict JSON encoding (default when `agent` is set).
+   * - `false` (default otherwise): uses structured-clone encoding and supports values
+   *   such as `Map`, `Set`, `Date`, and cycles. Functions using this mode
+   *   cannot be agent-exposed.
    */
   jsonSerializable?: boolean;
+  /**
+   * Expose this function to agents (e.g. via the MCP adapter).
+   * When omitted, the function is not agent-exposed (default-deny).
+   */
+  agent?: RpcFunctionAgentOptions;
+  /** Setup function called with context to initialize handler and dump */
+  setup?: (context: CONTEXT) => Thenable<RpcFunctionSetupResult<ARGS, RETURN>>;
+  /** Function implementation (required if setup doesn't provide one) */
+  handler?: (...args: ARGS) => RETURN;
+  /** Dump definition (setup dump takes priority) */
+  dump?: RpcDump<ARGS, RETURN, CONTEXT>;
+  /**
+   * Sugar for "query in dev, single baked snapshot in build": when
+   * `true` and no `dump` is provided, the build adapter runs the
+   * handler once with no arguments and stores the result as both a
+   * no-args record and the fallback so any call variant resolves
+   * to the same snapshot. Only valid on `query` (or untyped)
+   * functions; `static` already has equivalent default behavior.
+   */
+  snapshot?: boolean;
+  /** Per-context setup-result cache, populated by `getRpcResolvedSetupResult`. @internal */
+  __cache?: WeakMap<object, Thenable<RpcFunctionSetupResult<ARGS, RETURN>>>;
+  /** Single-slot fallback for primitive contexts. @internal */
+  __promise?: Thenable<RpcFunctionSetupResult<ARGS, RETURN>>;
 }
 /**
  * Dump store containing pre-computed results.
@@ -178,12 +197,26 @@ interface RpcFunctionDefinitionBase {
  */
 interface RpcDumpStore<T = any> {
   /** Function definitions keyed by name */
-  definitions: Record<string, RpcFunctionDefinitionBase>;
+  definitions: Record<string, Pick<RpcFunctionDefinitionBase, 'name' | 'type'>>;
   /** Records keyed by '<function-name>---<hash>' or '<function-name>---fallback' */
   records: Record<string, RpcDumpRecord | (() => Promise<RpcDumpRecord>)>;
   /** @internal */
   _functions?: T;
 }
+/** RPC function definition whose handler supplies its argument and return types. */
+interface RpcFunctionDefinitionWithoutSchemas<NAME extends string, TYPE extends RpcFunctionType, ARGS extends any[], RETURN, AS extends RpcArgsSchema | undefined, RS extends RpcReturnSchema | undefined, CONTEXT> extends RpcFunctionDefinitionBase<NAME, TYPE, ARGS, RETURN, CONTEXT> {
+  /** Standard Schema array validating (and typing) the arguments */
+  args?: AS;
+  /** Standard Schema validating (and typing) the return value */
+  returns?: RS;
+}
+/** RPC function definition whose argument and return types come from schemas. */
+interface RpcFunctionDefinitionWithSchemas<NAME extends string, TYPE extends RpcFunctionType, AS extends RpcArgsSchema | undefined, RS extends RpcReturnSchema | undefined, CONTEXT> extends RpcFunctionDefinitionBase<NAME, TYPE, InferArgsType<AS>, Thenable<InferReturnType<RS>>, CONTEXT> {
+  /** Standard Schema array validating (and typing) the arguments */
+  args: AS;
+  /** Standard Schema validating (and typing) the resolved return value */
+  returns: RS;
+}
 /**
  * Dump client options.
  */
@@ -206,101 +239,7 @@ interface RpcDumpCollectionOptions {
 /**
  * RPC function definition with optional dump support.
  */
-type RpcFunctionDefinition<NAME extends string, TYPE extends RpcFunctionType = 'query', ARGS extends any[] = [], RETURN = void, AS extends RpcArgsSchema | undefined = undefined, RS extends RpcReturnSchema | undefined = undefined, CONTEXT = undefined> = [AS, RS] extends [undefined, undefined] ? {
-  /** Function name (unique identifier) */
-  name: NAME;
-  /** Function type (static, action, event, or query) */
-  type?: TYPE;
-  /** Whether the function results should be cached */
-  cacheable?: boolean;
-  /** Standard Schema array validating (and typing) the arguments */
-  args?: AS;
-  /** Standard Schema validating (and typing) the return value */
-  returns?: RS;
-  /**
-   * Declares whether this function's args/return are JSON-serializable
-   * (no Map/Set/Date/BigInt/cycles/class instances/undefined/Symbol/Function).
-   *
-   * - `true`: wire and dump use strict `JSON.stringify`; misshapen
-   *   values throw `DF0019` at the call site. Required for `agent`.
-   * - `false` (default): `structured-clone-es` round-trips fancy
-   *   types. Cannot be `agent`-exposed (registration throws `DF0018`).
-   */
-  jsonSerializable?: boolean;
-  /**
-   * Expose this function to agents (e.g. via the MCP adapter).
-   * When omitted, the function is not agent-exposed (default-deny).
-   */
-  agent?: RpcFunctionAgentOptions;
-  /** Setup function called with context to initialize handler and dump */
-  setup?: (context: CONTEXT) => Thenable<RpcFunctionSetupResult<ARGS, RETURN>>;
-  /** Function implementation (required if setup doesn't provide one) */
-  handler?: (...args: ARGS) => RETURN;
-  /** Dump definition (setup dump takes priority) */
-  dump?: RpcDump<ARGS, RETURN, CONTEXT>;
-  /**
-   * Sugar for "query in dev, single baked snapshot in build": when
-   * `true` and no `dump` is provided, the build adapter runs the
-   * handler once with no arguments and stores the result as both a
-   * no-args record and the fallback so any call variant resolves
-   * to the same snapshot. Only valid on `query` (or untyped)
-   * functions; `static` already has equivalent default behavior.
-   */
-  snapshot?: boolean;
-  /** Per-context setup-result cache, populated by `getRpcResolvedSetupResult`. @internal */
-  __cache?: WeakMap<object, Thenable<RpcFunctionSetupResult<ARGS, RETURN>>>;
-  /** Single-slot fallback for primitive contexts. @internal */
-  __promise?: Thenable<RpcFunctionSetupResult<ARGS, RETURN>>;
-} : {
-  /** Function name (unique identifier) */
-  name: NAME;
-  /** Function type (static, action, event, or query) */
-  type?: TYPE;
-  /** Whether the function results should be cached */
-  cacheable?: boolean;
-  /** Standard Schema array validating (and typing) the arguments */
-  args: AS;
-  /** Standard Schema validating (and typing) the return value */
-  returns: RS;
-  /**
-   * Declares whether this function's args/return are JSON-serializable
-   * (no Map/Set/Date/BigInt/cycles/class instances/undefined/Symbol/Function).
-   *
-   * - `true`: wire and dump use strict `JSON.stringify`; misshapen
-   *   values throw `DF0019` at the call site. Required for `agent`.
-   * - `false` (default): `structured-clone-es` round-trips fancy
-   *   types. Cannot be `agent`-exposed (registration throws `DF0018`).
-   */
-  jsonSerializable?: boolean;
-  /**
-   * Expose this function to agents (e.g. via the MCP adapter).
-   * When omitted, the function is not agent-exposed (default-deny).
-   */
-  agent?: RpcFunctionAgentOptions;
-  /** Setup function called with context to initialize handler and dump */
-  setup?: (context: CONTEXT) => Thenable<RpcFunctionSetupResult<InferArgsType<AS>, Thenable<InferReturnType<RS>>>>;
-  /**
-   * Function implementation (required if setup doesn't provide one).
-   * The declared `returns` schema describes the *resolved* value:
-   * async handlers return a promise of it (the runtime always awaits).
-   */
-  handler?: (...args: InferArgsType<AS>) => Thenable<InferReturnType<RS>>;
-  /** Dump definition (setup dump takes priority) */
-  dump?: RpcDump<InferArgsType<AS>, Thenable<InferReturnType<RS>>, CONTEXT>;
-  /**
-   * Sugar for "query in dev, single baked snapshot in build": when
-   * `true` and no `dump` is provided, the build adapter runs the
-   * handler once with no arguments and stores the result as both a
-   * no-args record and the fallback so any call variant resolves
-   * to the same snapshot. Only valid on `query` (or untyped)
-   * functions; `static` already has equivalent default behavior.
-   */
-  snapshot?: boolean;
-  /** Per-context setup-result cache, populated by `getRpcResolvedSetupResult`. @internal */
-  __cache?: WeakMap<object, Thenable<RpcFunctionSetupResult<InferArgsType<AS>, Thenable<InferReturnType<RS>>>>>;
-  /** Single-slot fallback for primitive contexts. @internal */
-  __promise?: Thenable<RpcFunctionSetupResult<InferArgsType<AS>, Thenable<InferReturnType<RS>>>>;
-};
+type RpcFunctionDefinition<NAME extends string, TYPE extends RpcFunctionType = 'query', ARGS extends any[] = [], RETURN = void, AS extends RpcArgsSchema | undefined = undefined, RS extends RpcReturnSchema | undefined = undefined, CONTEXT = undefined> = [AS, RS] extends [undefined, undefined] ? RpcFunctionDefinitionWithoutSchemas<NAME, TYPE, ARGS, RETURN, AS, RS, CONTEXT> : RpcFunctionDefinitionWithSchemas<NAME, TYPE, AS, RS, CONTEXT>;
 type RpcFunctionDefinitionToFunction<T extends RpcFunctionDefinitionAny> = T extends {
   args: infer AS;
   returns: infer RS;
@@ -320,4 +259,4 @@ type RpcDefinitionsFilter<T extends readonly RpcFunctionDefinitionAny[], Type ex
   type: Type;
 } ? T[K] : never; };
 //#endregion
-export { RpcFunctionType as C, InferArgsType as D, Thenable as E, InferReturnType as O, RpcFunctionSetupResult as S, RpcReturnSchema as T, RpcFunctionDefinition as _, RpcDefinitionsFilter as a, RpcFunctionDefinitionBase as b, RpcDump as c, RpcDumpDefinition as d, RpcDumpGetter as f, RpcFunctionAgentOptions as g, RpcDumpStore as h, RpcArgsSchema as i, RpcDumpClientOptions as l, RpcDumpRecordError as m, BirpcReturn$1 as n, RpcDefinitionsToFunctions as o, RpcDumpRecord as p, EntriesToObject as r, RpcDefinitionsToFunctionsWithNamespace as s, BirpcFn as t, RpcDumpCollectionOptions as u, RpcFunctionDefinitionAny as v, RpcFunctionsCollector as w, RpcFunctionDefinitionToFunction as x, RpcFunctionDefinitionAnyWithContext as y };
+export { InferReturnType as A, RpcFunctionDefinitionWithoutSchemas as C, RpcReturnSchema as D, RpcFunctionsCollector as E, Thenable as O, RpcFunctionDefinitionWithSchemas as S, RpcFunctionType as T, RpcFunctionDefinition as _, RpcDefinitionsFilter as a, RpcFunctionDefinitionBase as b, RpcDump as c, RpcDumpDefinition as d, RpcDumpGetter as f, RpcFunctionAgentOptions as g, RpcDumpStore as h, RpcArgsSchema as i, InferArgsType as k, RpcDumpClientOptions as l, RpcDumpRecordError as m, BirpcReturn$1 as n, RpcDefinitionsToFunctions as o, RpcDumpRecord as p, EntriesToObject as r, RpcDefinitionsToFunctionsWithNamespace as s, BirpcFn as t, RpcDumpCollectionOptions as u, RpcFunctionDefinitionAny as v, RpcFunctionSetupResult as w, RpcFunctionDefinitionToFunction as x, RpcFunctionDefinitionAnyWithContext as y };

package/dist/utils/events.d.mts

@@ -1,4 +1,4 @@
-import { Ut as EventsMap, Vt as EventEmitter } from "../context-DLzIyQCZ.mjs";
+import { Ut as EventsMap, Vt as EventEmitter } from "../context-BLHBDQcZ.mjs";
 //#region src/utils/events.d.ts
 /**
  * Create event emitter.

package/dist/utils/remote-assets.mjs

@@ -1,2 +1,2 @@
-import { t as resolveStaticAssetsSource } from "../remote-assets-DMFzLSoH.mjs";
+import { t as resolveStaticAssetsSource } from "../remote-assets-D0StJVLp.mjs";
 export { resolveStaticAssetsSource };

package/dist/utils/shared-state.d.mts

@@ -1,2 +1,2 @@
-import { A as SharedStateEvents, D as ImmutableObject, E as ImmutableMap, M as SharedStatePatch, N as createSharedState, O as ImmutableSet, T as ImmutableArray, j as SharedStateOptions, k as SharedState, w as Immutable } from "../context-DLzIyQCZ.mjs";
+import { A as SharedStateEvents, D as ImmutableObject, E as ImmutableMap, M as SharedStatePatch, N as createSharedState, O as ImmutableSet, T as ImmutableArray, j as SharedStateOptions, k as SharedState, w as Immutable } from "../context-BLHBDQcZ.mjs";
 export { Immutable, ImmutableArray, ImmutableMap, ImmutableObject, ImmutableSet, SharedState, SharedStateEvents, SharedStateOptions, SharedStatePatch, createSharedState };

package/dist/utils/streaming-channel.d.mts

@@ -1,2 +1,2 @@
-import { C as createStreamSink, S as createStreamReader, _ as CreateStreamSinkOptions, b as StreamSink, g as CreateStreamReaderOptions, h as BufferedChunk, v as StreamErrorPayload, x as StreamSinkEvents, y as StreamReader } from "../context-DLzIyQCZ.mjs";
+import { C as createStreamSink, S as createStreamReader, _ as CreateStreamSinkOptions, b as StreamSink, g as CreateStreamReaderOptions, h as BufferedChunk, v as StreamErrorPayload, x as StreamSinkEvents, y as StreamReader } from "../context-BLHBDQcZ.mjs";
 export { BufferedChunk, CreateStreamReaderOptions, CreateStreamSinkOptions, StreamErrorPayload, StreamReader, StreamSink, StreamSinkEvents, createStreamReader, createStreamSink };

package/dist/{validation-CfV1s0SF.mjs → validation-BzxTTYaV.mjs}

@@ -1,4 +1,4 @@
-import { r as diagnostics } from "./serialization-DFg5sUt6.mjs";
+import { r as diagnostics } from "./serialization-BhuOoL80.mjs";
 import { createHash } from "node:crypto";
 //#region ../../node_modules/.pnpm/ohash@2.0.12/node_modules/ohash/dist/_chunks/is-equal.mjs
 function serialize(input) {
@@ -171,6 +171,19 @@ function hash(value) {
 	return hash$1(value);
 }
 //#endregion
+//#region src/rpc/agent-json-serialization.ts
+/**
+* Prevents using a coding-agent-exposed RPC function that is explicitly
+* marked as non-serializable, and marks these functions as serializable by
+* default.
+*
+* @internal
+*/
+function ensureAgentJsonSerializable(fnDef) {
+	if (fnDef.agent && fnDef.jsonSerializable === false) throw diagnostics.DF0019({ name: fnDef.name });
+	if (fnDef.agent && !fnDef.jsonSerializable) fnDef.jsonSerializable = true;
+}
+//#endregion
 //#region src/rpc/validate-io.ts
 /**
 * Run a single [Standard Schema](https://standardschema.dev) validator,
@@ -308,4 +321,4 @@ function validateDefinition(definition) {
 	validateDefinitions([definition]);
 }
 //#endregion
-export { validateRpcArgs as a, getRpcResolvedSetupResult as i, validateDefinitions as n, validateRpcReturn as o, getRpcHandler as r, hash as s, validateDefinition as t };
+export { validateRpcArgs as a, hash as c, getRpcResolvedSetupResult as i, validateDefinitions as n, validateRpcReturn as o, getRpcHandler as r, ensureAgentJsonSerializable as s, validateDefinition as t };

package/dist/{wire-codec-BHGt0sSs.mjs → wire-codec-B1W3zH3L.mjs}

@@ -1,4 +1,4 @@
-import { n as strictJsonStringify } from "./serialization-DFg5sUt6.mjs";
+import { n as strictJsonStringify } from "./serialization-BhuOoL80.mjs";
 import { n as structuredCloneStringify, t as structuredCloneParse } from "./structured-clone-CbAV5rFI.mjs";
 //#region src/rpc/wire-codec.ts
 const EMPTY_WIRE_DEFS = /* @__PURE__ */ new Map();

package/dist/{write-D2AJqVT8.mjs → write-DoXJzGUH.mjs}

@@ -1,5 +1,5 @@
-import { n as validateDefinitions, r as getRpcHandler, s as hash } from "./validation-CfV1s0SF.mjs";
-import { n as strictJsonStringify, r as diagnostics } from "./serialization-DFg5sUt6.mjs";
+import { c as hash, n as validateDefinitions, r as getRpcHandler, s as ensureAgentJsonSerializable } from "./validation-BzxTTYaV.mjs";
+import { n as strictJsonStringify, r as diagnostics } from "./serialization-BhuOoL80.mjs";
 import { DEVFRAME_RPC_DUMP_DIRNAME, DEVFRAME_RPC_DUMP_MANIFEST_FILENAME } from "./constants.mjs";
 import { n as structuredCloneStringify } from "./structured-clone-CbAV5rFI.mjs";
 import fs from "node:fs/promises";
@@ -402,6 +402,7 @@ async function collectStaticRpcDump(definitions, context) {
 	const manifest = {};
 	const files = {};
 	for (const definition of definitions) {
+		ensureAgentJsonSerializable(definition);
 		const type = definition.type ?? "query";
 		const serialization = definition.jsonSerializable === true ? "json" : "structured-clone";
 		if (type === "static") {

package/dist/{ws-client-Xpxt0oPA.d.mts → ws-client-CNpP6Ium.d.mts}

@@ -1,4 +1,4 @@
-import { v as RpcFunctionDefinitionAny } from "./types-Dq4i156u.mjs";
+import { v as RpcFunctionDefinitionAny } from "./types-D2vGd7-2.mjs";
 import { ChannelOptions } from "birpc";
 //#region src/rpc/transports/ws-client.d.ts
 interface WsRpcChannelOptions {

package/dist/{ws-server-9ztvkeJ0.d.mts → ws-server-BB8jhxeT.d.mts}

@@ -1,4 +1,4 @@
-import { v as RpcFunctionDefinitionAny } from "./types-Dq4i156u.mjs";
+import { v as RpcFunctionDefinitionAny } from "./types-D2vGd7-2.mjs";
 import { n as DevframeRpcConnection, t as DevframeNodeRpcSessionMeta } from "./session-r6PDixP6.mjs";
 import { BirpcGroup, ChannelOptions } from "birpc";
 import { Hooks } from "crossws";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "devframe",
   "type": "module",
-  "version": "0.9.18",
+  "version": "0.9.19",
   "description": "Framework for building one portable devtool integration that runs in any viewer.",
   "author": "Anthony Fu <anthonyfu117@hotmail.com>",
   "license": "MIT",
@@ -105,7 +105,7 @@
     "immer": "^11.1.18",
     "launch-editor": "^2.14.1",
     "mlly": "^1.8.2",
-    "obug": "^2.1.4",
+    "obug": "^3.0.0",
     "ohash": "^2.0.12",
     "p-limit": "^7.3.2",
     "perfect-debounce": "^2.1.0",
@@ -114,7 +114,7 @@
     "tsdown": "^0.23.0",
     "typescript": "^6.0.3",
     "ua-parser-modern": "^0.1.1",
-    "valibot": "^1.4.2",
+    "valibot": "^1.5.0",
     "whenexpr": "^0.1.2",
     "ws": "^8.21.3"
   },

package/skills/devframe/SKILL.md

@@ -30,7 +30,7 @@ Two layers, one boundary:
 
 Devframe is framework- and build-tool-agnostic - it has zero dependency on Vite or any `@vitejs/*` package and makes no UI-framework assumption. [Vite DevTools](https://devtools.vite.dev/) is the first flagship hub UI provider built on it; the built-in devframes deliberately span Vue, Svelte, Solid, React, and Next to prove the point.
 
-High-level concept: [Pluggable, Extensible, and Playful DevTools](https://antfu.me/posts/pluggable-extensible-playful-devtools). Full reference: [devfra.me](https://devfra.me/).
+High-level concept: [Pluggable, Extensible, and Playful DevTools](https://devfra.me/posts/pluggable-extensible-playful-devtools). Full reference: [devfra.me](https://devfra.me/).
 
 ## Deployment map — pick by how it's served, not by what it does