devframe 0.0.0 → 0.1.16

package/dist/rpc-9FNa3Inb.mjs

@@ -0,0 +1,474 @@
+import { hash } from "ohash";
+import { consoleReporter, createLogger, defineDiagnostics, plainFormatter } from "logs-sdk";
+//#region src/rpc/cache.ts
+/**
+* @experimental API is expected to change.
+*/
+var RpcCacheManager = class {
+	cacheMap = /* @__PURE__ */ new Map();
+	options;
+	keySerializer;
+	constructor(options) {
+		this.options = options;
+		this.keySerializer = options.keySerializer || ((args) => hash(args));
+	}
+	updateOptions(options) {
+		this.options = {
+			...this.options,
+			...options
+		};
+	}
+	cached(m, a) {
+		const methodCache = this.cacheMap.get(m);
+		if (methodCache) return methodCache.get(this.keySerializer(a));
+	}
+	apply(req, res) {
+		const methodCache = this.cacheMap.get(req.m) || /* @__PURE__ */ new Map();
+		methodCache.set(this.keySerializer(req.a), res);
+		this.cacheMap.set(req.m, methodCache);
+	}
+	validate(m) {
+		return this.options.functions.includes(m);
+	}
+	clear(fn) {
+		if (fn) this.cacheMap.delete(fn);
+		else this.cacheMap.clear();
+	}
+};
+const logger = createLogger({
+	diagnostics: [defineDiagnostics({
+		docsBase: "https://devtools.vite.dev/errors",
+		codes: {
+			DTK0001: {
+				message: (p) => `RPC function "${p.name}" is already registered`,
+				hint: "Use the `force` parameter to overwrite an existing registration."
+			},
+			DTK0002: { message: (p) => `RPC function "${p.name}" is not registered. Use register() to add new functions.` },
+			DTK0003: { message: (p) => `RPC function "${p.name}" is not registered` },
+			DTK0004: { message: (p) => `Either handler or setup function must be provided for RPC function "${p.name}"` },
+			DTK0005: { message: (p) => `Function "${p.name}" not found in dump store` },
+			DTK0006: { message: (p) => `No dump match for "${p.name}" with args: ${p.args}` },
+			DTK0007: { message: (p) => `Function "${p.name}" with type "${p.type}" cannot have dump configuration. Only "static" and "query" types support dumps.` },
+			DTK0008: {
+				message: (p) => `Function "${p.name}" with type "${p.type}" cannot use \`snapshot: true\`. Only "query" functions support this sugar; "static" functions have equivalent default behavior already.`,
+				hint: "Remove `snapshot: true`, or change the function type to `query`."
+			}
+		}
+	})],
+	formatter: plainFormatter,
+	reporters: consoleReporter
+});
+//#endregion
+//#region src/rpc/handler.ts
+async function getRpcResolvedSetupResult(definition, context) {
+	if (definition.__resolved) return definition.__resolved;
+	if (!definition.setup) return {};
+	definition.__promise ??= Promise.resolve(definition.setup(context)).then((r) => {
+		definition.__resolved = r;
+		definition.__promise = void 0;
+		return r;
+	});
+	return definition.__resolved ??= await definition.__promise;
+}
+async function getRpcHandler(definition, context) {
+	if (definition.handler) return definition.handler;
+	const result = await getRpcResolvedSetupResult(definition, context);
+	if (!result.handler) throw logger.DTK0004({ name: definition.name }).throw();
+	return result.handler;
+}
+//#endregion
+//#region src/rpc/collector.ts
+var RpcFunctionsCollectorBase = class {
+	definitions = /* @__PURE__ */ new Map();
+	functions;
+	_onChanged = [];
+	constructor(context) {
+		this.context = context;
+		const definitions = this.definitions;
+		const self = this;
+		this.functions = new Proxy({}, {
+			get(_, prop) {
+				const definition = definitions.get(prop);
+				if (!definition) return void 0;
+				return getRpcHandler(definition, self.context);
+			},
+			has(_, prop) {
+				return definitions.has(prop);
+			},
+			getOwnPropertyDescriptor(_, prop) {
+				return {
+					value: definitions.get(prop)?.handler,
+					configurable: true,
+					enumerable: true
+				};
+			},
+			ownKeys() {
+				return Array.from(definitions.keys());
+			}
+		});
+	}
+	register(fn, force = false) {
+		if (this.definitions.has(fn.name) && !force) throw logger.DTK0001({ name: fn.name }).throw();
+		this.definitions.set(fn.name, fn);
+		this._onChanged.forEach((cb) => cb(fn.name));
+	}
+	update(fn, force = false) {
+		if (!this.definitions.has(fn.name) && !force) throw logger.DTK0002({ name: fn.name }).throw();
+		this.definitions.set(fn.name, fn);
+		this._onChanged.forEach((cb) => cb(fn.name));
+	}
+	onChanged(fn) {
+		this._onChanged.push(fn);
+		return () => {
+			const index = this._onChanged.indexOf(fn);
+			if (index !== -1) this._onChanged.splice(index, 1);
+		};
+	}
+	async getHandler(name) {
+		return await getRpcHandler(this.definitions.get(name), this.context);
+	}
+	getSchema(name) {
+		const definition = this.definitions.get(name);
+		if (!definition) throw logger.DTK0003({ name: String(name) }).throw();
+		return {
+			args: definition.args,
+			returns: definition.returns
+		};
+	}
+	has(name) {
+		return this.definitions.has(name);
+	}
+	get(name) {
+		return this.definitions.get(name);
+	}
+	list() {
+		return Array.from(this.definitions.keys());
+	}
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/yocto-queue@1.2.2/node_modules/yocto-queue/index.js
+var Node = class {
+	value;
+	next;
+	constructor(value) {
+		this.value = value;
+	}
+};
+var Queue = class {
+	#head;
+	#tail;
+	#size;
+	constructor() {
+		this.clear();
+	}
+	enqueue(value) {
+		const node = new Node(value);
+		if (this.#head) {
+			this.#tail.next = node;
+			this.#tail = node;
+		} else {
+			this.#head = node;
+			this.#tail = node;
+		}
+		this.#size++;
+	}
+	dequeue() {
+		const current = this.#head;
+		if (!current) return;
+		this.#head = this.#head.next;
+		this.#size--;
+		if (!this.#head) this.#tail = void 0;
+		return current.value;
+	}
+	peek() {
+		if (!this.#head) return;
+		return this.#head.value;
+	}
+	clear() {
+		this.#head = void 0;
+		this.#tail = void 0;
+		this.#size = 0;
+	}
+	get size() {
+		return this.#size;
+	}
+	*[Symbol.iterator]() {
+		let current = this.#head;
+		while (current) {
+			yield current.value;
+			current = current.next;
+		}
+	}
+	*drain() {
+		while (this.#head) yield this.dequeue();
+	}
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/p-limit@7.3.0/node_modules/p-limit/index.js
+function pLimit(concurrency) {
+	let rejectOnClear = false;
+	if (typeof concurrency === "object") ({concurrency, rejectOnClear = false} = concurrency);
+	validateConcurrency(concurrency);
+	if (typeof rejectOnClear !== "boolean") throw new TypeError("Expected `rejectOnClear` to be a boolean");
+	const queue = new Queue();
+	let activeCount = 0;
+	const resumeNext = () => {
+		if (activeCount < concurrency && queue.size > 0) {
+			activeCount++;
+			queue.dequeue().run();
+		}
+	};
+	const next = () => {
+		activeCount--;
+		resumeNext();
+	};
+	const run = async (function_, resolve, arguments_) => {
+		const result = (async () => function_(...arguments_))();
+		resolve(result);
+		try {
+			await result;
+		} catch {}
+		next();
+	};
+	const enqueue = (function_, resolve, reject, arguments_) => {
+		const queueItem = { reject };
+		new Promise((internalResolve) => {
+			queueItem.run = internalResolve;
+			queue.enqueue(queueItem);
+		}).then(run.bind(void 0, function_, resolve, arguments_));
+		if (activeCount < concurrency) resumeNext();
+	};
+	const generator = (function_, ...arguments_) => new Promise((resolve, reject) => {
+		enqueue(function_, resolve, reject, arguments_);
+	});
+	Object.defineProperties(generator, {
+		activeCount: { get: () => activeCount },
+		pendingCount: { get: () => queue.size },
+		clearQueue: { value() {
+			if (!rejectOnClear) {
+				queue.clear();
+				return;
+			}
+			const abortError = AbortSignal.abort().reason;
+			while (queue.size > 0) queue.dequeue().reject(abortError);
+		} },
+		concurrency: {
+			get: () => concurrency,
+			set(newConcurrency) {
+				validateConcurrency(newConcurrency);
+				concurrency = newConcurrency;
+				queueMicrotask(() => {
+					while (activeCount < concurrency && queue.size > 0) resumeNext();
+				});
+			}
+		},
+		map: { async value(iterable, function_) {
+			const promises = Array.from(iterable, (value, index) => this(function_, value, index));
+			return Promise.all(promises);
+		} }
+	});
+	return generator;
+}
+function validateConcurrency(concurrency) {
+	if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) throw new TypeError("Expected `concurrency` to be a number from 1 and up");
+}
+//#endregion
+//#region src/rpc/validation.ts
+/**
+* Validates RPC function definitions.
+* Action and event functions cannot have dumps (side effects should not be cached).
+*
+* @throws {Error} If an action or event function has a dump configuration
+*/
+function validateDefinitions(definitions) {
+	for (const definition of definitions) {
+		const type = definition.type || "query";
+		if ((type === "action" || type === "event") && definition.dump) throw logger.DTK0007({
+			name: definition.name,
+			type
+		}).throw();
+		if (definition.snapshot && type !== "query") throw logger.DTK0008({
+			name: definition.name,
+			type
+		}).throw();
+	}
+}
+/**
+* Validates a single RPC function definition.
+*
+* @throws {Error} If an action or event function has a dump configuration
+*/
+function validateDefinition(definition) {
+	validateDefinitions([definition]);
+}
+//#endregion
+//#region src/rpc/dumps.ts
+function getDumpRecordKey(functionName, args) {
+	return `${functionName}---${hash(args)}`;
+}
+function getDumpFallbackKey(functionName) {
+	return `${functionName}---fallback`;
+}
+async function resolveGetter(valueOrGetter) {
+	return typeof valueOrGetter === "function" ? await valueOrGetter() : valueOrGetter;
+}
+/**
+* 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 })
+* ```
+*/
+async function dumpFunctions(definitions, context, options = {}) {
+	validateDefinitions(definitions);
+	const concurrency = options.concurrency === true ? 5 : options.concurrency === false || options.concurrency == null ? 1 : options.concurrency;
+	const store = {
+		definitions: {},
+		records: {}
+	};
+	const tasksResolutions = definitions.map((definition) => async () => {
+		if (definition.type === "event" || definition.type === "action") return;
+		const setupResult = definition.setup ? await Promise.resolve(definition.setup(context)) : {};
+		const handler = setupResult.handler || definition.handler;
+		if (!handler) throw logger.DTK0004({ name: definition.name }).throw();
+		let dump = setupResult.dump ?? definition.dump;
+		if (!dump && definition.type === "static") dump = { inputs: [[]] };
+		if (!dump && definition.snapshot) dump = async (_ctx, h) => {
+			const output = await Promise.resolve(h(...[]));
+			return {
+				records: [{
+					inputs: [],
+					output
+				}],
+				fallback: output
+			};
+		};
+		if (!dump) return;
+		if (typeof dump === "function") dump = await Promise.resolve(dump(context, handler));
+		store.definitions[definition.name] = {
+			name: definition.name,
+			type: definition.type
+		};
+		return {
+			handler,
+			dump,
+			definition
+		};
+	});
+	let functionsToDump = [];
+	if (concurrency <= 1) for (const task of tasksResolutions) {
+		const resolution = await task();
+		if (resolution) functionsToDump.push(resolution);
+	}
+	else {
+		const limit = pLimit(concurrency);
+		functionsToDump = (await Promise.all(tasksResolutions.map((task) => limit(task)))).filter((x) => !!x);
+	}
+	const dumpTasks = [];
+	for (const { definition, handler, dump } of functionsToDump) {
+		const { inputs, records, fallback } = dump;
+		if (records) for (const record of records) {
+			const recordKey = getDumpRecordKey(definition.name, record.inputs);
+			store.records[recordKey] = record;
+		}
+		if ("fallback" in dump) {
+			const fallbackKey = getDumpFallbackKey(definition.name);
+			store.records[fallbackKey] = {
+				inputs: [],
+				output: fallback
+			};
+		}
+		if (inputs) for (const input of inputs) dumpTasks.push(async () => {
+			const recordKey = getDumpRecordKey(definition.name, input);
+			try {
+				const output = await Promise.resolve(handler(...input));
+				store.records[recordKey] = {
+					inputs: input,
+					output
+				};
+			} catch (error) {
+				store.records[recordKey] = {
+					inputs: input,
+					error: {
+						message: error.message,
+						name: error.name
+					}
+				};
+			}
+		});
+	}
+	if (concurrency <= 1) for (const task of dumpTasks) await task();
+	else {
+		const limit = pLimit(concurrency);
+		await Promise.all(dumpTasks.map((task) => limit(task)));
+	}
+	return store;
+}
+/**
+* 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')
+* ```
+*/
+function createClientFromDump(store, options = {}) {
+	const { onMiss } = options;
+	return new Proxy({}, {
+		get(_, functionName) {
+			if (!(functionName in store.definitions)) throw logger.DTK0005({ name: functionName }).throw();
+			return async (...args) => {
+				const recordKey = getDumpRecordKey(functionName, args);
+				const recordOrGetter = store.records[recordKey];
+				if (recordOrGetter) {
+					const record = await resolveGetter(recordOrGetter);
+					if (record.error) {
+						const error = new Error(record.error.message);
+						error.name = record.error.name;
+						throw error;
+					}
+					if (typeof record.output === "function") return await record.output();
+					return record.output;
+				}
+				onMiss?.(functionName, args);
+				const fallbackKey = getDumpFallbackKey(functionName);
+				if (fallbackKey in store.records) {
+					const fallbackOrGetter = store.records[fallbackKey];
+					const fallbackRecord = await resolveGetter(fallbackOrGetter);
+					if (fallbackRecord && typeof fallbackRecord.output === "function") return await fallbackRecord.output();
+					if (fallbackRecord) return fallbackRecord.output;
+				}
+				throw logger.DTK0006({
+					name: functionName,
+					args: JSON.stringify(args)
+				}).throw();
+			};
+		},
+		has(_, functionName) {
+			return functionName in store.definitions;
+		},
+		ownKeys() {
+			return Object.keys(store.definitions);
+		},
+		getOwnPropertyDescriptor(_, functionName) {
+			return functionName in store.definitions ? {
+				configurable: true,
+				enumerable: true,
+				value: void 0
+			} : void 0;
+		}
+	});
+}
+/**
+* Filters function definitions to only those with dump definitions.
+* Note: Only checks the definition itself, not setup results.
+*/
+function getDefinitionsWithDumps(definitions) {
+	return definitions.filter((def) => def.dump !== void 0);
+}
+//#endregion
+export { validateDefinitions as a, getRpcResolvedSetupResult as c, validateDefinition as i, RpcCacheManager as l, dumpFunctions as n, RpcFunctionsCollectorBase as o, getDefinitionsWithDumps as r, getRpcHandler as s, createClientFromDump as t };

package/dist/server-DrBxa6ZV.mjs

@@ -0,0 +1,49 @@
+import { createRpcServer } from "./rpc/server.mjs";
+import { attachWsRpcTransport } from "./rpc/transports/ws-server.mjs";
+import { WebSocketServer } from "ws";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { createServer } from "node:http";
+import { createApp, toNodeListener } from "h3";
+//#region src/node/server.ts
+/**
+* Compose an h3 + WebSocket server for a devtool context. The RPC
+* group is bound to `context.rpc.functions`; the WS endpoint lives on
+* the same port as the HTTP server.
+*/
+async function startHttpAndWs(options) {
+	const { context, port } = options;
+	const bindHost = options.host ?? "localhost";
+	const app = options.app ?? createApp();
+	const httpServer = createServer(toNodeListener(app));
+	const wss = new WebSocketServer({ server: httpServer });
+	const rpcHost = context.rpc;
+	const asyncStorage = new AsyncLocalStorage();
+	const rpcGroup = createRpcServer(rpcHost.functions);
+	attachWsRpcTransport(rpcGroup, { wss });
+	rpcHost._rpcGroup = rpcGroup;
+	rpcHost._asyncStorage = asyncStorage;
+	rpcHost._authDisabled = options.auth === false;
+	await new Promise((resolveListen) => {
+		httpServer.listen(port, bindHost, () => resolveListen());
+	});
+	const origin = `http://${bindHost}:${port}`;
+	if (options.onReady) await options.onReady({
+		origin,
+		port,
+		app
+	});
+	return {
+		origin,
+		port,
+		app,
+		wss,
+		rpcGroup,
+		async close() {
+			for (const ws of wss.clients) ws.terminate();
+			await new Promise((r) => wss.close(() => r()));
+			await new Promise((r) => httpServer.close(() => r()));
+		}
+	};
+}
+//#endregion
+export { startHttpAndWs as t };

package/dist/src-BoIqXRc9.mjs

@@ -0,0 +1,85 @@
+import { t as createDefineWrapperWithContext } from "./define-Bb4zh-Dc.mjs";
+import { safeParse } from "valibot";
+//#region src/adapters/flags.ts
+/**
+* Identity helper that preserves the literal schema-map type — use this
+* so `InferCliFlags<typeof myFlags>` resolves to the right object shape.
+*
+* ```ts
+* const appFlags = defineCliFlags({
+*   depth: v.pipe(v.number(), v.integer()),
+*   config: v.optional(v.string()),
+* })
+*
+* defineDevtool({
+*   cli: { flags: appFlags },
+*   setup(ctx, info) {
+*     const flags = info.flags as InferCliFlags<typeof appFlags>
+*     flags.depth // number
+*     flags.config // string | undefined
+*   },
+* })
+* ```
+*/
+function defineCliFlags(flags) {
+	return flags;
+}
+/**
+* Best-effort probe of a valibot schema to decide whether the
+* corresponding CAC option takes a value. Unwraps `optional` / `nullable`
+* / `nullish` / `default` / `pipe` wrappers then matches on the inner
+* type's kind.
+*/
+function getSchemaKind(schema) {
+	let current = schema;
+	while (current) {
+		const kind = current.type;
+		if (kind === "optional" || kind === "nullable" || kind === "nullish" || kind === "undefined") {
+			current = current.wrapped ?? current.inner;
+			continue;
+		}
+		if (kind === "pipe" && Array.isArray(current.pipe) && current.pipe.length > 0) {
+			current = current.pipe[0];
+			continue;
+		}
+		return kind;
+	}
+	return "unknown";
+}
+/** Whether the CAC option for this schema should be a boolean flag. */
+function isBooleanFlag(schema) {
+	return getSchemaKind(schema) === "boolean";
+}
+/** Validate and coerce the raw cac-parsed bag against a {@link CliFlagsSchema}. */
+function parseCliFlags(schema, raw) {
+	const flags = {};
+	const issues = [];
+	for (const [key, fieldSchema] of Object.entries(schema)) {
+		const result = safeParse(fieldSchema, raw[key]);
+		if (result.success) flags[key] = result.output;
+		else issues.push(`--${toKebab(key)}: ${result.issues.map((i) => i.message).join(", ")}`);
+	}
+	for (const [key, value] of Object.entries(raw)) if (!(key in schema) && !(key in flags)) flags[key] = value;
+	return issues.length ? {
+		flags,
+		issues
+	} : { flags };
+}
+function toKebab(camel) {
+	return camel.replaceAll(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+}
+/** Kebab-case a schema key for CAC option registration. */
+function flagKeyToOption(camel) {
+	return toKebab(camel);
+}
+//#endregion
+//#region src/define.ts
+const defineRpcFunction = createDefineWrapperWithContext();
+function defineCommand(command) {
+	return command;
+}
+function defineJsonRenderSpec(spec) {
+	return spec;
+}
+//#endregion
+export { flagKeyToOption as a, defineCliFlags as i, defineJsonRenderSpec as n, isBooleanFlag as o, defineRpcFunction as r, parseCliFlags as s, defineCommand as t };

package/dist/static-dump-CQUC1aIW.mjs

@@ -0,0 +1,82 @@
+import { n as dumpFunctions, s as getRpcHandler } from "./rpc-9FNa3Inb.mjs";
+import { DEVTOOLS_RPC_DUMP_DIRNAME } from "./constants.mjs";
+//#region src/node/host-h3.ts
+/**
+* h3-backed {@link DevToolsHost} — used by the standalone CLI adapter.
+* This commit adds the shell; the CLI adapter in commit 5 wires it up
+* with a real h3 app and sirv handler.
+*/
+function createH3DevToolsHost(options) {
+	return {
+		mountStatic(base, distDir) {
+			return options.mount?.(base, distDir);
+		},
+		resolveOrigin() {
+			return options.origin;
+		}
+	};
+}
+//#endregion
+//#region src/node/static-dump.ts
+function makeDumpKey(name) {
+	return encodeURIComponent(name.replaceAll(":", "~"));
+}
+function makeStaticPath(name) {
+	return `${DEVTOOLS_RPC_DUMP_DIRNAME}/${makeDumpKey(name)}.static.json`;
+}
+function makeQueryRecordPath(name, hash) {
+	return `${DEVTOOLS_RPC_DUMP_DIRNAME}/${makeDumpKey(name)}.record.${hash}.json`;
+}
+function makeQueryFallbackPath(name) {
+	return `${DEVTOOLS_RPC_DUMP_DIRNAME}/${makeDumpKey(name)}.fallback.json`;
+}
+async function resolveRecord(record) {
+	return typeof record === "function" ? await record() : record;
+}
+async function collectStaticRpcDump(definitions, context) {
+	const manifest = {};
+	const files = {};
+	for (const definition of definitions) {
+		const type = definition.type ?? "query";
+		if (type === "static") {
+			const handler = await getRpcHandler(definition, context);
+			const path = makeStaticPath(definition.name);
+			files[path] = { output: await Promise.resolve(handler()) };
+			manifest[definition.name] = {
+				type: "static",
+				path
+			};
+			continue;
+		}
+		if (type !== "query") continue;
+		const store = await dumpFunctions([definition], context);
+		if (!(definition.name in store.definitions)) continue;
+		const queryEntry = {
+			type: "query",
+			records: {}
+		};
+		const prefix = `${definition.name}---`;
+		for (const [recordKey, recordOrGetter] of Object.entries(store.records)) {
+			if (!recordKey.startsWith(prefix)) continue;
+			const key = recordKey.slice(prefix.length);
+			const record = await resolveRecord(recordOrGetter);
+			if (key === "fallback") {
+				const path = makeQueryFallbackPath(definition.name);
+				files[path] = record;
+				queryEntry.fallback = path;
+			} else {
+				const path = makeQueryRecordPath(definition.name, key);
+				files[path] = record;
+				queryEntry.records[key] = path;
+			}
+		}
+		if (!Object.keys(queryEntry.records).length && !queryEntry.fallback) continue;
+		manifest[definition.name] = queryEntry;
+	}
+	return {
+		manifest,
+		files
+	};
+}
+//#endregion
+export { createH3DevToolsHost as n, collectStaticRpcDump as t };

package/dist/transports-BPUzHhI2.mjs

@@ -0,0 +1,15 @@
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+//#region src/node/mcp/transports.ts
+/**
+* Start the MCP server on stdio. Returns a stop function.
+* @internal
+*/
+async function startStdioTransport(server) {
+	const transport = new StdioServerTransport();
+	await server.connect(transport);
+	return async () => {
+		await server.close();
+	};
+}
+//#endregion
+export { startStdioTransport };