@voltro/cli 0.33.0 → 0.35.0

package/dist/codegen-CYM3Zqrf.js

@@ -0,0 +1,605 @@
+import { o as e } from "./fileConventions-Cof68_BL.js";
+import { dirname as t, join as n, relative as r, resolve as i } from "node:path";
+import { promises as a, readFileSync as o } from "node:fs";
+import { pathToFileURL as s } from "node:url";
+import { isEventDescriptor as c, isWireReachable as l } from "@voltro/protocol";
+import { undoSurfaceEnabled as u } from "@voltro/runtime";
+import { createHash as d } from "node:crypto";
+import { isAgentDescriptor as f } from "@voltro/ai/agent";
+//#region src/browserSafetyGuard.ts
+var p = /* @__PURE__ */ new Set(/* @__PURE__ */ "crypto.fs.path.os.net.http.https.http2.tls.dns.dgram.stream.zlib.child_process.worker_threads.cluster.readline.vm.module.perf_hooks.async_hooks.inspector.v8.process.tty.repl.constants.sys.string_decoder".split(".")), m = (e) => e.startsWith("node:") || p.has(e) || e === "@voltro/workflow" ? !0 : e === "@voltro/database/wire" ? !1 : e === "@voltro/database" || e.startsWith("@voltro/database/") || e === "@voltro/runtime" || e.startsWith("@voltro/runtime/") ? !0 : e === "@voltro/ai/agent" || e === "@voltro/ai/events" ? !1 : !!(e === "@voltro/ai" || e.startsWith("@voltro/ai/") || [
+	"@voltro/protocol/session",
+	"@voltro/protocol/jwt",
+	"@voltro/protocol/apikey"
+].includes(e) || e === "@voltro/env/server" || e.startsWith("@effect/cluster") || e.startsWith("@effect/sql") || e === "@effect/platform-node" || [
+	"pg",
+	"postgres",
+	"mysql2",
+	"tedious",
+	"better-sqlite3",
+	"ioredis",
+	"mongodb",
+	"@planetscale/database",
+	"@neondatabase/serverless",
+	"knex",
+	"drizzle-orm",
+	"@prisma/client",
+	"nodemailer",
+	"jose"
+].includes(e)), h = (e) => e.replace(/\/\*[\s\S]*?\*\//g, " ").replace(/(^|[^:])\/\/[^\n]*/g, "$1"), g = (e) => {
+	let t = h(e), n = [], r = /(?:^|[\n;}])\s*(?:import|export)\s+([^;'"]*?)\s+from\s+['"]([^'"]+)['"]/g, i;
+	for (; (i = r.exec(t)) !== null;) {
+		let e = i[1].trim();
+		if (e === "type" || e.startsWith("type ")) continue;
+		let t = e.match(/^\{([\s\S]*)\}$/);
+		if (t) {
+			let e = t[1].split(",").map((e) => e.trim()).filter(Boolean);
+			if (e.length > 0 && e.every((e) => e.startsWith("type "))) continue;
+		}
+		n.push(i[2]);
+	}
+	let a = /(?:^|[\n;}])\s*import\s+['"]([^'"]+)['"]/g;
+	for (; (i = a.exec(t)) !== null;) n.push(i[1]);
+	let o = /\bimport\(\s*['"]([^'"]+)['"]\s*\)/g;
+	for (; (i = o.exec(t)) !== null;) n.push(i[1]);
+	return n;
+}, _ = (e) => e.endsWith(".ts") || e.endsWith(".tsx"), v = async (e) => {
+	let t = _(e) ? [e] : [
+		`${e}.ts`,
+		`${e}.tsx`,
+		n(e, "index.ts"),
+		n(e, "index.tsx")
+	];
+	for (let e of t) try {
+		if ((await a.stat(e)).isFile()) return e;
+	} catch {}
+	return null;
+}, y = async (e, r) => {
+	let i = r;
+	for (;;) {
+		let r = n(i, "node_modules", e);
+		try {
+			if ((await a.stat(r)).isDirectory()) return r;
+		} catch {}
+		let o = t(i);
+		if (o === i) return null;
+		i = o;
+	}
+}, b = (e) => {
+	if (typeof e == "string") return e;
+	if (typeof e == "object" && e) {
+		let t = e;
+		for (let e of [
+			"import",
+			"module",
+			"node",
+			"default"
+		]) if (e in t) {
+			let n = b(t[e]);
+			if (n !== void 0) return n;
+		}
+	}
+}, x = async (e, r) => {
+	if (e.startsWith(".")) return v(i(t(r), e));
+	let o = e.split("/"), s = e.startsWith("@"), c = s ? `${o[0]}/${o[1]}` : o[0], l = s ? o.slice(2) : o.slice(1), u = l.length > 0 ? `./${l.join("/")}` : ".", d = await y(c, t(r));
+	if (!d) return null;
+	try {
+		let e = JSON.parse(await a.readFile(n(d, "package.json"), "utf8")), t = b(e.exports?.[u]) ?? (u === "." ? e.module ?? e.main : void 0);
+		if (typeof t == "string") return v(i(d, t));
+	} catch {}
+	return null;
+}, S = (e, t) => e.startsWith(t) ? e.slice(t.length).replace(/^[/\\]/, "") : e, C = async (e, t) => {
+	let n = /* @__PURE__ */ new Set(), r = [{
+		file: e,
+		chain: [S(e, t)]
+	}];
+	for (; r.length > 0;) {
+		let { file: e, chain: i } = r.shift();
+		if (n.has(e)) continue;
+		n.add(e);
+		let o;
+		try {
+			o = await a.readFile(e, "utf8");
+		} catch {
+			continue;
+		}
+		for (let a of g(o)) {
+			if (m(a)) return {
+				specifier: a,
+				chain: [...i, a]
+			};
+			let o = await x(a, e);
+			o && !n.has(o) && r.push({
+				file: o,
+				chain: [...i, `${a}  (${S(o, t)})`]
+			});
+		}
+	}
+	return null;
+}, w = /\.client\.tsx?$/, T = async (e, t) => {
+	let n = [];
+	for (let r of t) {
+		if (!w.test(r)) continue;
+		let t = await C(r, e);
+		t !== null && n.push({
+			file: S(r, e),
+			violation: t
+		});
+	}
+	return n;
+}, E = (e) => `browser-safety violation — ${e.file} declares itself browser-safe (.client.ts) and is not.\n\n  '${e.violation.specifier}' is server-only (node:* / database / ai / cluster / protocol session / db driver).\n\n  import chain:\n      → ${e.violation.chain.join("\n      → ")}\n\n  The .client suffix is a claim the framework checks, not a hint. Either move the server-only\n  code behind a *.server.ts and keep this file pure, or drop the suffix — an unmarked file\n  makes no claim, and only the rpcGroup guard will judge it (later, and with a longer chain).`, D = async (e) => {
+	if (process.env.VOLTRO_BROWSER_SAFETY === "off") return;
+	let n = await C(e, t(e));
+	if (!n) return;
+	let r = n.chain.join("\n      → ");
+	throw Error(`browser-safety violation — the generated rpcGroup pulls a SERVER-ONLY module into the client bundle.\n\n  '${n.specifier}' is server-only (node:* / database / ai / cluster / protocol session / db driver),\n  and the web client loads rpcGroup VALUE-LEVEL — this crashes the browser with\n  "Module …node:crypto… has been externalized for browser compatibility", or bloats the\n  bundle with the whole server graph.\n\n  import chain:\n      → ${r}\n\n  Fix: keep the descriptor (*.query/.mutation/.action.ts), the workflow descriptor\n  (*.workflow.tsx, import from @voltro/workflow/define), AND any plugin error schema\n  browser-safe. Move DB-backed / node: code behind a *.server.ts file or a browser-safe\n  subpath (e.g. a plugin's '/errors' export). Escape hatch (not recommended):\n  VOLTRO_BROWSER_SAFETY=off.`);
+}, O = /\.(query|mutation|action|stream)\.ts$/, k = /\.(query|mutation|action|stream)\.server\.ts$/, A = /\.workflow\.tsx$/, j = /(?<!\.server)\.agent\.tsx?$/, M = /\.connection\.tsx?$/, N = /* @__PURE__ */ new Set([
+	"node_modules",
+	"dist",
+	"build",
+	".turbo",
+	".vite",
+	".next",
+	".git"
+]), P = async (e) => {
+	let t = async (e) => {
+		let r = await a.readdir(e, { withFileTypes: !0 }).catch(() => []);
+		for (let i of r) if (!N.has(i.name)) {
+			if (i.isDirectory()) {
+				if (await t(n(e, i.name))) return !0;
+			} else if (i.isFile() && M.test(i.name)) return !0;
+		}
+		return !1;
+	};
+	return t(e);
+}, F = async (t) => {
+	let r = [], i = async (t) => {
+		let o = await a.readdir(t, { withFileTypes: !0 });
+		for (let a of o) {
+			if (N.has(a.name)) continue;
+			let o = n(t, a.name);
+			a.isDirectory() ? await i(o) : a.isFile() && (O.test(a.name) && !k.test(a.name) || A.test(a.name) || j.test(a.name) || e.test(a.name)) && r.push(o);
+		}
+	};
+	return await i(t), r;
+}, I = (e) => typeof e == "object" && !!e && "kind" in e && "name" in e && (e.kind === "query" || e.kind === "mutation" || e.kind === "action" || e.kind === "stream"), L = Symbol.for("@effect/workflow/Workflow"), R = (e) => typeof e == "object" && !!e && L in e && "name" in e && typeof e.name == "string", z = async (e) => Promise.all(e.map((e) => import(s(e).href))), B = async (e) => {
+	let t = [], n = await z(e);
+	for (let [r, i] of e.entries()) {
+		let e = n[r], a = /* @__PURE__ */ new Set();
+		for (let [n, r] of Object.entries(e)) {
+			if (typeof r == "object" && r) {
+				if (a.has(r)) continue;
+				a.add(r);
+			}
+			if (I(r)) {
+				if (!l(r)) continue;
+				t.push({
+					file: i,
+					exportName: n,
+					rpcTag: r.name,
+					kind: r.kind,
+					...r.requiresApproval == null ? {} : { requiresApproval: !0 }
+				});
+			} else c(r) ? t.push({
+				file: i,
+				exportName: n,
+				rpcTag: r.name,
+				kind: "event"
+			}) : R(r) && t.push({
+				file: i,
+				exportName: n,
+				rpcTag: r.name,
+				kind: "workflow"
+			});
+		}
+	}
+	return t;
+}, V = async (e) => {
+	let t = [], n = e.filter((e) => j.test(e)), r = await z(n);
+	for (let [e, i] of n.entries()) for (let [n, a] of Object.entries(r[e])) f(a) && t.push({
+		file: i,
+		exportName: n,
+		name: a.name
+	});
+	return t;
+}, H = (e) => {
+	let t = (e, t) => e.split(/[^a-zA-Z0-9]+/).filter(Boolean).map((e, n) => (n === 0 && !t ? e.charAt(0).toLowerCase() : e.charAt(0).toUpperCase()) + e.slice(1)).join(""), n = e.split(".");
+	return `${t(n[0] ?? "rpc", !1)}${n.slice(1).map((e) => t(e, !0)).join("")}Rpc`;
+}, U = /^[A-Za-z][A-Za-z0-9]*([._-][A-Za-z0-9]+)*$/, W = (e, t) => {
+	let n = (e) => r(t, e.file).replace(/\\/g, "/"), i = e.filter((e) => !U.test(e.rpcTag));
+	if (i.length > 0) throw Error(`invalid rpc tag — a procedure/workflow \`name\` must start with a letter and
+use only letters, digits, and \`.\` \`-\` \`_\` separators (the tag becomes a JS
+identifier in the generated rpcGroup):
+
+${i.map((e) => `  • "${e.rpcTag}"  (${n(e)})`).join("\n")}\n`);
+	let a = /* @__PURE__ */ new Map();
+	for (let t of e) {
+		let e = H(t.rpcTag), n = a.get(e);
+		n ? n.push(t) : a.set(e, [t]);
+	}
+	let o = [...a.values()].filter((e) => new Set(e.map((e) => e.rpcTag)).size > 1);
+	if (o.length > 0) throw Error(`rpc tag identifier collision — these distinct tags collapse to the same
+generated identifier (separators are normalized away). Rename one so they
+differ by more than a \`.\`/\`-\`/\`_\`:
+
+${o.map((e) => `  ${H(e[0].rpcTag)}:\n` + e.map((e) => `    - "${e.rpcTag}"  (${n(e)})`).join("\n")).join("\n\n")}\n`);
+}, G = (e) => {
+	switch (e) {
+		case "query": return 0;
+		case "mutation": return 1;
+		case "action": return 2;
+		case "stream": return 3;
+		case "event": return 4;
+		case "workflow": return 5;
+	}
+}, K = (e, t) => {
+	let n = /* @__PURE__ */ new Map();
+	for (let t of e) n.has(t.rpcTag) || n.set(t.rpcTag, t);
+	let i = [...n.keys()], a = (e) => r(t, n.get(e).file).replace(/\\/g, "/"), o = [];
+	for (let e of i) {
+		let t = i.filter((t) => t.startsWith(`${e}.`)).sort();
+		if (t.length === 0) continue;
+		let n = t.map((e) => `      - ${e}  (${a(e)})`).join("\n");
+		o.push(`  • "${e}"  (${a(e)})\n    is a procedure AND the namespace prefix of:\n${n}`);
+	}
+	if (o.length !== 0) throw Error(`rpc tag namespace collision — the web client nests tags by ".", so a tag
+can't be both a leaf and a namespace. Rename one side (e.g. give the
+workflow/procedure a nested name like "<prefix>.run"):
+
+${o.join("\n\n")}\n`);
+}, q = "// source-fingerprint: ", J = async (e) => {
+	let t = [...await F(e)].sort(), n = d("sha1");
+	for (let i of t) {
+		let t = "";
+		try {
+			t = o(i, "utf8");
+		} catch {}
+		n.update(`${r(e, i).replace(/\\/g, "/")}\u0000${t}\u0000`);
+	}
+	return n.digest("hex").slice(0, 16);
+}, Y = async (e) => {
+	let t = async (e) => {
+		let r = await a.readdir(e, { withFileTypes: !0 }).catch(() => []);
+		for (let t of r) if (!N.has(t.name) && t.isFile() && t.name === "rpcGroup.generated.ts") return n(e, t.name);
+		for (let i of r) {
+			if (N.has(i.name) || !i.isDirectory()) continue;
+			let r = await t(n(e, i.name));
+			if (r !== void 0) return r;
+		}
+	};
+	return t(i(e));
+}, X = async (e) => {
+	let n = await Y(e);
+	if (n === void 0) return { kind: "absent" };
+	let r = "";
+	try {
+		r = await a.readFile(n, "utf8");
+	} catch {
+		return { kind: "absent" };
+	}
+	let i = /^\/\/ source-fingerprint: ([0-9a-f]+)$/m.exec(r)?.[1];
+	return i === void 0 ? {
+		kind: "stale",
+		file: n,
+		reason: "the generated group carries no freshness stamp"
+	} : await J(t(n)) === i ? {
+		kind: "fresh",
+		file: n
+	} : {
+		kind: "stale",
+		file: n,
+		reason: "a descriptor changed since the group was generated"
+	};
+}, Z = (e, n, i, a = [], s = [], c = !1, l = !1, u = [], f = "") => {
+	let p = s.length > 0, m = s.flatMap((e) => [{
+		file: e.file,
+		exportName: e.exportName,
+		rpcTag: `${e.name}.send`,
+		kind: "action"
+	}, {
+		file: e.file,
+		exportName: e.exportName,
+		rpcTag: `${e.name}.messages`,
+		kind: "query"
+	}]), h = [...new Map(u.map((e) => [e.tag, e])).values()].sort((e, t) => e.tag < t.tag ? -1 : 1), g = h.map((e) => ({
+		file: `plugin:${e.module}`,
+		exportName: e.name,
+		rpcTag: e.tag,
+		kind: e.kind
+	}));
+	K([
+		...i,
+		...m,
+		...g
+	], e), W([
+		...i,
+		...m,
+		...g
+	], e);
+	let _ = (e) => e.replace(/[^a-zA-Z0-9_$]/g, "_"), v = (e) => `__src_agent_${_(e.name)}`, y = (e) => `__agentRoutes_${_(e.name)}`, b = a.length > 0, x = a.map((e, t) => `import { ${e.name} as __pe${t} } from '${e.module}'`), S = b ? ", __voltroPluginErrors" : "", C = h.length > 0, w = h.map((e, t) => `import { ${e.name} as __prpc${t} } from '${e.module}'`), T = (e) => e === "query" ? "queryToRpc" : e === "mutation" ? "mutationToRpc" : "actionToRpc", E = h.map((e, t) => `export const ${H(e.tag)} = ${T(e.kind)}(__prpc${t}${S})`), D = h.map((e) => `  ${H(e.tag)},`), O = [...i].sort((e, t) => e.kind === t.kind ? e.rpcTag < t.rpcTag ? -1 : 1 : G(e.kind) - G(t.kind)), k = t(n), A = (e) => `__src_${H(e.rpcTag)}`, j = (e) => {
+		let t = `./${r(k, e.file).replace(/\\/g, "/").replace(/\.tsx?$/, "")}`;
+		return `import { ${e.exportName} as ${A(e)} } from '${t}'`;
+	}, M = (e) => {
+		let t = H(e.rpcTag), n = A(e);
+		return e.kind === "query" ? `export const ${t} = queryToRpc(${n}${S})` : e.kind === "mutation" ? `export const ${t} = mutationToRpc(${n}${S})` : e.kind === "action" ? `export const ${t} = actionToRpc(${n}${S})` : e.kind === "stream" ? `export const ${t} = streamToRpc(${n}${S})` : e.kind === "event" ? `export const ${t} = eventToRpc(${n}${S})` : [
+			`export const ${t} = Rpc.make('${e.rpcTag}', {`,
+			`  payload: ${n}.payloadSchema,`,
+			"  success: WorkflowRunHandleSchema,",
+			`  error:   ${n}.errorSchema,`,
+			"})"
+		].join("\n");
+	}, N = [...O.filter((e) => e.kind === "query" || e.kind === "mutation" || e.kind === "action" || e.kind === "stream").map((e) => `  | __AppErrorOf<typeof ${A(e)}>`), ...b ? ["  | Schema.Schema.Type<(typeof __voltroPluginErrors)[number]>"] : []], P = N.length > 0, F = O.some((e) => e.kind === "workflow"), I = F ? [
+		"__voltroWorkflowRun",
+		"__voltroWorkflowRuns",
+		"__voltroWorkflowRunSteps",
+		"__voltroWorkflowRunEvents",
+		"__voltroWorkflowDomainEvents",
+		"__voltroWorkflowEventDeliveries",
+		"__voltroWorkflowCancel",
+		"__voltroWorkflowResume",
+		"__voltroWorkflowSignal",
+		"__voltroWorkflowUpdate"
+	] : [], L = c ? [
+		"__voltroUndoLog",
+		"__voltroUndoApply",
+		"__voltroUndoRedo"
+	] : [], R = O.some((e) => e.requiresApproval === !0), z = R ? ["__voltroApprovalsPending", "__voltroApprovalsDecide"] : [], B = l ? [
+		"__voltroConnectionsList",
+		"__voltroConnectionStart",
+		"__voltroConnectionSubmitToken",
+		"__voltroConnectionDisconnect"
+	] : [], V = [
+		...O.map((e) => `  ${H(e.rpcTag)},`),
+		...s.flatMap((e) => [`  ${H(`${e.name}.send`)},`, `  ${H(`${e.name}.messages`)},`]),
+		...I.map((e) => `  ${e},`),
+		...L.map((e) => `  ${e},`),
+		...z.map((e) => `  ${e},`),
+		...B.map((e) => `  ${e},`),
+		...D
+	].join("\n"), U = ["queryToRpc"];
+	(O.some((e) => e.kind === "mutation") || h.some((e) => e.kind === "mutation")) && U.push("mutationToRpc"), (O.some((e) => e.kind === "action") || F || p || h.some((e) => e.kind === "action")) && U.push("actionToRpc"), O.some((e) => e.kind === "stream") && U.push("streamToRpc"), O.some((e) => e.kind === "event") && U.push("eventToRpc"), F && U.push("WorkflowRunHandleSchema", "workflowCancelDescriptor", "workflowDomainEventsQueryDescriptor", "workflowEventDeliveriesQueryDescriptor", "workflowResumeDescriptor", "workflowRunEventsQueryDescriptor", "workflowRunQueryDescriptor", "workflowRunsQueryDescriptor", "workflowRunStepsQueryDescriptor", "workflowSignalDescriptor", "workflowUpdateDescriptor"), c && U.push("mutationToRpc", "undoLogQueryDescriptor", "undoApplyDescriptor", "undoRedoDescriptor"), R && U.push("mutationToRpc", "approvalsPendingQueryDescriptor", "approvalsDecideDescriptor"), l && U.push("mutationToRpc", "actionToRpc", "connectionsListQueryDescriptor", "connectionStartDescriptor", "connectionSubmitTokenDescriptor", "connectionDisconnectDescriptor"), (O.some((e) => e.kind === "query" || e.kind === "mutation" || e.kind === "action" || e.kind === "stream") || p || F || c || R || l || C) && U.push("normalizeDescriptor");
+	let J = [...new Set(U)].sort(), Y = [...O.filter((e) => e.kind === "query" || e.kind === "mutation" || e.kind === "action" || e.kind === "stream").map((e) => [e.rpcTag, A(e)]), ...s.flatMap((e) => [[`${e.name}.send`, `${y(e)}.send`], [`${e.name}.messages`, `${y(e)}.messages`]])], X = [
+		...F ? [
+			["__voltro.workflow.run", "workflowRunQueryDescriptor"],
+			["__voltro.workflow.runs", "workflowRunsQueryDescriptor"],
+			["__voltro.workflow.run.steps", "workflowRunStepsQueryDescriptor"],
+			["__voltro.workflow.run.events", "workflowRunEventsQueryDescriptor"],
+			["__voltro.workflow.domainEvents", "workflowDomainEventsQueryDescriptor"],
+			["__voltro.workflow.event.deliveries", "workflowEventDeliveriesQueryDescriptor"],
+			["__voltro.workflow.cancel", "workflowCancelDescriptor"],
+			["__voltro.workflow.resume", "workflowResumeDescriptor"],
+			["__voltro.workflow.signal", "workflowSignalDescriptor"],
+			["__voltro.workflow.update", "workflowUpdateDescriptor"]
+		] : [],
+		...c ? [
+			["__voltro.undo.log", "undoLogQueryDescriptor"],
+			["__voltro.undo.apply", "undoApplyDescriptor"],
+			["__voltro.undo.redo", "undoRedoDescriptor"]
+		] : [],
+		...R ? [["__voltro.approvals.pending", "approvalsPendingQueryDescriptor"], ["__voltro.approvals.decide", "approvalsDecideDescriptor"]] : [],
+		...l ? [
+			["__voltro.connections.list", "connectionsListQueryDescriptor"],
+			["__voltro.connections.start", "connectionStartDescriptor"],
+			["__voltro.connections.submitToken", "connectionSubmitTokenDescriptor"],
+			["__voltro.connections.disconnect", "connectionDisconnectDescriptor"]
+		] : [],
+		...h.map((e, t) => [e.tag, `__prpc${t}`])
+	], Z = ([e, t]) => `  ${JSON.stringify(e)}: normalizeDescriptor(${t}),`, Q = ([e, t]) => `  readonly ${JSON.stringify(e)}: typeof ${t}`, $ = Y.map(Z), ee = X.map(Z), te = O.filter((e) => e.kind === "workflow").map((e) => `  ${JSON.stringify(e.rpcTag)}: { kind: 'workflow' },`), ne = O.filter((e) => e.kind === "workflow").map((e) => `  readonly ${JSON.stringify(e.rpcTag)}: { readonly kind: 'workflow' }`), re = [
+		...Y.map(Q),
+		...ne,
+		...X.map(Q)
+	], ie = O.filter((e) => e.kind === "workflow").map((e) => {
+		let t = A(e);
+		return [
+			`  ${JSON.stringify(e.rpcTag)}: {`,
+			"    kind: 'workflow',",
+			`    payload: ${t}.payloadSchema,`,
+			`    success: ${t}.successSchema,`,
+			`    error: ${t}.errorSchema,`,
+			`    signals: __voltroWorkflowMessages(${t}).signals,`,
+			`    updates: __voltroWorkflowMessages(${t}).updates,`,
+			"  },"
+		].join("\n");
+	}), ae = [...O, ...s.map((e) => ({
+		rpcTag: `agent:${e.name}`,
+		file: e.file
+	}))];
+	return [
+		"// THIS FILE IS GENERATED — DO NOT EDIT BY HAND.",
+		"// Re-emitted by `voltro dev` whenever query/mutation/action/stream/workflow files change.",
+		`// descriptor-fingerprint: ${d("sha1").update(ae.map((e) => {
+			let t = "";
+			try {
+				t = o(e.file, "utf8");
+			} catch {}
+			return `${e.rpcTag}\u0000${t}`;
+		}).join("
")).digest("hex").slice(0, 16)}`,
+		`${q}${f}`,
+		"// Source files:",
+		...O.map((t) => `//   - ${r(e, t.file).replace(/\\/g, "/")}`),
+		...s.map((t) => `//   - ${r(e, t.file).replace(/\\/g, "/")}  (agent)`),
+		"",
+		F ? "import { Rpc, RpcGroup } from '@effect/rpc'" : "import { RpcGroup } from '@effect/rpc'",
+		...F || P ? ["import { Schema } from 'effect'"] : [],
+		`import { ${J.join(", ")} } from '@voltro/protocol'`,
+		...p ? ["import { agentRouteDescriptors as __voltroAgentRoutes } from '@voltro/ai/agent'"] : [],
+		"",
+		...O.map(j),
+		...s.map((e) => `import { ${e.exportName} as ${v(e)} } from './${r(k, e.file).replace(/\\/g, "/").replace(/\.tsx?$/, "")}'`),
+		...b ? ["", ...x] : [],
+		...C ? ["", ...w] : [],
+		"",
+		...s.map((e) => `const ${y(e)} = __voltroAgentRoutes(${v(e)})`),
+		...p ? [""] : [],
+		...b ? [
+			"/** Cross-cutting plugin error schemas, unioned into every rpc's",
+			" *  wire error so interceptor failures decode typed on the client. */",
+			`const __voltroPluginErrors = [${a.map((e, t) => `__pe${t}`).join(", ")}] as const`,
+			""
+		] : [],
+		...F ? [
+			"const __voltroEmptyWorkflowMessages = { signals: {}, updates: {} } as const",
+			"const __voltroWorkflowMessages = <const M extends {",
+			"  readonly signals: Readonly<Record<string, Schema.Schema.Any>>",
+			"  readonly updates: Readonly<Record<string, { readonly payload: Schema.Schema.Any; readonly success: Schema.Schema.Any }>>",
+			"}>(definition: object & { readonly __voltroWorkflowMessages?: M }) =>",
+			"  definition.__voltroWorkflowMessages ?? __voltroEmptyWorkflowMessages",
+			"",
+			"export const workflowDescriptors = {",
+			...ie,
+			"} as const",
+			"",
+			"export type WorkflowDescriptors = typeof workflowDescriptors",
+			"export type WorkflowName = keyof WorkflowDescriptors",
+			"export type WorkflowPayloads = { [K in WorkflowName]: WorkflowDescriptors[K] extends { readonly payload: infer Payload extends Schema.Schema.Any } ? Schema.Schema.Type<Payload> : never }",
+			"export type WorkflowResults = { [K in WorkflowName]: WorkflowDescriptors[K] extends { readonly success: infer Success extends Schema.Schema.Any } ? Schema.Schema.Type<Success> : never }",
+			"export type WorkflowErrors = { [K in WorkflowName]: WorkflowDescriptors[K] extends { readonly error: infer ErrorSchema extends Schema.Schema.Any } ? Schema.Schema.Type<ErrorSchema> : never }",
+			"export type WorkflowSignals = { [K in WorkflowName]: WorkflowDescriptors[K] extends { readonly signals: infer Signals extends Readonly<Record<string, Schema.Schema.Any>> } ? { [S in keyof Signals]: Schema.Schema.Type<Signals[S]> } : {} }",
+			"export type WorkflowUpdates = { [K in WorkflowName]: WorkflowDescriptors[K] extends { readonly updates: infer Updates extends Readonly<Record<string, { readonly payload: Schema.Schema.Any; readonly success: Schema.Schema.Any }>> } ? { [U in keyof Updates]: {",
+			"  readonly payload: Schema.Schema.Type<Updates[U]['payload']>",
+			"  readonly result: Schema.Schema.Type<Updates[U]['success']>",
+			"} } : {} }",
+			"export type WorkflowMessages = { [K in WorkflowName]: {",
+			"  readonly signals: WorkflowSignals[K]",
+			"  readonly updates: WorkflowUpdates[K]",
+			"} }",
+			""
+		] : [],
+		...O.map(M),
+		...s.flatMap((e) => [`export const ${H(`${e.name}.send`)} = actionToRpc(${y(e)}.send${S})`, `export const ${H(`${e.name}.messages`)} = queryToRpc(${y(e)}.messages${S})`]),
+		...F ? [
+			"export const __voltroWorkflowRun = queryToRpc(workflowRunQueryDescriptor)",
+			"export const __voltroWorkflowRuns = queryToRpc(workflowRunsQueryDescriptor)",
+			"export const __voltroWorkflowRunSteps = queryToRpc(workflowRunStepsQueryDescriptor)",
+			"export const __voltroWorkflowRunEvents = queryToRpc(workflowRunEventsQueryDescriptor)",
+			"export const __voltroWorkflowDomainEvents = queryToRpc(workflowDomainEventsQueryDescriptor)",
+			"export const __voltroWorkflowEventDeliveries = queryToRpc(workflowEventDeliveriesQueryDescriptor)",
+			"export const __voltroWorkflowCancel = actionToRpc(workflowCancelDescriptor)",
+			"export const __voltroWorkflowResume = actionToRpc(workflowResumeDescriptor)",
+			"export const __voltroWorkflowSignal = actionToRpc(workflowSignalDescriptor)",
+			"export const __voltroWorkflowUpdate = actionToRpc(workflowUpdateDescriptor)"
+		] : [],
+		...c ? [
+			"export const __voltroUndoLog = queryToRpc(undoLogQueryDescriptor)",
+			"export const __voltroUndoApply = mutationToRpc(undoApplyDescriptor)",
+			"export const __voltroUndoRedo = mutationToRpc(undoRedoDescriptor)"
+		] : [],
+		...R ? ["export const __voltroApprovalsPending = queryToRpc(approvalsPendingQueryDescriptor)", "export const __voltroApprovalsDecide = mutationToRpc(approvalsDecideDescriptor)"] : [],
+		...l ? [
+			"export const __voltroConnectionsList = queryToRpc(connectionsListQueryDescriptor)",
+			"export const __voltroConnectionStart = actionToRpc(connectionStartDescriptor)",
+			"export const __voltroConnectionSubmitToken = mutationToRpc(connectionSubmitTokenDescriptor)",
+			"export const __voltroConnectionDisconnect = mutationToRpc(connectionDisconnectDescriptor)"
+		] : [],
+		...E,
+		"",
+		"export const appGroup = RpcGroup.make(",
+		V,
+		")",
+		"",
+		"/** Per-rpc-tag metadata for the client. Drives auto-optimistic etc.",
+		" *  Function fields (target.shape, target.identify) survive because",
+		" *  the descriptors themselves are imported by reference. */",
+		"export const appDescriptors = {",
+		...$,
+		...te,
+		...ee,
+		"} as const",
+		"",
+		"export type AppDescriptors = typeof appDescriptors",
+		"",
+		"/** Type-level map: rpc tag → the DESCRIPTOR TYPE behind it — the input and",
+		" *  output `Schema`s this app's procedures actually declare.",
+		" *",
+		" *  Feed it to `createHooks` from @voltro/client to get hooks whose tag is a",
+		" *  literal union and whose input/output types are INFERRED, so a call site",
+		" *  never spells either by hand:",
+		" *",
+		" *      // src/lib/api.ts",
+		" *      import { createHooks } from '@voltro/client'",
+		" *      import type { AppProcedures } from '<this-api-package>/rpcGroup'",
+		" *",
+		" *      export const { useSubscription, useMutation, useAction } =",
+		" *        createHooks<AppProcedures>('app')   // the key from app.config.ts `apis`",
+		" *",
+		" *  A type ALIAS, not an interface, on purpose: an interface has no implicit",
+		" *  index signature, so it would not satisfy `createHooks`' constraint.",
+		" *  Types only — erased at build time, so importing it costs the bundle",
+		" *  nothing. */",
+		"export type AppProcedures = {",
+		...re,
+		"}",
+		"",
+		...P ? [
+			"type __AppErrorOf<D> = D extends { readonly error: infer E extends Schema.Schema.Any } ? Schema.Schema.Type<E> : never",
+			"/** Union of every typed error the app's rpcs can fail with — the declared",
+			" *  `error:` schemas + cross-cutting plugin errors. Generated by reference,",
+			" *  so it can never drift out of date. (Workflows: see `WorkflowErrors`.) */",
+			"export type AppError =",
+			...N,
+			"/** The `_tag` literal of every AppError — the exhaustive key set for `matchError`. */",
+			"export type AppErrorTag = AppError extends { readonly _tag: infer T extends string } ? T : never",
+			"",
+			"/** Exhaustively match a caught rpc error by its `_tag`. Handler keys are the",
+			" *  app's ACTUAL error tags (a dead/renamed tag is a compile error), so the",
+			" *  hand-maintained tag list that drifts is gone. Returns the matched handler's",
+			" *  result, or `fallback(err)` / `undefined` when no tag matches. Browser-safe",
+			" *  (reads `_tag` structurally — no runtime dependency). */",
+			"export const matchError = <R>(",
+			"  err: unknown,",
+			"  handlers: Partial<{ [T in AppErrorTag]: (e: Extract<AppError, { readonly _tag: T }>) => R }>,",
+			"  fallback?: (err: unknown) => R,",
+			"): R | undefined => {",
+			"  const tag = (err as { readonly _tag?: unknown } | null | undefined)?._tag",
+			"  if (typeof tag === 'string') {",
+			"    const handler = (handlers as Record<string, ((e: never) => R) | undefined>)[tag]",
+			"    if (handler) return handler(err as never)",
+			"  }",
+			"  return fallback ? fallback(err) : undefined",
+			"}",
+			""
+		] : []
+	].join("\n");
+}, Q = async (e) => {
+	let r = i(e.root), o = await F(r), s = await B(o), c = await V(o), l = await P(r);
+	if (s.length === 0 && c.length === 0 && !l && (e.pluginRpcImports?.length ?? 0) === 0) return;
+	let d = ((e) => {
+		if (e.length === 0) return r;
+		let t = e.map((e) => e.split("/")), n = Math.min(...t.map((e) => e.length)), i = [];
+		for (let e = 0; e < n; e++) {
+			let n = t[0][e];
+			if (t.every((t) => t[e] === n)) i.push(n);
+			else break;
+		}
+		return i.join("/") || "/";
+	})([...new Set([...s.map((e) => e.file), ...c.map((e) => e.file)].map((e) => e.replace(/\/[^/]+$/, "")))]), f = /* @__PURE__ */ new Set([
+		"queries",
+		"mutations",
+		"actions",
+		"streams",
+		"workflows"
+	]), p = (e) => e.slice(e.lastIndexOf("/") + 1), m = d;
+	for (; m !== r && f.has(p(m));) m = m.slice(0, m.lastIndexOf("/")) || "/";
+	let h = i(e.outputFile ?? n(m, "rpcGroup.generated.ts")), g = [...new Map((e.pluginErrorImports ?? []).map((e) => [`${e.module}#${e.name}`, e])).values()], _ = [...new Map((e.pluginRpcImports ?? []).map((e) => [e.tag, e])).values()], v = await J(t(h)), y = Z(r, h, s, g, c, u(), l, _, v), b = [];
+	for (let t of e.pluginContributions ?? []) {
+		let e = null;
+		try {
+			e = t.emit();
+		} catch (n) {
+			e = `// <plugin:${t.pluginName}> ERROR: ${n?.message ?? String(n)}\n// </plugin:${t.pluginName}>`;
+		}
+		e === null || e === "" || b.push([
+			`// <plugin:${t.pluginName}>`,
+			e,
+			`// </plugin:${t.pluginName}>`,
+			""
+		].join("\n"));
+	}
+	let x = b.length === 0 ? y : `${y}\n\n// ---- plugin codegen ----\n\n${b.join("\n")}`, S = null;
+	try {
+		S = await a.readFile(h, "utf8");
+	} catch {}
+	return S !== x && await a.writeFile(h, x, "utf8"), await D(h), h;
+};
+//#endregion
+export { D as a, T as c, w as i, J as n, E as o, Q as r, C as s, X as t };

package/dist/codegen-ChBi_hVa.js

@@ -0,0 +1,2 @@
+import { t as e } from "./codegen-CYM3Zqrf.js";
+export { e as checkRpcGroupFreshness };

package/dist/codegenCommand-C4YoQIc2.js

@@ -0,0 +1,30 @@
+import { l as e, z as t } from "./dev-C7sFZq3m.js";
+import { r as n } from "./codegen-CYM3Zqrf.js";
+import { basename as r, relative as i, resolve as a } from "node:path";
+//#region src/codegenCommand.ts
+var o = async (i) => {
+	let { config: a, present: o, error: s } = await e(i);
+	if (o && a === null) return {
+		kind: "refused",
+		reason: "app.config.ts exists but could not be loaded" + (s === void 0 ? "" : ` — ${s instanceof Error ? s.message : String(s)}`)
+	};
+	let c = a?.plugins ?? [], { pluginContributions: l, pluginErrorImports: u, pluginRpcImports: d } = await t(c, a?.name ?? r(i), i), f = await n({
+		root: i,
+		...l.length > 0 ? { pluginContributions: l } : {},
+		...u.length > 0 ? { pluginErrorImports: u } : {},
+		...d.length > 0 ? { pluginRpcImports: d } : {},
+		...a?.name === void 0 ? {} : { apiName: a.name }
+	});
+	return f ? {
+		kind: "wrote",
+		file: f,
+		plugins: c.length,
+		errorSchemas: u.length,
+		routes: d.length
+	} : { kind: "nothing-to-write" };
+}, s = async (e) => {
+	let t = a(e.find((e) => !e.startsWith("-")) ?? process.cwd()), n = await o(t);
+	return n.kind === "refused" ? (console.error(`voltro codegen: ${n.reason} — refusing to write.`), console.error("  The generated file would omit every plugin's error union and client routes, and would typecheck, so the omission would only surface as a missing error tag at runtime."), 1) : n.kind === "nothing-to-write" ? (console.log("voltro codegen: no rpc primitives found — nothing to write."), 0) : (console.log(`voltro codegen: wrote ${i(t, n.file)} (plugins ${n.plugins}, error schemas ${n.errorSchemas}, plugin routes ${n.routes})`), n.plugins > 0 && n.errorSchemas === 0 && console.log("  note: no plugin contributed a cross-cutting error schema, so the wire error union carries only each procedure's own `error:`. Expected if none of your plugins declare `errorSchemas` — but `guards:` needs @voltro/plugin-rbac for its ScopeError to decode typed."), 0);
+};
+//#endregion
+export { o as regenerateRpcGroup, s as runCodegenCommand };