devframe 0.0.0 → 0.1.17

package/dist/rpc-hbRk8qtt.mjs

@@ -0,0 +1,456 @@
+import { c as logger } from "./serialization-CWcWE7x7.mjs";
+import { hash } from "ohash";
+//#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();
+	}
+};
+//#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.DF0024({ 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.DF0021({ name: fn.name }).throw();
+		assertAgentJsonSerializable(fn);
+		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.DF0022({ name: fn.name }).throw();
+		assertAgentJsonSerializable(fn);
+		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.DF0023({ 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());
+	}
+};
+function assertAgentJsonSerializable(fn) {
+	if (fn.agent && fn.jsonSerializable !== true) throw logger.DF0019({ name: fn.name }).throw();
+}
+//#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.DF0027({
+			name: definition.name,
+			type
+		}).throw();
+		if (definition.snapshot && type !== "query") throw logger.DF0028({
+			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.DF0024({ 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.DF0025({ 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.DF0026({
+					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/serialization-CWcWE7x7.mjs

@@ -0,0 +1,112 @@
+import { consoleReporter, createLogger, defineDiagnostics, plainFormatter } from "logs-sdk";
+import { deserialize as structuredCloneDeserialize, parse as structuredCloneParse, serialize as structuredCloneSerialize, stringify as structuredCloneStringify } from "structured-clone-es";
+//#region src/rpc/diagnostics.ts
+const diagnostics = defineDiagnostics({
+	docsBase: "https://devtools.vite.dev/devframe/errors",
+	codes: {
+		DF0019: {
+			message: (p) => `RPC function "${p.name}" has \`agent\` set but \`jsonSerializable\` is not \`true\` — MCP requires JSON-serializable data.`,
+			hint: "Set `jsonSerializable: true` if the payload is JSON-safe, or remove `agent` to keep it RPC-only."
+		},
+		DF0020: {
+			message: (p) => `RPC function "${p.name}" declares \`jsonSerializable: true\` but the value at "${p.path}" is a ${p.type}.`,
+			hint: "Either drop `jsonSerializable: true` (falls back to structured-clone) or change the value to a JSON-safe shape."
+		},
+		DF0021: {
+			message: (p) => `RPC function "${p.name}" is already registered`,
+			hint: "Use the `force` parameter to overwrite an existing registration."
+		},
+		DF0022: { message: (p) => `RPC function "${p.name}" is not registered. Use register() to add new functions.` },
+		DF0023: { message: (p) => `RPC function "${p.name}" is not registered` },
+		DF0024: { message: (p) => `Either handler or setup function must be provided for RPC function "${p.name}"` },
+		DF0025: { message: (p) => `Function "${p.name}" not found in dump store` },
+		DF0026: { message: (p) => `No dump match for "${p.name}" with args: ${p.args}` },
+		DF0027: { message: (p) => `Function "${p.name}" with type "${p.type}" cannot have dump configuration. Only "static" and "query" types support dumps.` },
+		DF0028: {
+			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`."
+		}
+	}
+});
+const logger = createLogger({
+	diagnostics: [diagnostics],
+	formatter: plainFormatter,
+	reporters: consoleReporter
+});
+//#endregion
+//#region src/rpc/serialization.ts
+/**
+* Wire format used by the WS RPC transport.
+*
+* - **JSON (default, unprefixed):** payload is plain JSON text. Used when
+*   the dispatched method is declared `jsonSerializable: true`. Encoded
+*   via {@link strictJsonStringify} (rejects non-JSON values), decoded
+*   via `JSON.parse`.
+* - **Structured-clone (`s:` prefix):** payload is `s:` followed by
+*   `structured-clone-es` text. Used when the method is declared
+*   `jsonSerializable: false` (or omitted, the default). Round-trips
+*   `Map`, `Set`, `Date`, `BigInt`, cycles, and class instances.
+*
+* birpc envelopes always start with `{`, so a leading byte that is not
+* `s` is unambiguously JSON. Each direction independently chooses its
+* encoding from local definitions — request and response are not
+* coupled by a mirror rule.
+*/
+const STRUCTURED_CLONE_PREFIX = "s:";
+/**
+* `JSON.stringify` with a single-pass strict replacer.
+*
+* Throws `DF0020` synchronously when the value contains a type JSON
+* cannot round-trip losslessly: `Map`, `Set`, `Date`, `BigInt`, class
+* instances, or `undefined` inside an array (silently becomes `null`).
+*
+* Native pass-throughs (no extra work needed):
+*   - circular references — `JSON.stringify` raises `TypeError`.
+*   - `BigInt` at top level — caught here for a friendlier error path.
+*
+* Lenient cases (allowed without throwing):
+*   - `undefined` as an object property — legitimate optional field;
+*     JSON.stringify just omits it.
+*   - `undefined` at the root — legitimate "action returned nothing".
+*   - `Symbol` / `Function` values — semantically "drop me" in JSON.
+*
+* `fnName` is used only for the diagnostic message — pass the RPC
+* function name when calling from a wire serializer / dump writer so
+* the error points at the offending function.
+*/
+function strictJsonStringify(value, fnName = "") {
+	return JSON.stringify(value, function strictReplacer(key, val) {
+		const holder = this;
+		const original = holder != null ? holder[key] : val;
+		if (original === void 0) {
+			if (Array.isArray(holder)) throw nonJsonAt(fnName, "undefined", holder, key);
+			return val;
+		}
+		if (original === null) return val;
+		if (typeof original === "bigint") throw nonJsonAt(fnName, "BigInt", holder, key);
+		if (typeof original === "object") {
+			if (original instanceof Map) throw nonJsonAt(fnName, "Map", holder, key);
+			if (original instanceof Set) throw nonJsonAt(fnName, "Set", holder, key);
+			if (original instanceof Date) throw nonJsonAt(fnName, "Date", holder, key);
+			if (Array.isArray(original)) return val;
+			const proto = Object.getPrototypeOf(original);
+			if (proto !== null && proto !== Object.prototype) throw nonJsonAt(fnName, original.constructor?.name ?? "class instance", holder, key);
+		}
+		return val;
+	});
+}
+function nonJsonAt(fnName, type, parent, key) {
+	const path = formatPath(parent, key);
+	return logger.DF0020({
+		name: fnName || "<anonymous>",
+		type,
+		path
+	}).throw();
+}
+function formatPath(parent, key) {
+	if (Array.isArray(parent)) return `[${key}]`;
+	if (key === "") return "<root>";
+	return key;
+}
+//#endregion
+export { structuredCloneSerialize as a, logger as c, structuredCloneParse as i, strictJsonStringify as n, structuredCloneStringify as o, structuredCloneDeserialize as r, diagnostics as s, STRUCTURED_CLONE_PREFIX as t };

package/dist/server-DkJ2-s0Y.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-DIKqQIjp.mjs

@@ -0,0 +1,85 @@
+import { t as createDefineWrapperWithContext } from "./define-CW9gLnyG.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 };