devframe 0.8.2 → 0.9.0-beta.10

package/dist/helpers/vite.d.mts

@@ -1,100 +0,0 @@
-import { d as McpRouteOptions, p as DevframeAuthHandler, r as DevframeDefinition } from "../devframe-mQ4qZAuo.mjs";
-//#region src/helpers/vite.d.ts
-interface ViteDevBridgeOptions {
-  /**
-   * Mount base. Defaults to `def.basePath ?? '/__<id>/'` for this hosted
-   * adapter — the devframe shares the origin with the host Vite app.
-   *
-   * Relative spellings like `'./'` (common for base-agnostic Nuxt builds)
-   * are normalized to absolute paths so they compose with Vite's connect
-   * router.
-   */
-  base?: string;
-  /**
-   * Dev-time middleware mode. When set, the host app owns the SPA and
-   * devframe spins up a separate RPC + WS server on a resolved port,
-   * registering Vite middleware at `<base>__connection.json` so the
-   * host-served SPA can discover the WS endpoint.
-   *
-   *  - `false` (default) — static-mount the SPA at `base` with SPA
-   *    fallback. No RPC server is started.
-   *  - `true` — bridge mode with all defaults (port from
-   *    {@link resolveDevServerPort}, host from `def.cli?.host`).
-   *  - object — bridge mode with explicit overrides.
-   */
-  devMiddleware?: boolean | {
-    /** Override the bridge port. Default: {@link resolveDevServerPort}. */
-    port?: number;
-    /** Override the bridge bind host. Default: `def.cli?.host ?? 'localhost'`. */
-    host?: string;
-    /** Flag bag forwarded to `def.setup(ctx, { flags })`. */
-    flags?: Record<string, unknown>;
-  };
-  /**
-   * Whether the bridged devframe runs its own auth gate. The side-car RPC
-   * server is reachable by anything that can open its socket, so it **gates by
-   * default**: when unset, authentication resolves through `createDevServer`
-   * (devframe's interactive OTP gate unless the definition's `cli.auth` opts
-   * out), and the side-car prints its code/link banner to stdout. Pass a
-   * {@link DevframeAuthHandler} to install a custom scheme, or `false` to opt
-   * out for a single-user localhost host that owns the trust boundary another
-   * way. Only applies in bridge mode (`devMiddleware`); the static-mount mode
-   * starts no RPC server.
-   *
-   * @default gated (devframe's interactive OTP, unless `cli.auth` opts out)
-   */
-  auth?: boolean | DevframeAuthHandler;
-  /**
-   * Expose the side-car's route-based MCP server (Streamable-HTTP) and
-   * advertise it in the bridge's `__connection.json`. Forwarded to
-   * {@link createDevServer}: overrides `def.cli?.mcp`, `undefined` falls
-   * through to it, `false` disables the route regardless. Only applies in
-   * bridge mode (`devMiddleware`); the static-mount mode starts no server.
-   *
-   * The endpoint lives on the side-car's own port, so the advertised meta
-   * carries `{ port, path }` — see `ConnectionMeta['mcp']`.
-   *
-   * @experimental
-   */
-  mcp?: boolean | McpRouteOptions;
-}
-interface DevframeVitePlugin {
-  name: string;
-  apply: 'serve';
-  configureServer: (server: {
-    middlewares: {
-      use: (path: string, handler: any) => void;
-    };
-    httpServer?: {
-      once: (event: 'close', cb: () => void) => void;
-    } | null;
-  }) => void | Promise<void>;
-  closeBundle?: () => void | Promise<void>;
-}
-/**
- * Bridge a devframe into an existing Vite dev server. Returns a Vite
- * plugin with two modes, picked via `options.devMiddleware`:
- *
- *   - **static-mount mode** (default) — mounts `def.cli.distDir` at
- *     `options.base` with SPA fallback enabled. No RPC server is started.
- *
- *   - **bridge mode** (`devMiddleware: true | {…}`) — skips the static
- *     mount; the host app owns the SPA. Devframe starts a separate
- *     RPC + WS dev server (via {@link createDevServer} in bridge mode)
- *     and registers Vite middleware at `<base>__connection.json` so the
- *     host-served SPA can discover the WS endpoint via
- *     {@link connectDevframe}.
- *
- * The side-car RPC server **gates by default** (devframe's interactive OTP
- * unless the definition's `cli.auth` opts out), printing its code/link banner
- * to stdout, so a bridged devframe isn't silently reachable by anything that
- * can open its socket. Pass `options.auth: false` to opt out for a single-user
- * localhost host, or a {@link DevframeAuthHandler} for a custom scheme.
- *
- * Use bridge mode when integrating with frameworks that own the SPA
- * (Nuxt, Astro, SolidStart, plain Vite apps). For the all-in-one
- * `dev` / `build` / `mcp` shell, reach for {@link createCac} instead.
- */
-declare function viteDevBridge(d: DevframeDefinition, options?: ViteDevBridgeOptions): DevframeVitePlugin;
-//#endregion
-export { DevframeVitePlugin, ViteDevBridgeOptions, viteDevBridge };

package/dist/helpers/vite.mjs

@@ -1,105 +0,0 @@
-import { DEVFRAME_CONNECTION_META_FILENAME, DEVFRAME_WS_ROUTE } from "../constants.mjs";
-import { t as diagnostics } from "../diagnostics-D7wM2cwM.mjs";
-import { n as resolveBasePath, t as normalizeBasePath } from "../_shared-bWRzeSa0.mjs";
-import { serveStaticNodeMiddleware } from "../utils/serve-static.mjs";
-import { n as resolveDevServerPort, r as resolveMcpConnectionMeta, t as createDevServer } from "../dev-Bc49u3qg.mjs";
-import { resolve } from "pathe";
-//#region src/helpers/vite.ts
-/**
-* Bridge a devframe into an existing Vite dev server. Returns a Vite
-* plugin with two modes, picked via `options.devMiddleware`:
-*
-*   - **static-mount mode** (default) — mounts `def.cli.distDir` at
-*     `options.base` with SPA fallback enabled. No RPC server is started.
-*
-*   - **bridge mode** (`devMiddleware: true | {…}`) — skips the static
-*     mount; the host app owns the SPA. Devframe starts a separate
-*     RPC + WS dev server (via {@link createDevServer} in bridge mode)
-*     and registers Vite middleware at `<base>__connection.json` so the
-*     host-served SPA can discover the WS endpoint via
-*     {@link connectDevframe}.
-*
-* The side-car RPC server **gates by default** (devframe's interactive OTP
-* unless the definition's `cli.auth` opts out), printing its code/link banner
-* to stdout, so a bridged devframe isn't silently reachable by anything that
-* can open its socket. Pass `options.auth: false` to opt out for a single-user
-* localhost host, or a {@link DevframeAuthHandler} for a custom scheme.
-*
-* Use bridge mode when integrating with frameworks that own the SPA
-* (Nuxt, Astro, SolidStart, plain Vite apps). For the all-in-one
-* `dev` / `build` / `mcp` shell, reach for {@link createCac} instead.
-*/
-function viteDevBridge(d, options = {}) {
-	const base = normalizeMountBase(options.base ?? resolveBasePath(d, "hosted"));
-	if (!options.devMiddleware) {
-		const distDir = d.cli?.distDir;
-		return {
-			name: `devframe:${d.id}`,
-			apply: "serve",
-			configureServer(server) {
-				if (!distDir) return;
-				server.middlewares.use(base, serveStaticNodeMiddleware(resolve(distDir)));
-			}
-		};
-	}
-	const mw = options.devMiddleware === true ? {} : options.devMiddleware;
-	let started;
-	return {
-		name: `devframe:${d.id}`,
-		apply: "serve",
-		async configureServer(server) {
-			await started?.close().catch(() => {});
-			started = void 0;
-			let port;
-			try {
-				port = mw.port ?? await resolveDevServerPort(d, { host: mw.host });
-				started = await createDevServer(d, {
-					host: mw.host,
-					port,
-					flags: mw.flags,
-					openBrowser: false,
-					auth: options.auth,
-					mcp: options.mcp
-				});
-			} catch (e) {
-				diagnostics.DF0033({
-					id: d.id,
-					reason: String(e),
-					cause: e
-				}, { method: "warn" });
-				return;
-			}
-			const mcpMeta = resolveMcpConnectionMeta(d, options.mcp, port);
-			const metaPath = `${base}${DEVFRAME_CONNECTION_META_FILENAME}`;
-			server.middlewares.use(metaPath, (_req, res) => {
-				res.setHeader("Content-Type", "application/json");
-				res.end(JSON.stringify({
-					backend: "websocket",
-					websocket: {
-						port,
-						path: `/${DEVFRAME_WS_ROUTE}`
-					},
-					...mcpMeta ? { mcp: mcpMeta } : {}
-				}));
-			});
-			server.httpServer?.once("close", () => {
-				started?.close().catch(() => {});
-			});
-		},
-		async closeBundle() {
-			await started?.close().catch(() => {});
-			started = void 0;
-		}
-	};
-}
-/**
-* Make `base` safe for `server.middlewares.use(path, …)`. Vite's connect
-* router matches by absolute URL prefix, so relative spellings like
-* `'./'` (commonly used for base-agnostic Nuxt builds) collapse to the
-* origin root before the shared leading/trailing-slash normalization.
-*/
-function normalizeMountBase(base) {
-	return normalizeBasePath(base.replace(/^\.\/?/, "/"));
-}
-//#endregion
-export { viteDevBridge };

package/dist/http-C4T68YV6.mjs

@@ -1,38 +0,0 @@
-import { t as createMcpFetchHandler } from "./fetch-BKaD0Vb3.mjs";
-import { defineHandler } from "h3";
-//#region src/adapters/mcp/http.ts
-/**
-* Mount an MCP Streamable-HTTP endpoint on an h3 app at `path` — the h3
-* binding over {@link createMcpFetchHandler}, which owns the sessions, the
-* origin gate, and the transport plumbing.
-*
-* The handler is web-standard — it takes the h3 event's web `Request` and
-* returns a web `Response` (an SSE `ReadableStream` body for the
-* server→client stream). We copy that response onto `event.res` and return
-* its body rather than returning the `Response` object directly, so a
-* legitimate MCP 404 (unknown session) isn't swallowed by h3's
-* "Response-with-404 falls through to the next handler" rule (which would
-* otherwise hand the request to the SPA static catch-all).
-*
-* @experimental
-*/
-function mountMcpHttp(app, ctx, path, options) {
-	const handler = createMcpFetchHandler(ctx, options);
-	app.use(path, defineHandler(async (event) => respond(event, await handler.fetch(event.req))));
-	return { dispose: handler.dispose };
-}
-/**
-* Copy a web `Response` from the MCP transport onto the h3 event's response
-* and return its body. Returning the body (a `ReadableStream` or `null`)
-* rather than the `Response` object avoids h3's 404-fall-through behavior.
-*/
-function respond(event, response) {
-	event.res.status = response.status;
-	event.res.statusText = response.statusText;
-	response.headers.forEach((value, key) => {
-		event.res.headers.set(key, value);
-	});
-	return response.body ?? "";
-}
-//#endregion
-export { mountMcpHttp };

package/dist/index-vAX6bYuc.d.mts

@@ -1,78 +0,0 @@
-import { h as RpcDumpStore, l as RpcDumpClientOptions, m as RpcDumpRecordError, n as BirpcReturn, o as RpcDefinitionsToFunctions, u as RpcDumpCollectionOptions, v as RpcFunctionDefinitionAny } from "./types-CnJSgRVa.mjs";
-//#region src/rpc/dump/static.d.ts
-type StaticRpcDumpSerialization = 'json' | 'structured-clone';
-interface StaticRpcDumpManifestStaticEntry {
-  type: 'static';
-  path: string;
-  /** Encoder used when this entry's file was written. Default: `'json'`. */
-  serialization?: StaticRpcDumpSerialization;
-}
-interface StaticRpcDumpManifestQueryEntry {
-  type: 'query';
-  records: Record<string, string>;
-  fallback?: string;
-  /** Encoder used when each record/fallback file was written. Default: `'json'`. */
-  serialization?: StaticRpcDumpSerialization;
-}
-type StaticRpcDumpManifestValue = StaticRpcDumpManifestStaticEntry | StaticRpcDumpManifestQueryEntry | any;
-type StaticRpcDumpManifest = Record<string, StaticRpcDumpManifestValue>;
-interface StaticRpcDumpFile {
-  /** Whether this file was written via `JSON.stringify` or `structured-clone-es.stringify`. */
-  serialization: StaticRpcDumpSerialization;
-  /** Function name the file belongs to — used to scope `DF0019` errors during write. */
-  fnName: string;
-  /** Payload to encode. */
-  data: unknown;
-}
-interface StaticRpcDumpCollection {
-  manifest: StaticRpcDumpManifest;
-  files: Record<string, StaticRpcDumpFile>;
-}
-declare function collectStaticRpcDump(definitions: Iterable<RpcFunctionDefinitionAny>, context: any): Promise<StaticRpcDumpCollection>;
-//#endregion
-//#region src/rpc/dump/collect.d.ts
-/**
- * Collects pre-computed dumps by executing functions with their defined input combinations.
- * Static functions without dump config automatically get `{ inputs: [[]] }`.
- *
- * @example
- * ```ts
- * const store = await dumpFunctions([greet], context, { concurrency: 10 })
- * ```
- */
-declare function dumpFunctions<T extends readonly RpcFunctionDefinitionAny[]>(definitions: T, context?: any, options?: RpcDumpCollectionOptions): Promise<RpcDumpStore<RpcDefinitionsToFunctions<T>>>;
-/**
- * Creates a client that serves pre-computed results from a dump store.
- * Uses argument hashing to match calls to stored records.
- *
- * @example
- * ```ts
- * const client = createClientFromDump(store)
- * await client.greet('Alice')
- * ```
- */
-declare function createClientFromDump<T extends Record<string, any>>(store: RpcDumpStore<T>, options?: RpcDumpClientOptions): BirpcReturn<T>;
-/**
- * Filters function definitions to only those with dump definitions.
- * Note: Only checks the definition itself, not setup results.
- */
-declare function getDefinitionsWithDumps<T extends readonly RpcFunctionDefinitionAny[]>(definitions: T): RpcFunctionDefinitionAny[];
-//#endregion
-//#region src/rpc/dump/error.d.ts
-/**
- * Normalize a thrown value into a plain object suitable for storage in
- * a dump record. Preserves `message`, `name`, `cause`, and any own
- * enumerable properties of an `Error` so consumers reading the dump can
- * reconstruct a richer Error than just `{ message, name }`.
- *
- * Non-`Error` throws are wrapped as `{ name: 'Error', message: String(thrown) }`.
- */
-declare function serializeDumpError(error: unknown): RpcDumpRecordError;
-/**
- * Inverse of {@link serializeDumpError}: rebuild a thrown `Error` from
- * the plain object stored in a dump record. Preserves `cause`, restores
- * the original `name`, and re-attaches any custom own properties.
- */
-declare function reviveDumpError(stored: RpcDumpRecordError): Error;
-//#endregion
-export { getDefinitionsWithDumps as a, StaticRpcDumpManifest as c, StaticRpcDumpManifestValue as d, StaticRpcDumpSerialization as f, dumpFunctions as i, StaticRpcDumpManifestQueryEntry as l, serializeDumpError as n, StaticRpcDumpCollection as o, collectStaticRpcDump as p, createClientFromDump as r, StaticRpcDumpFile as s, reviveDumpError as t, StaticRpcDumpManifestStaticEntry as u };