devframe 0.5.3 → 0.6.0-beta.1

package/dist/{_shared-CUFqO4kJ.mjs → _shared-bWRzeSa0.mjs}

@@ -1,3 +1,4 @@
+import { cleanDoubleSlashes, withLeadingSlash, withTrailingSlash } from "ufo";
 //#region src/adapters/_shared.ts
 /**
 * Resolve the mount base path for a devframe's SPA. Hosted adapters
@@ -12,9 +13,7 @@ function resolveBasePath(def, kind) {
 	return kind === "standalone" ? "/" : `/__${def.id}/`;
 }
 function normalizeBasePath(base) {
-	let out = base.startsWith("/") ? base : `/${base}`;
-	if (!out.endsWith("/")) out = `${out}/`;
-	return out.replace(/\/+/g, "/");
+	return cleanDoubleSlashes(withTrailingSlash(withLeadingSlash(base)));
 }
 //#endregion
 export { resolveBasePath as n, normalizeBasePath as t };

package/dist/adapters/build.d.mts

@@ -1,4 +1,4 @@
-import { r as DevframeDefinition } from "../devframe-BuR6n9ZD.mjs";
+import { r as DevframeDefinition } from "../devframe-BwfavB78.mjs";
 
 //#region src/adapters/build.d.ts
 interface CreateBuildOptions {

package/dist/adapters/build.mjs

@@ -1,13 +1,13 @@
-import { t as collectStaticRpcDump } from "../dump-9lKIJTLh.mjs";
-import { n as colors } from "../diagnostics-reporter-CBBZwoMv.mjs";
+import { t as collectStaticRpcDump } from "../dump-DoXkj4ku.mjs";
+import { n as colors } from "../diagnostics-reporter-CsIG85Q5.mjs";
 import { DEVFRAME_CONNECTION_META_FILENAME, DEVFRAME_RPC_DUMP_DIRNAME, DEVFRAME_RPC_DUMP_MANIFEST_FILENAME } from "../constants.mjs";
-import { n as strictJsonStringify } from "../serialization-BD_qXGjd.mjs";
-import { n as structuredCloneStringify } from "../structured-clone-jegjz0hM.mjs";
-import { n as createHostContext, t as createH3DevframeHost } from "../host-h3-Dgpgr1Ul.mjs";
-import { n as resolveBasePath } from "../_shared-CUFqO4kJ.mjs";
+import { n as strictJsonStringify } from "../serialization-DpLXCy13.mjs";
+import { n as structuredCloneStringify } from "../structured-clone-XpHLZ8nr.mjs";
+import { n as createHostContext, t as createH3DevframeHost } from "../host-h3-C5SZlk03.mjs";
+import { n as resolveBasePath } from "../_shared-bWRzeSa0.mjs";
 import { existsSync } from "node:fs";
-import process from "node:process";
 import { dirname, resolve } from "pathe";
+import process from "node:process";
 import fs$1 from "node:fs/promises";
 //#region src/adapters/build.ts
 /**

package/dist/adapters/cli.d.mts

@@ -1,4 +1,4 @@
-import { dt as defineCliFlags, ft as parseCliFlags, lt as CliFlagsSchema, r as DevframeDefinition, ut as InferCliFlags } from "../devframe-BuR6n9ZD.mjs";
+import { Ct as CliFlagsSchema, Et as parseCliFlags, Tt as defineCliFlags, r as DevframeDefinition, wt as InferCliFlags } from "../devframe-BwfavB78.mjs";
 import { CAC } from "cac";
 import { H3 } from "h3";
 

package/dist/adapters/cli.mjs

@@ -1,6 +1,6 @@
-import { n as colors } from "../diagnostics-reporter-CBBZwoMv.mjs";
+import { n as colors } from "../diagnostics-reporter-CsIG85Q5.mjs";
 import { createBuild } from "./build.mjs";
-import { n as resolveDevServerPort, t as createDevServer } from "../dev-Cv43GfqM.mjs";
+import { n as resolveDevServerPort, t as createDevServer } from "../dev-CSpLSEVh.mjs";
 import process from "node:process";
 import cac from "cac";
 import { safeParse } from "valibot";

package/dist/adapters/dev.d.mts

@@ -1,5 +1,5 @@
-import { r as DevframeDefinition } from "../devframe-BuR6n9ZD.mjs";
-import { n as StartedServer } from "../server-wHlpcdZ9.mjs";
+import { l as DevframeWsOptions, r as DevframeDefinition } from "../devframe-BwfavB78.mjs";
+import { n as StartedServer } from "../server-oju7PTi2.mjs";
 import { H3 } from "h3";
 
 //#region src/adapters/dev.d.ts
@@ -31,6 +31,12 @@ interface CreateDevServerOptions {
    * `resolveBasePath(def, 'standalone')` (i.e. `def.basePath` or `/`).
    */
   basePath?: string;
+  /**
+   * Override how the browser reaches the RPC WebSocket (`def.cli?.ws`).
+   * See {@link DevframeWsOptions}: same-server route (default), a dedicated
+   * port, or a remote origin.
+   */
+  ws?: DevframeWsOptions;
   /**
    * h3 app to mount the SPA + connection-meta routes on. When omitted
    * a fresh app is created. Pass a pre-configured app to attach custom

package/dist/adapters/dev.mjs

@@ -1,2 +1,2 @@
-import { n as resolveDevServerPort, t as createDevServer } from "../dev-Cv43GfqM.mjs";
+import { n as resolveDevServerPort, t as createDevServer } from "../dev-CSpLSEVh.mjs";
 export { createDevServer, resolveDevServerPort };

package/dist/adapters/embedded.d.mts

@@ -1,4 +1,4 @@
-import { d as DevframeNodeContext, r as DevframeDefinition } from "../devframe-BuR6n9ZD.mjs";
+import { m as DevframeNodeContext, r as DevframeDefinition } from "../devframe-BwfavB78.mjs";
 
 //#region src/adapters/embedded.d.ts
 interface CreateEmbeddedOptions {

package/dist/adapters/mcp.d.mts

@@ -1,4 +1,4 @@
-import { r as DevframeDefinition } from "../devframe-BuR6n9ZD.mjs";
+import { r as DevframeDefinition } from "../devframe-BwfavB78.mjs";
 //#region src/adapters/mcp/build-server.d.ts
 interface CreateMcpServerOptions {
   /**

package/dist/adapters/mcp.mjs

@@ -1,8 +1,8 @@
-import { i as diagnostics } from "../shared-state-BlBNYziY.mjs";
-import { n as createHostContext } from "../host-h3-Dgpgr1Ul.mjs";
+import { a as diagnostics } from "../storage-l2ezeend.mjs";
+import { n as createHostContext } from "../host-h3-C5SZlk03.mjs";
+import { join } from "pathe";
 import { homedir } from "node:os";
 import process from "node:process";
-import { join } from "pathe";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { CallToolRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 import { toJsonSchema } from "@valibot/to-json-schema";
@@ -204,7 +204,7 @@ async function createMcpServer(definition, options = {}) {
 		serverVersion: options.serverVersion ?? definition.version ?? "0.0.0",
 		exposeSharedState: options.exposeSharedState ?? true
 	});
-	const { startStdioTransport } = await import("../transports-DTFoMUbE.mjs");
+	const { startStdioTransport } = await import("../transports-BmDVn4SF.mjs");
 	let stop;
 	try {
 		stop = await startStdioTransport(server);

package/dist/client/index.d.mts

@@ -1,7 +1,7 @@
-import { T as StreamSink, U as DevframeRpcClientFunctions, W as DevframeRpcServerFunctions, g as RpcSharedStateHost, l as ConnectionMeta, ot as EventEmitter, w as StreamReader } from "../devframe-BuR6n9ZD.mjs";
-import { C as RpcFunctionsCollector } from "../types-BkkQ0Txg.mjs";
-import { C as RpcCacheManager, w as RpcCacheOptions } from "../index-C7M1hnvL.mjs";
-import { t as WsRpcChannelOptions } from "../ws-client-CVYX9niP.mjs";
+import { $ as ScopedServerFunctions, D as StreamReader, J as DevframeSettings, L as SharedState, O as StreamSink, bt as EventEmitter, d as ConnectionMeta, et as ScopedSharedStates, it as DevframeRpcServerFunctions, rt as DevframeRpcClientFunctions, tt as SettingsForNamespace, v as RpcSharedStateGetOptions, y as RpcSharedStateHost } from "../devframe-BwfavB78.mjs";
+import { _ as RpcFunctionDefinition, w as RpcFunctionsCollector } from "../types-DZEx4ffs.mjs";
+import { C as RpcCacheManager, w as RpcCacheOptions } from "../index-CxaPKDXX.mjs";
+import { t as WsRpcChannelOptions } from "../ws-client-D0z0pOhn.mjs";
 import { BirpcOptions, BirpcReturn } from "birpc";
 
 //#region src/client/rpc-streaming.d.ts
@@ -34,6 +34,81 @@ interface RpcStreamingClientHost {
  */
 declare function createRpcStreamingClientHost(rpc: DevframeRpcClient): RpcStreamingClientHost;
 //#endregion
+//#region src/client/scope.d.ts
+type AnyRpcFn = (...args: any[]) => any;
+/**
+ * Client-side streaming host scoped to a namespace. Channel names are
+ * auto-prefixed with `<namespace>:`.
+ */
+interface DevframeScopedClientStreamingHost {
+  subscribe: <T = unknown>(channel: string, id: string, options?: StreamingSubscribeOptions) => StreamReader<T>;
+  upload: <T = unknown>(channel: string, id: string) => StreamSink<T>;
+}
+/**
+ * The scoped client RPC surface exposed on
+ * `client.scope('my-plugin').rpc`. IDs and keys you pass are
+ * auto-namespaced with `my-plugin:`.
+ */
+interface DevframeScopedClientRpc<NS extends string = string> {
+  /** The namespace this surface is scoped to. */
+  readonly namespace: NS;
+  /**
+   * Register a client (server→client) RPC function. The definition's
+   * `name` must be bare (no `:`); it is stored as `<namespace>:<name>`.
+   */
+  register: (fn: RpcFunctionDefinition<string, any, any, any, any, any, DevframeRpcContext>) => void;
+  /** Call a server RPC function. Bare names resolve within this namespace. */
+  call: {
+    <T extends keyof ScopedServerFunctions<NS> & string>(method: T, ...args: Parameters<Extract<ScopedServerFunctions<NS>[T], AnyRpcFn>>): Promise<Awaited<ReturnType<Extract<ScopedServerFunctions<NS>[T], AnyRpcFn>>>>;
+    <T extends keyof DevframeRpcServerFunctions & string>(method: T, ...args: Parameters<Extract<DevframeRpcServerFunctions[T], AnyRpcFn>>): Promise<Awaited<ReturnType<Extract<DevframeRpcServerFunctions[T], AnyRpcFn>>>>;
+    (method: string, ...args: any[]): Promise<any>;
+  };
+  /** Call a server RPC event (fire-and-forget). */
+  callEvent: {
+    <T extends keyof ScopedServerFunctions<NS> & string>(method: T, ...args: Parameters<Extract<ScopedServerFunctions<NS>[T], AnyRpcFn>>): void;
+    <T extends keyof DevframeRpcServerFunctions & string>(method: T, ...args: Parameters<Extract<DevframeRpcServerFunctions[T], AnyRpcFn>>): void;
+    (method: string, ...args: any[]): void;
+  };
+  /** Call an optional server RPC function (no error if unregistered). */
+  callOptional: {
+    <T extends keyof ScopedServerFunctions<NS> & string>(method: T, ...args: Parameters<Extract<ScopedServerFunctions<NS>[T], AnyRpcFn>>): Promise<Awaited<ReturnType<Extract<ScopedServerFunctions<NS>[T], AnyRpcFn>>> | undefined>;
+    <T extends keyof DevframeRpcServerFunctions & string>(method: T, ...args: Parameters<Extract<DevframeRpcServerFunctions[T], AnyRpcFn>>): Promise<Awaited<ReturnType<Extract<DevframeRpcServerFunctions[T], AnyRpcFn>>> | undefined>;
+    (method: string, ...args: any[]): Promise<any>;
+  };
+  /** Resolve a namespaced shared state. Bare keys resolve within this namespace. */
+  sharedState: {
+    <T extends keyof ScopedSharedStates<NS> & string>(key: T, options?: RpcSharedStateGetOptions<ScopedSharedStates<NS>[T]>): Promise<SharedState<ScopedSharedStates<NS>[T]>>;
+    <T extends Record<string, any> = Record<string, any>>(key: string, options?: RpcSharedStateGetOptions<T>): Promise<SharedState<T>>;
+  };
+  /** Streaming host scoped to this namespace. */
+  streaming: DevframeScopedClientStreamingHost;
+}
+/**
+ * A namespace-scoped view of the {@link DevframeRpcClient}. Returned by
+ * `client.scope('my-plugin')`. Replaces `rpc` with the auto-namespaced
+ * surface and adds a top-level `settings` store.
+ */
+interface DevframeScopedClientContext<NS extends string = string, Settings extends Record<string, any> = Record<string, any>> {
+  /** The namespace this context is scoped to. */
+  readonly namespace: NS;
+  /** The underlying unscoped client. */
+  readonly base: DevframeRpcClient;
+  rpc: DevframeScopedClientRpc<NS>;
+  /** Persisted settings for this namespace (`global` + `project`). */
+  settings: DevframeSettings<Settings>;
+  /**
+   * Return a new scoped client, replacing the current scope. Pass `null`
+   * or `''` to un-scope and get the base client.
+   */
+  scope: DevframeRpcClient['scope'];
+}
+/**
+ * Build a namespace-scoped view of a {@link DevframeRpcClient}. Every RPC
+ * id, shared-state key, and streaming channel passed through the returned
+ * `rpc` surface is auto-namespaced with `<namespace>:`.
+ */
+declare function createScopedClientContext<NS extends string = string>(rpc: DevframeRpcClient, namespace: NS): DevframeScopedClientContext<NS>;
+//#endregion
 //#region src/client/rpc.d.ts
 interface DevframeRpcContext {
   /**
@@ -52,6 +127,14 @@ interface DevframeRpcClientOptions {
    * The auth token to use for the client
    */
   authToken?: string;
+  /**
+   * Query-param name on the page URL carrying a one-time authentication code
+   * (OTP) for "magic link" auth (e.g. a link the dev server prints). When
+   * present, the client exchanges the code for a token and removes the parameter
+   * from the URL. Set `false` to disable — e.g. integrations that drive their
+   * own authentication via `authenticateWithUrlOtp`. Default: `'devframe_otp'`.
+   */
+  otpParam?: string | false;
   wsOptions?: Partial<WsRpcChannelOptions>;
   rpcOptions?: Partial<BirpcOptions<DevframeRpcServerFunctions, DevframeRpcClientFunctions, boolean>>;
   cacheOptions?: boolean | Partial<RpcCacheOptions>;
@@ -85,10 +168,17 @@ interface DevframeRpcClient {
    */
   requestTrust: () => Promise<boolean>;
   /**
-   * Request trust from the server using a specific auth token.
+   * Request trust from the server using a previously-issued auth token.
    * Updates the stored token and re-requests trust without reloading the page.
    */
   requestTrustWithToken: (token: string) => Promise<boolean>;
+  /**
+   * Authenticate this client by exchanging a one-time code (shown by the dev
+   * server) for a node-issued auth token. On success the token is persisted for
+   * future reconnections and shared with sibling tabs. Resolves `true` when
+   * authenticated.
+   */
+  requestTrustWithCode: (code: string) => Promise<boolean>;
   /**
    * Call a RPC function on the server
    */
@@ -119,19 +209,71 @@ interface DevframeRpcClient {
    * The RPC cache manager
    */
   cacheManager: RpcCacheManager;
+  /**
+   * Create a namespace-scoped view of this client. The returned
+   * `client.scope('my-plugin')` auto-namespaces every RPC id,
+   * shared-state key, and streaming channel with `my-plugin:`, and
+   * exposes a typed top-level `settings` store. This is the preferred way
+   * to consume the client from a single tool's UI code.
+   *
+   * Pass `null` or `''` to un-scope and get the base client.
+   */
+  scope: {
+    <NS extends string>(namespace: NS): DevframeScopedClientContext<NS, SettingsForNamespace<NS>>;
+    (namespace?: null | ''): DevframeRpcClient;
+  };
 }
 interface DevframeRpcClientMode {
   readonly isTrusted: boolean;
   ensureTrusted: DevframeRpcClient['ensureTrusted'];
   requestTrust: DevframeRpcClient['requestTrust'];
   requestTrustWithToken: DevframeRpcClient['requestTrustWithToken'];
+  /**
+   * Exchange a one-time code for a node-issued token. Resolves the minted
+   * token on success (for the caller to persist), or `null` on failure.
+   */
+  requestTrustWithCode: (code: string) => Promise<string | null>;
   call: DevframeRpcClient['call'];
   callEvent: DevframeRpcClient['callEvent'];
   callOptional: DevframeRpcClient['callOptional'];
 }
 declare function getDevframeRpcClient(options?: DevframeRpcClientOptions): Promise<DevframeRpcClient>;
 //#endregion
+//#region src/client/otp.d.ts
+/**
+ * Read a one-time authentication code (OTP) from the current page URL's query
+ * string, without side effects. Returns `undefined` when the parameter is absent.
+ */
+declare function readOtpFromUrl(param?: string): string | undefined;
+/**
+ * Read the one-time code from the page URL and remove it from the address bar
+ * (and the current history entry), so the single-use code isn't left in the
+ * URL, browser history, or a `Referer`. Returns the code, or `undefined` when
+ * absent.
+ */
+declare function consumeOtpFromUrl(param?: string): string | undefined;
+/**
+ * Consume a one-time code from the page URL (see {@link consumeOtpFromUrl}) and
+ * exchange it for a token via the client. Resolves `true` when the client is
+ * authenticated (already trusted, or the exchange succeeded), and `false` when
+ * no code is present or the exchange failed.
+ *
+ * Higher-level integrations (e.g. Vite DevTools) that want to drive their own
+ * authentication UI can disable `connectDevframe`'s built-in handling with
+ * `otpParam: false` and call this — or {@link consumeOtpFromUrl} — themselves.
+ */
+declare function authenticateWithUrlOtp(rpc: Pick<DevframeRpcClient, 'isTrusted' | 'requestTrustWithCode'>, options?: {
+  param?: string;
+}): Promise<boolean>;
+//#endregion
+//#region src/client/settings.d.ts
+/**
+ * Build the client-side `settings` surface for a scope namespace. Mirrors
+ * the node-side stores over the shared-state sync protocol.
+ */
+declare function createClientSettings<T extends Record<string, any> = Record<string, any>>(rpc: DevframeRpcClient, namespace: string): DevframeSettings<T>;
+//#endregion
 //#region src/client/index.d.ts
 declare const connectDevframe: typeof getDevframeRpcClient;
 //#endregion
-export { DevframeClientRpcHost, DevframeRpcClient, DevframeRpcClientCall, DevframeRpcClientCallEvent, DevframeRpcClientCallOptional, DevframeRpcClientMode, DevframeRpcClientOptions, DevframeRpcContext, RpcClientEvents, RpcStreamingClientHost, StreamingSubscribeOptions, connectDevframe, createRpcStreamingClientHost, getDevframeRpcClient };
+export { DevframeClientRpcHost, DevframeRpcClient, DevframeRpcClientCall, DevframeRpcClientCallEvent, DevframeRpcClientCallOptional, DevframeRpcClientMode, DevframeRpcClientOptions, DevframeRpcContext, DevframeScopedClientContext, DevframeScopedClientRpc, DevframeScopedClientStreamingHost, RpcClientEvents, RpcStreamingClientHost, StreamingSubscribeOptions, authenticateWithUrlOtp, connectDevframe, consumeOtpFromUrl, createClientSettings, createRpcStreamingClientHost, createScopedClientContext, getDevframeRpcClient, readOtpFromUrl };