devframe 0.9.8 → 0.9.9

package/dist/{rpc-core-DlHd276T.mjs → rpc-core-DVQ7xi89.mjs}

@@ -1,12 +1,12 @@
 import { n as __exportAll } from "./rolldown-runtime-B4iAMlE-.mjs";
 import { createRpcServer } from "./rpc/server.mjs";
-import { t as diagnostics } from "./diagnostics-BXWW3VK-.mjs";
+import { t as diagnostics } from "./diagnostics-BMfN8mb1.mjs";
 import { AsyncLocalStorage } from "node:async_hooks";
 //#region src/node/rpc-core.ts
 var rpc_core_exports = /* @__PURE__ */ __exportAll({ createContextRpcServer: () => createContextRpcServer });
 /**
 * Bind a devframe context's registered RPC functions to a birpc group,
-* transport-agnostically — the shared core under the instance shell's own
+* transport-agnostically: the shared core under the instance shell's own
 * HTTP+WS binding (Node http + WS) and the Bun fetch-upgrade tier of
 * `createHandler`.
 *
@@ -26,8 +26,20 @@ function createContextRpcServer(options) {
 		for (const fn of authHandler.rpcFunctions) if (!rpcHost.definitions.has(fn.name)) rpcHost.register(fn);
 	}
 	const rpcGroup = createRpcServer(rpcHost.functions, { rpcOptions: {
+		/**
+		* Forwarded as-is so a host with its own structured diagnostics
+		* keeps seeing RPC failures.
+		*/
 		onFunctionError: options.rpcOptions?.onFunctionError,
 		onGeneralError: options.rpcOptions?.onGeneralError,
+		/**
+		* Wrap each RPC handler in an AsyncLocalStorage context so
+		* `ctx.rpc.getCurrentRpcSession()` works inside handlers (used
+		* by streaming subscribe/unsubscribe/cancel and shared-state
+		* sync), and (when an `authorize` gate is configured) reject
+		* the call before it ever reaches the handler. Mirrors
+		* `packages/core/src/node/ws.ts`'s resolver.
+		*/
 		resolver(name, fn) {
 			const rpc = this;
 			if (!fn) return void 0;

package/dist/{serialization-BGzEwAdr.mjs → serialization-DTZnPQ1-.mjs}

@@ -1,4 +1,4 @@
-import { t as diagnostics } from "./diagnostics-CD8nlgll.mjs";
+import { t as diagnostics } from "./diagnostics-D0EVm5M6.mjs";
 //#region src/rpc/serialization.ts
 /**
 * Wire format used by the live RPC transports (WebSocket and SSE).
@@ -14,7 +14,7 @@ import { t as diagnostics } from "./diagnostics-CD8nlgll.mjs";
 *
 * 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
+* encoding from local definitions; request and response are not
 * coupled by a mirror rule.
 */
 const STRUCTURED_CLONE_PREFIX = "s:";
@@ -26,16 +26,16 @@ const STRUCTURED_CLONE_PREFIX = "s:";
 * 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.
+*   - 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;
+*   - `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.
+*   - `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
+* `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.
 */
@@ -47,19 +47,21 @@ function strictJsonStringify(value, fnName = "") {
 			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);
-		}
+		if (original !== null) assertJsonSafe(original, holder, key, fnName);
 		return val;
 	});
 }
+/** Throw `DF0020` when `original` is a type JSON can't round-trip losslessly. */
+function assertJsonSafe(original, holder, key, fnName) {
+	if (typeof original === "bigint") throw nonJsonAt(fnName, "BigInt", holder, key);
+	if (typeof original !== "object") return;
+	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;
+	const proto = Object.getPrototypeOf(original);
+	if (proto !== null && proto !== Object.prototype) throw nonJsonAt(fnName, original.constructor?.name ?? "class instance", holder, key);
+}
 function nonJsonAt(fnName, type, parent, key) {
 	const path = formatPath(parent, key);
 	return diagnostics.DF0020({

package/dist/{services-install-CqqQVls5.mjs → services-install-P_DV7VYL.mjs}

@@ -1,5 +1,5 @@
-import { t as DEVFRAME_EVENTS } from "./events-4daw0uK9.mjs";
-import { t as diagnostics } from "./diagnostics-BXWW3VK-.mjs";
+import { t as DEVFRAME_EVENTS } from "./events-BV4Dj59a.mjs";
+import { t as diagnostics } from "./diagnostics-BMfN8mb1.mjs";
 import { createRequire } from "node:module";
 import { pathToFileURL } from "node:url";
 import { isAbsolute, join } from "pathe";
@@ -219,6 +219,12 @@ var DevframeAgentHost = class {
 			description: input.description,
 			safety: input.safety ?? "action",
 			tags: input.tags,
+			/**
+			* Standard Schema `args` are carried raw (mirroring how an RPC-backed
+			* tool defers to `ctx.rpc.definitions`); consumers (the MCP adapter)
+			* convert to JSON Schema on demand. An explicit `inputSchema` override
+			* wins when given.
+			*/
 			args: input.args,
 			inputSchema: input.inputSchema,
 			outputSchema: input.outputSchema,
@@ -268,7 +274,7 @@ function inferSafety(type) {
 //#region src/node/services-install.ts
 /**
 * Turn a `resolveFrom` value (a file path, a file URL like `import.meta.url`,
-* or a directory) into something `createRequire` accepts — a directory gets a
+* or a directory) into something `createRequire` accepts; a directory gets a
 * synthetic filename appended so resolution starts inside it.
 */
 function toRequireBase(resolveFrom) {
@@ -341,6 +347,24 @@ function compareVersions(a, b) {
 	if (a.prerelease && b.prerelease) return a.prerelease < b.prerelease ? -1 : a.prerelease > b.prerelease ? 1 : 0;
 	return 0;
 }
+/** Whether `version` and `base` share their first `lockUpTo + 1` parts. */
+function partsMatchUpTo(version, base, lockUpTo) {
+	for (let i = 0; i <= lockUpTo; i++) if ((version.parts[i] ?? 0) !== (base.parts[i] ?? 0)) return false;
+	return true;
+}
+function satisfiesCaret(version, base) {
+	if (compareVersions(version, base) < 0) return false;
+	const fixedIndex = base.parts.findIndex((part) => part !== 0);
+	return partsMatchUpTo(version, base, fixedIndex === -1 ? base.parts.length - 1 : fixedIndex);
+}
+function satisfiesTilde(version, base, segments) {
+	if (compareVersions(version, base) < 0) return false;
+	return partsMatchUpTo(version, base, segments.length >= 2 ? 1 : 0);
+}
+function satisfiesExactOrPrefix(version, base, segments) {
+	for (let i = 0; i < Math.max(segments.length, 3); i++) if (i < segments.length && (version.parts[i] ?? 0) !== (base.parts[i] ?? 0)) return false;
+	return segments.length >= 3 ? compareVersions(version, base) === 0 : true;
+}
 function satisfiesComparator(version, comparator) {
 	const raw = comparator.trim();
 	if (!raw || raw === "*" || raw === "x") return true;
@@ -356,26 +380,13 @@ function satisfiesComparator(version, comparator) {
 		case ">=": return compareVersions(version, base) >= 0;
 		case "<": return compareVersions(version, base) < 0;
 		case "<=": return compareVersions(version, base) <= 0;
-		case "^": {
-			if (compareVersions(version, base) < 0) return false;
-			const fixedIndex = base.parts.findIndex((part) => part !== 0);
-			const lockUpTo = fixedIndex === -1 ? base.parts.length - 1 : fixedIndex;
-			for (let i = 0; i <= lockUpTo; i++) if ((version.parts[i] ?? 0) !== (base.parts[i] ?? 0)) return false;
-			return true;
-		}
-		case "~": {
-			if (compareVersions(version, base) < 0) return false;
-			const lockUpTo = segments.length >= 2 ? 1 : 0;
-			for (let i = 0; i <= lockUpTo; i++) if ((version.parts[i] ?? 0) !== (base.parts[i] ?? 0)) return false;
-			return true;
-		}
-		default:
-			for (let i = 0; i < Math.max(segments.length, 3); i++) if (i < segments.length && (version.parts[i] ?? 0) !== (base.parts[i] ?? 0)) return false;
-			return segments.length >= 3 ? compareVersions(version, base) === 0 : true;
+		case "^": return satisfiesCaret(version, base);
+		case "~": return satisfiesTilde(version, base, segments);
+		default: return satisfiesExactOrPrefix(version, base, segments);
 	}
 }
 /**
-* Pragmatic semver range check for service version declarations — supports
+* Pragmatic semver range check for service version declarations; supports
 * the common forms (`1.2.3`, `^1.2.3`, `~1.2`, `>=1 <3`, `1.x`, `*`, and
 * `||`-joined alternatives) without pulling in a semver dependency. An
 * unparseable version or range reads as **not satisfied**.
@@ -402,7 +413,7 @@ function deepMergeTwo(a, b) {
 }
 /**
 * Default option-set merge when a service declares no `mergeOptions`:
-* deep-merge in declaration order — objects recurse, arrays union-dedupe,
+* deep-merge in declaration order: objects recurse, arrays union-dedupe,
 * scalars take the later value. Covers the built-in services (`roots` /
 * `langs` union, `themes` per-key last-wins) without a custom hook.
 */

package/dist/session-DPfj6zQG.mjs

@@ -0,0 +1,16 @@
+//#region src/rpc/transports/session.ts
+let sessionId = 0;
+/**
+* Mint the per-connection session meta every transport binding shares:
+* one id space across transports, so session bookkeeping (streaming
+* subscriptions, shared-state sync, auth trust) never collides between a
+* WS peer and an SSE session on the same server.
+*/
+function createRpcSessionMeta() {
+	return {
+		id: sessionId++,
+		subscribedStates: /* @__PURE__ */ new Set()
+	};
+}
+//#endregion
+export { createRpcSessionMeta as t };

package/dist/{shared-state--sduc6Xi.mjs → shared-state-CaxB1q0h.mjs}

@@ -931,8 +931,8 @@ function createSharedState(options) {
 			if (syncIds.has(syncId)) return;
 			rememberSyncId(syncIds, syncId);
 			if (enablePatches$1) {
-				const [newState, patches] = produceWithPatches(state, fn);
-				state = newState;
+				const [nextState, patches] = produceWithPatches(state, fn);
+				state = nextState;
 				events.emit("updated", state, patches, syncId);
 			} else {
 				state = produce(state, fn);

package/dist/{simple-schema-DQPZrAaZ.mjs → simple-schema-Bi40l-P6.mjs}

@@ -37,7 +37,7 @@ function number() {
 function boolean() {
 	return make("boolean", (v) => typeof v === "boolean" ? ok(v) : fail("Expected a boolean"));
 }
-/** `undefined` — mirrors valibot's `void`. */
+/** `undefined`, mirroring valibot's `void`. */
 function voidType() {
 	return make("void", (v) => v === void 0 ? ok(void 0) : fail("Expected undefined"));
 }
@@ -130,7 +130,7 @@ function describe(schema, description) {
 	};
 }
 /**
-* Grouped access to every builder — `s.string()`, `s.object({ ... })`,
+* Grouped access to every builder: `s.string()`, `s.object({ ... })`,
 * `s.void()`, etc. Handy for a valibot-like `import { s } from
 * 'devframe/utils/simple-schema'` call site.
 */

package/dist/{sse-client-DwX021ST.d.mts → sse-client-BQ4jS3eO.d.mts}

@@ -1,4 +1,4 @@
-import { v as RpcFunctionDefinitionAny } from "./types-CMdPYhOx.mjs";
+import { v as RpcFunctionDefinitionAny } from "./types-Dq4i156u.mjs";
 import { ChannelOptions } from "birpc";
 //#region src/rpc/transports/sse-client.d.ts
 interface SseRpcChannelOptions {
@@ -10,7 +10,7 @@ interface SseRpcChannelOptions {
   authToken?: string;
   /**
    * RPC function definitions (or just the `jsonSerializable` flag per
-   * method) used to dispatch the per-call wire serializer — same contract
+   * method) used to dispatch the per-call wire serializer, the same contract
    * as the WS channel.
    */
   definitions?: ReadonlyMap<string, Pick<RpcFunctionDefinitionAny, 'jsonSerializable'>>;
@@ -19,7 +19,7 @@ interface SseRpcChannelOptions {
 }
 /**
  * Build a birpc `ChannelOptions` object backed by an SSE stream (server →
- * client) and HTTP `POST` (client → server) — the WebSocket-free counterpart
+ * client) and HTTP `POST` (client → server): the WebSocket-free counterpart
  * to `createWsRpcChannel`, wire-compatible with `attachSseRpcTransport`.
  *
  * The stream is consumed via `fetch` streaming (not `EventSource`), so it
@@ -27,7 +27,7 @@ interface SseRpcChannelOptions {
  * (`event: session`) carries the session id; every `POST` echoes it in the
  * `x-birpc-session` header. A response to a client-initiated request comes
  * back in the `POST`'s own body and is re-injected into the channel; a
- * dropped stream terminates the channel — there is no reconnect, matching
+ * dropped stream terminates the channel; there is no reconnect, matching
  * the WS channel's closed-is-done semantics.
  */
 declare function createSseRpcChannel(options: SseRpcChannelOptions): ChannelOptions & {

package/dist/{state-CK9LjrnT.mjs → state-CeQQWzM-.mjs}

@@ -1,5 +1,5 @@
 import { DEVFRAME_OTP_URL_PARAM } from "./constants.mjs";
-import { n as randomToken, r as timingSafeEqual, t as randomDigits } from "./crypto-token-XCqTSMg9.mjs";
+import { n as randomToken, r as timingSafeEqual, t as randomDigits } from "./crypto-token-TVbGGFuj.mjs";
 //#region ../../node_modules/.pnpm/ua-parser-modern@0.1.1/node_modules/ua-parser-modern/dist/index.mjs
 const EMPTY = "";
 const UNKNOWN = "?";
@@ -1169,7 +1169,7 @@ function parseUA(uastringOrExtensions, extensions) {
 *
 * The client used to parse+format this itself, but that pulled
 * `ua-parser-modern` into the browser bundle for a label nothing else on
-* the client needs — the client now sends the raw string and parsing
+* the client needs; the client now sends the raw string and parsing
 * happens here, at the server ingress, keeping the persisted label format
 * identical.
 */
@@ -1221,13 +1221,13 @@ function refreshTempAuthCode() {
 }
 /**
 * Build a "magic link" authentication URL that embeds a one-time code (OTP) in
-* the URL **fragment**. Opening it authenticates the client without typing —
+* the URL **fragment**. Opening it authenticates the client without typing;
 * print it on startup (devframe stays headless, so the host prints its own
 * banner). Defaults to the current code; the link is subject to the same TTL.
 *
 * The code rides the fragment (`#devframe_otp=…`), not the query string, so it
 * is never sent to the server, written to an access log, or leaked in a
-* `Referer` header — the browser client reads it locally (see
+* `Referer` header; the browser client reads it locally (see
 * `consumeOtpFromUrl`). Any existing fragment parameters are preserved.
 */
 function buildOtpAuthUrl(baseUrl, code = tempAuthCode) {

package/dist/{static-DV_qUSRS.mjs → static-DZ8P2Kn7.mjs}

@@ -1,5 +1,5 @@
-import { n as validateDefinitions, r as getRpcHandler, s as hash } from "./validation-YrZH6atx.mjs";
-import { t as diagnostics } from "./diagnostics-CD8nlgll.mjs";
+import { n as validateDefinitions, r as getRpcHandler, s as hash } from "./validation-BOy8IoFZ.mjs";
+import { t as diagnostics } from "./diagnostics-D0EVm5M6.mjs";
 import { DEVFRAME_RPC_DUMP_DIRNAME } from "./constants.mjs";
 //#region ../../node_modules/.pnpm/yocto-queue@1.2.2/node_modules/yocto-queue/index.js
 var Node = class {
@@ -156,9 +156,9 @@ function serializeWithSeen(error, seen) {
 	};
 	const cause = error.cause;
 	if (cause !== void 0) out.cause = cause instanceof Error ? serializeWithSeen(cause, seen) : cause;
-	for (const key of Object.keys(error)) {
+	for (const [key, value] of Object.entries(error)) {
 		if (key === "name" || key === "message" || key === "cause") continue;
-		out[key] = error[key];
+		out[key] = value;
 	}
 	return out;
 }
@@ -168,13 +168,11 @@ function serializeWithSeen(error, seen) {
 * the original `name`, and re-attaches any custom own properties.
 */
 function reviveDumpError(stored) {
-	const cause = stored.cause instanceof Error ? stored.cause : isPlainErrorShape(stored.cause) ? reviveDumpError(stored.cause) : stored.cause;
-	const error = cause !== void 0 ? new Error(stored.message, { cause }) : new Error(stored.message);
-	error.name = stored.name;
-	for (const key of Object.keys(stored)) {
-		if (key === "name" || key === "message" || key === "cause") continue;
-		error[key] = stored[key];
-	}
+	const { name, message, cause: rawCause, ...extras } = stored;
+	const cause = rawCause instanceof Error ? rawCause : isPlainErrorShape(rawCause) ? reviveDumpError(rawCause) : rawCause;
+	const error = cause !== void 0 ? new Error(message, { cause }) : new Error(message);
+	error.name = name;
+	Object.assign(error, extras);
 	return error;
 }
 function isPlainErrorShape(value) {
@@ -191,15 +189,77 @@ function getDumpFallbackKey(functionName) {
 async function resolveGetter(valueOrGetter) {
 	return typeof valueOrGetter === "function" ? await valueOrGetter() : valueOrGetter;
 }
+/** Run tasks sequentially (`concurrency <= 1`) or through a `p-limit` pool. */
+async function runDumpTasks(tasks, concurrency) {
+	if (concurrency <= 1) {
+		const out = [];
+		for (const task of tasks) out.push(await task());
+		return out;
+	}
+	const limit = pLimit(concurrency);
+	return Promise.all(tasks.map((task) => limit(task)));
+}
 /**
-* 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 })
-* ```
+* Resolve one definition's handler + dump config and register it in the store.
+* Returns `undefined` for definitions that carry no dump.
 */
+async function resolveDumpTask(definition, context, store) {
+	if (definition.type === "event" || definition.type === "action") return void 0;
+	const setupResult = definition.setup ? await Promise.resolve(definition.setup(context)) : {};
+	const handler = setupResult.handler || definition.handler;
+	if (!handler) throw diagnostics.DF0024({ name: definition.name });
+	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 void 0;
+	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
+	};
+}
+/**
+* Write a resolved dump's pre-defined records and fallback into the store, and
+* return the per-input execution tasks that fill in the rest.
+*/
+function collectDumpTasks(resolution, store) {
+	const { definition, handler, dump } = resolution;
+	const { inputs, records, fallback } = dump;
+	if (records) for (const record of records) store.records[getDumpRecordKey(definition.name, record.inputs)] = record;
+	if ("fallback" in dump) store.records[getDumpFallbackKey(definition.name)] = {
+		inputs: [],
+		output: fallback
+	};
+	if (!inputs) return [];
+	return inputs.map((input) => async () => {
+		const recordKey = getDumpRecordKey(definition.name, input);
+		try {
+			store.records[recordKey] = {
+				inputs: input,
+				output: await Promise.resolve(handler(...input))
+			};
+		} catch (error) {
+			store.records[recordKey] = {
+				inputs: input,
+				error: serializeDumpError(error)
+			};
+		}
+	});
+}
 async function dumpFunctions(definitions, context, options = {}) {
 	validateDefinitions(definitions);
 	const concurrency = options.concurrency === true ? 5 : options.concurrency === false || options.concurrency == null ? 1 : options.concurrency;
@@ -207,79 +267,7 @@ async function dumpFunctions(definitions, context, options = {}) {
 		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 diagnostics.DF0024({ name: definition.name });
-		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: serializeDumpError(error)
-				};
-			}
-		});
-	}
-	if (concurrency <= 1) for (const task of dumpTasks) await task();
-	else {
-		const limit = pLimit(concurrency);
-		await Promise.all(dumpTasks.map((task) => limit(task)));
-	}
+	await runDumpTasks((await runDumpTasks(definitions.map((definition) => () => resolveDumpTask(definition, context, store)), concurrency)).filter((x) => !!x).flatMap((resolution) => collectDumpTasks(resolution, store)), concurrency);
 	return store;
 }
 /**
@@ -359,6 +347,54 @@ function makeQueryFallbackPath(name) {
 async function resolveRecord(record) {
 	return typeof record === "function" ? await record() : record;
 }
+async function collectStaticDefinition(definition, context, serialization, files) {
+	const handler = await getRpcHandler(definition, context);
+	const path = makeStaticPath(definition.name);
+	files[path] = {
+		serialization,
+		fnName: definition.name,
+		data: { output: await Promise.resolve(handler()) }
+	};
+	return {
+		type: "static",
+		path,
+		serialization
+	};
+}
+async function collectQueryDefinition(definition, context, serialization, files) {
+	const store = await dumpFunctions([definition], context);
+	if (!(definition.name in store.definitions)) return void 0;
+	const queryEntry = {
+		type: "query",
+		records: {},
+		serialization
+	};
+	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] = {
+				serialization,
+				fnName: definition.name,
+				data: record
+			};
+			queryEntry.fallback = path;
+		} else {
+			const path = makeQueryRecordPath(definition.name, key);
+			files[path] = {
+				serialization,
+				fnName: definition.name,
+				data: record
+			};
+			queryEntry.records[key] = path;
+		}
+	}
+	if (!Object.keys(queryEntry.records).length && !queryEntry.fallback) return void 0;
+	return queryEntry;
+}
 async function collectStaticRpcDump(definitions, context) {
 	const manifest = {};
 	const files = {};
@@ -366,53 +402,12 @@ async function collectStaticRpcDump(definitions, context) {
 		const type = definition.type ?? "query";
 		const serialization = definition.jsonSerializable === true ? "json" : "structured-clone";
 		if (type === "static") {
-			const handler = await getRpcHandler(definition, context);
-			const path = makeStaticPath(definition.name);
-			files[path] = {
-				serialization,
-				fnName: definition.name,
-				data: { output: await Promise.resolve(handler()) }
-			};
-			manifest[definition.name] = {
-				type: "static",
-				path,
-				serialization
-			};
+			manifest[definition.name] = await collectStaticDefinition(definition, context, serialization, files);
 			continue;
 		}
 		if (type !== "query") continue;
-		const store = await dumpFunctions([definition], context);
-		if (!(definition.name in store.definitions)) continue;
-		const queryEntry = {
-			type: "query",
-			records: {},
-			serialization
-		};
-		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] = {
-					serialization,
-					fnName: definition.name,
-					data: record
-				};
-				queryEntry.fallback = path;
-			} else {
-				const path = makeQueryRecordPath(definition.name, key);
-				files[path] = {
-					serialization,
-					fnName: definition.name,
-					data: record
-				};
-				queryEntry.records[key] = path;
-			}
-		}
-		if (!Object.keys(queryEntry.records).length && !queryEntry.fallback) continue;
-		manifest[definition.name] = queryEntry;
+		const queryEntry = await collectQueryDefinition(definition, context, serialization, files);
+		if (queryEntry) manifest[definition.name] = queryEntry;
 	}
 	return {
 		manifest,

package/dist/{storage-BXNVhKyR.mjs → storage-Dccf_IyD.mjs}

@@ -1,4 +1,4 @@
-import { t as diagnostics } from "./diagnostics-BXWW3VK-.mjs";
+import { t as diagnostics } from "./diagnostics-BMfN8mb1.mjs";
 import { createSharedState } from "devframe/utils/shared-state";
 import process from "node:process";
 import { dirname } from "pathe";