@voltro/cli 0.33.0 → 0.34.0

package/dist/updateCommand-Bkptutss.js

@@ -0,0 +1,585 @@
+import { n as e, r as t, t as n } from "./codemodRunner-DRRqXR74.js";
+import { basename as r, dirname as i, join as a, relative as o, resolve as s } from "node:path";
+import { existsSync as c, readFileSync as l, readdirSync as u, statSync as d, writeFileSync as f } from "node:fs";
+import { totalmem as p } from "node:os";
+import { execFileSync as m, spawnSync as h } from "node:child_process";
+//#region src/peerAlignment.ts
+var g = (e) => {
+	let t = /^\s*(?:\^|~|>=|=|v)?\s*(\d+)\.(\d+)\.(\d+)/.exec(e);
+	if (t && !/\|\||\s<|\s-\s/.test(e)) return [
+		Number(t[1]),
+		Number(t[2]),
+		Number(t[3])
+	];
+}, _ = (e, t) => e[0] === t[0] ? e[1] === t[1] ? e[2] < t[2] : e[1] < t[1] : e[0] < t[0], v = (e) => e.flatMap(({ name: e, peerDependencies: t }) => Object.entries(t ?? {}).filter(([e]) => !e.startsWith("@voltro/")).map(([t, n]) => ({
+	peer: t,
+	range: n,
+	requiredBy: e
+}))), y = (e, t) => {
+	let n = /* @__PURE__ */ new Map();
+	for (let e of t) {
+		let t = n.get(e.peer);
+		t ? t.push(e) : n.set(e.peer, [e]);
+	}
+	let r = [], i = /* @__PURE__ */ new Map();
+	for (let [e, t] of n) {
+		let n = t.map((e) => ({
+			r: e,
+			floor: g(e.range)
+		})).filter((e) => e.floor !== void 0);
+		if (n.length !== 0) {
+			if (new Set(n.map((e) => e.r.range)).size > 1) {
+				r.push({
+					peer: e,
+					requirements: t
+				});
+				continue;
+			}
+			i.set(e, n[0].r);
+		}
+	}
+	let a = [];
+	for (let { path: t, pkg: n } of e) for (let e of ["dependencies", "devDependencies"]) {
+		let r = n[e];
+		if (r) for (let [n, o] of i) {
+			let i = r[n];
+			if (i === void 0) continue;
+			let s = g(i), c = g(o.range);
+			!s || !c || _(s, c) && a.push({
+				path: t,
+				section: e,
+				peer: n,
+				from: i,
+				to: o.range
+			});
+		}
+	}
+	return {
+		alignments: a,
+		conflicts: r
+	};
+}, b = (e, t) => {
+	for (let n of t.alignments) {
+		let t = e.find((e) => e.path === n.path);
+		if (!t) continue;
+		let r = t.pkg[n.section];
+		r && n.peer in r && (r[n.peer] = n.to);
+	}
+}, x = (e, t, n) => {
+	let r = /* @__PURE__ */ new Set(), i = [];
+	for (let a of e) {
+		if (t.has(a.peer) || r.has(a.peer)) continue;
+		let e = n(a.peer);
+		if (e === void 0) continue;
+		let o = g(a.range), s = g(e);
+		!o || !s || !_(s, o) || (r.add(a.peer), i.push({
+			peer: a.peer,
+			required: a.range,
+			installed: e,
+			requiredBy: a.requiredBy
+		}));
+	}
+	return i;
+}, S = /^(workspace:|catalog:|link:|file:|npm:|portal:)/, C = /* @__PURE__ */ new Set([
+	"pnpm",
+	"npm",
+	"yarn",
+	"bun"
+]), w = [
+	["pnpm-lock.yaml", "pnpm"],
+	["yarn.lock", "yarn"],
+	["bun.lock", "bun"],
+	["bun.lockb", "bun"],
+	["package-lock.json", "npm"]
+], T = (e) => {
+	let t = [], n = s(e);
+	for (; t.push(n), !c(a(n, ".git"));) {
+		let e = i(n);
+		if (e === n) break;
+		n = e;
+	}
+	return t;
+}, E = (e) => {
+	for (let t of T(e)) {
+		let e = a(t, "package.json");
+		if (c(e)) try {
+			let t = JSON.parse(l(e, "utf8")).packageManager;
+			if (typeof t == "string") {
+				let e = t.split("@")[0]?.trim();
+				if (e && C.has(e)) return e;
+			}
+		} catch {}
+		for (let [e, n] of w) if (c(a(t, e))) return n;
+	}
+	return "npm";
+}, D = 4, O = (e) => {
+	for (let t of T(e)) {
+		if (c(a(t, "pnpm-workspace.yaml")) || c(a(t, "pnpm-workspace.yml"))) return t;
+		let e = a(t, "package.json");
+		if (c(e)) try {
+			let n = JSON.parse(l(e, "utf8")).workspaces;
+			if (Array.isArray(n) ? n.length > 0 : typeof n == "object" && n) return t;
+		} catch {}
+	}
+}, k = (e) => {
+	let n = [], r = (e, i) => {
+		let o = a(e, "package.json");
+		if (c(o) && n.push(o), i >= D) return;
+		let s;
+		try {
+			s = u(e);
+		} catch {
+			return;
+		}
+		for (let n of s) {
+			if (n.startsWith(".") || t.has(n)) continue;
+			let o = a(e, n);
+			try {
+				if (!d(o).isDirectory()) continue;
+			} catch {
+				continue;
+			}
+			r(o, i + 1);
+		}
+	};
+	return r(s(e), 0), n;
+}, A = (e) => {
+	try {
+		return m("git", ["status", "--porcelain"], {
+			cwd: e,
+			encoding: "utf8"
+		}).trim() === "";
+	} catch {
+		return !1;
+	}
+}, j = /^\d+\.\d+\.\d+/, M = (e, t) => {
+	try {
+		let n = m(e, [...t], {
+			encoding: "utf8",
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			]
+		}).trim();
+		if (!n) return;
+		if (n.startsWith("{")) {
+			let e = JSON.parse(n).version;
+			return typeof e == "string" && j.test(e) ? e : void 0;
+		}
+		let r = n.split("\n").map((e) => e.trim()).filter(Boolean).pop();
+		return r && j.test(r) ? r : void 0;
+	} catch {
+		return;
+	}
+}, N = () => {
+	try {
+		let e = m("yarn", ["--version"], {
+			encoding: "utf8",
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			]
+		}).trim();
+		return Number.parseInt(e.split(".")[0] ?? "", 10) || 1;
+	} catch {
+		return 1;
+	}
+}, P = (e, t, n) => [...t === "pnpm" ? [["pnpm", [
+	"view",
+	e,
+	"version"
+]]] : t === "yarn" ? n >= 2 ? [["yarn", [
+	"npm",
+	"info",
+	e,
+	"--fields",
+	"version",
+	"--json"
+]]] : [["yarn", [
+	"info",
+	e,
+	"version",
+	"--silent"
+]]] : t === "bun" ? [["bun", [
+	"pm",
+	"view",
+	e,
+	"version"
+]]] : [], ["npm", [
+	"view",
+	e,
+	"version"
+]]], F = (e, t, n) => {
+	let r = `${e}@${t}`;
+	return [...n === "pnpm" ? [["pnpm", [
+		"view",
+		r,
+		"voltro",
+		"--json"
+	]]] : [], ["npm", [
+		"view",
+		r,
+		"voltro",
+		"--json"
+	]]];
+}, I = (e) => {
+	try {
+		let t = JSON.parse(e)?.codemods;
+		if (!Array.isArray(t)) return;
+		let n = [];
+		for (let e of t) {
+			let t = e;
+			if (typeof t.version != "string" || typeof t.id != "string") return;
+			n.push({
+				version: t.version,
+				id: t.id,
+				title: typeof t.title == "string" ? t.title : t.id,
+				kind: t.kind === "transform" ? "transform" : "manual"
+			});
+		}
+		return n;
+	} catch {
+		return;
+	}
+}, L = (e, t = "npm", n = "@voltro/cli") => {
+	for (let [r, i] of F(n, e, t)) try {
+		let e = I(m(r, i, {
+			encoding: "utf8",
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			],
+			timeout: 2e4
+		}));
+		if (e !== void 0) return e;
+	} catch {}
+}, R = (e, t, r) => e.filter((e) => n(t, e.version) < 0 && n(e.version, r) <= 0), z = (e, t = "npm") => {
+	for (let [n, r] of P(e, t, t === "yarn" ? N() : 1)) {
+		let e = M(n, r);
+		if (e) return e;
+	}
+}, B = (e) => JSON.parse(l(e, "utf8")), V = [
+	"app.config.ts",
+	"app.config.tsx",
+	"app.config.js"
+], H = (e) => {
+	let t = s(e);
+	for (;;) {
+		let e = i(t);
+		if (e === t) return;
+		t = e;
+		let n = a(t, "package.json");
+		if (c(n)) try {
+			if (W(B(n)).length > 0) return t;
+		} catch {}
+	}
+}, U = (e) => {
+	let t = a(e, "node_modules", "@voltro", "cli", "package.json");
+	if (!c(t)) return;
+	let n = B(t).version;
+	return typeof n == "string" ? n : void 0;
+}, W = (e) => {
+	let t = [];
+	for (let n of ["dependencies", "devDependencies"]) {
+		let r = e[n];
+		if (r) for (let [e, i] of Object.entries(r)) e.startsWith("@voltro/") && t.push({
+			section: n,
+			name: e,
+			spec: i
+		});
+	}
+	return t;
+}, G = (e, t, n, i) => {
+	let s = a(e, "node_modules", "@voltro");
+	if (!c(s)) return 0;
+	let l = [];
+	for (let e of u(s)) {
+		let t = a(s, e, "package.json");
+		if (c(t)) try {
+			let n = B(t);
+			l.push({
+				name: n.name ?? `@voltro/${e}`,
+				peerDependencies: n.peerDependencies
+			});
+		} catch {}
+	}
+	let d = v(l), p = y(t, d), m = /* @__PURE__ */ new Set();
+	for (let { pkg: e } of t) for (let t of ["dependencies", "devDependencies"]) for (let n of Object.keys(e[t] ?? {})) m.add(n);
+	let h = x(d, m, (t) => {
+		let n = a(e, "node_modules", ...t.split("/"), "package.json");
+		if (c(n)) try {
+			return B(n).version;
+		} catch {
+			return;
+		}
+	});
+	if (h.length > 0) {
+		console.warn("\nvoltro update: these peer dependencies are UNSATISFIED and nothing here declares them:");
+		for (let e of h) console.warn(`  ${e.peer}  installed ${e.installed}, ${e.requiredBy} requires ${e.required}`);
+		console.warn("  They resolve transitively, so the install succeeds and the app boots on a graph"), console.warn("  the framework was not tested against. Effect types are NOMINAL — two copies"), console.warn("  produce red `tsc` on rpcGroup.generated.ts while the server runs green."), console.warn("  Fix: declare them where the @voltro/* packages are used, at the version above.");
+	}
+	for (let e of p.conflicts) {
+		console.warn(`\nvoltro update: framework packages disagree about \`${e.peer}\`:`);
+		for (let t of e.requirements) console.warn(`  ${t.requiredBy} wants ${t.range}`);
+		console.warn("  Left as declared — resolving this would be a guess about which is right.");
+	}
+	if (p.alignments.length === 0) return 0;
+	console.log("\nAligning peer dependencies the framework requires:");
+	for (let t of p.alignments) console.log(`  ${t.peer}  ${t.from} → ${t.to}   (${o(e, t.path) || r(t.path)})`);
+	b(t, p);
+	let g = new Set(p.alignments.map((e) => e.path));
+	for (let e of t) g.has(e.path) && f(e.path, JSON.stringify(e.pkg, null, 2) + "\n");
+	console.log(`\nRe-installing with ${n} so the aligned ranges resolve…`);
+	let _ = i(n, e);
+	return _ !== 0 && (console.error(`\nvoltro update: ${n} install failed after aligning peer dependencies.`), console.error("  The package.json changes above ARE written; re-run the install yourself.")), _;
+}, K = (e, t, n) => W(e).map(({ name: e, spec: r }) => S.test(r) ? {
+	name: e,
+	from: r,
+	to: r,
+	skipped: "non-registry spec"
+} : {
+	name: e,
+	from: r,
+	to: `${n ? "" : /^[\^~]/.exec(r)?.[0] ?? ""}${t}`
+}), ee = (e, t) => {
+	for (let n of t) if (!n.skipped) for (let t of ["dependencies", "devDependencies"]) {
+		let r = e[t];
+		r && n.name in r && (r[n.name] = n.to);
+	}
+}, q = (e, t, n) => e.map(({ path: e, pkg: r }) => ({
+	path: e,
+	entries: K(r, t, n)
+})).filter((e) => e.entries.length > 0), J = (e, t) => {
+	let n = new Map(e.map((e) => [e.path, e])), r = [];
+	for (let e of t) {
+		let t = n.get(e.path);
+		t && (ee(t.pkg, e.entries), r.push(t));
+	}
+	return r;
+}, te = /* @__PURE__ */ new Set([
+	"--to",
+	"--from",
+	"--root",
+	"--only"
+]), ne = /* @__PURE__ */ new Set([
+	"--dry-run",
+	"--force",
+	"--exact",
+	"--codemods-only",
+	"--run-codemods",
+	"--no-install",
+	"--help",
+	"-h"
+]), re = (e) => {
+	let t, n, r = process.cwd(), i = [], a = [], o = [], c = (e) => {
+		for (let t of e.split(",")) t.length > 0 && a.push(t);
+	};
+	for (let a = 0; a < e.length; a++) {
+		let l = e[a];
+		if (l === void 0) continue;
+		let u = l.indexOf("="), d = u > 0 ? l.slice(0, u) : l, f = u > 0 ? l.slice(u + 1) : void 0;
+		if (te.has(d)) {
+			let i = f ?? e[++a] ?? "";
+			d === "--to" ? t = i : d === "--from" ? n = i : d === "--root" ? r = s(i === "" ? "." : i) : c(i);
+			continue;
+		}
+		if (d.startsWith("-")) {
+			ne.has(d) || o.push(d);
+			continue;
+		}
+		i.push(l);
+	}
+	return i[0] && (r = s(process.cwd(), i[0])), {
+		root: r,
+		dryRun: e.includes("--dry-run"),
+		force: e.includes("--force"),
+		exact: e.includes("--exact"),
+		codemodsOnly: e.includes("--codemods-only") || e.includes("--run-codemods"),
+		noInstall: e.includes("--no-install"),
+		only: a,
+		unknownFlags: o,
+		...t === void 0 ? {} : { to: t },
+		...n === void 0 ? {} : { from: n }
+	};
+}, Y = "voltro update [app] [flags]\n\nUpgrade an app to a newer framework release: bump every @voltro/* dependency,\ninstall, and run the codemods shipped with the target version.\n\nIn a workspace (pnpm-workspace.yaml, or a package.json \"workspaces\" field),\nEVERY member package.json that declares @voltro/* is bumped in lockstep and the\ninstall runs once at the workspace root — so api / web / shared packages never\nend up on different framework versions.\n\nFlags:\n  --to <version>     Target version (default: the latest published version).\n  --from <version>   Source version — overrides the detected installed version.\n                     Use it after a hand-edited bump so the codemods for the\n                     delta you actually crossed still run.\n  --root <dir>       App directory to update (default: the current directory).\n                     A positional [app] does the same.\n  --dry-run          Print the plan — every package.json that would be bumped,\n                     plus the codemods the target version puts IN RANGE — and\n                     write nothing. Installs nothing. Allowed on a dirty tree,\n                     which is the point: it is how you decide whether to stash.\n  --force            Proceed on a dirty working tree, and re-run even when the\n                     installed version already equals the target.\n  --exact            Pin exact versions (drop the ^ / ~ range prefix).\n  --no-install       Write the version bump, then stop — do not run the package\n                     manager. For a containerised / offline install: run your own\n                     install, then: voltro update --codemods-only --from <old>\n\n  --only <id>        Run only the named codemod(s) — repeatable, or comma-\n                     separated. Ids are what --dry-run prints. Combine with\n                     --codemods-only to take the load-bearing half first.\n\n  --codemods-only    Run ONLY the codemods for [from, to] against the installed\n                     tree — no version bump, no install. The recovery path after\n                     a manual bump, or after a failed install. Alias:\n                     --run-codemods.\n\nMemory: the codemod pass parses source, so it wants heap in proportion to the\nfiles it touches. It sizes the child's --max-old-space-size from THIS machine —\nnode's own default caps near 4 GB however much RAM is installed — so you should\nnot need to set anything. If it still runs out it says so and names the knob;\nNODE_OPTIONS=--max-old-space-size=<MB> overrides, and --only / --root narrow the\npass instead of enlarging it.\n  -h, --help         Print this help.\n\nExamples:\n  voltro update\n  voltro update --to 0.6.0 --dry-run\n  voltro update --codemods-only --from 0.5.0 --to 0.6.0\n\nAfter updating: run `voltro db apply` (NOT db migrate) to reconcile changed\nframework tables, then your typecheck.", ie = (e) => e.includes("--help") || e.includes("-h"), ae = async (e, t = {}) => {
+	let n = t.latestVersion ?? z, i = t.isGitClean ?? A, s = t.install ?? ((e, t) => h(e, ["install"], {
+		cwd: t,
+		stdio: "inherit"
+	}).status ?? 1);
+	if (ie(e)) return console.log(Y), 0;
+	let l = re(e);
+	if (l.unknownFlags.length > 0) return console.error(`voltro update: unknown flag ${l.unknownFlags.join(", ")}`), console.error("  Run `voltro update --help` for the flags this command accepts."), 1;
+	let u = a(l.root, "package.json");
+	if (!c(u)) {
+		let e = V.find((e) => c(a(l.root, e))), t = e === void 0 ? void 0 : H(l.root);
+		return e !== void 0 && t !== void 0 ? (console.error(`voltro update: ${e} is here, but this directory has no package.json.`), console.error("  That is a supported layout — one root manifest, apps carrying only their"), console.error("  app.config.ts. The bump belongs to the manifest that declares @voltro/*, and"), console.error("  the codemods run across every app beneath it:"), console.error(`    voltro update --root ${t}`), 1) : (console.error(`voltro update: no package.json at ${l.root}`), 1);
+	}
+	let d = B(u), p = W(d);
+	if (p.length === 0) {
+		let e = V.find((e) => c(a(l.root, e)));
+		if (e !== void 0) {
+			let t = H(l.root);
+			return console.error(`voltro update: ${e} is here, but ${r(u)} declares no @voltro/* dependency.`), console.error("  This IS a Voltro app — its dependencies are just declared further up, which"), console.error("  is a supported layout (one root manifest, apps carrying only app.config.ts)."), console.error("  Nothing can be bumped HERE: a bump rewrites dependency ranges, and this file"), console.error("  has none."), t === void 0 ? (console.error("  No ancestor package.json declares @voltro/* either. Add the dependencies to"), console.error("  the manifest that owns this workspace, then run update from there.")) : (console.error("  Run it where they are declared — that manifest covers every app beneath it:"), console.error(`    voltro update --root ${t}`)), 1;
+		}
+		return console.error("voltro update: no @voltro/* dependencies here — not a Voltro app."), 1;
+	}
+	if (!l.dryRun && !l.force && !i(l.root)) if (l.codemodsOnly) console.warn("voltro update: working tree is not clean — the codemod diff will be mixed in"), console.warn("  with your existing changes. Review with `git diff` before committing; the"), console.warn("  codemods rewrite source and nothing here separates their edits from yours."), console.warn("  (Use --dry-run first, or --only <id> to take one codemod at a time.)");
+	else return console.error("voltro update: working tree is not clean. Commit/stash first so you can review the"), console.error("  codemod diff — or re-run with --force (not recommended) or --dry-run (preview only)."), console.error("  Only running the codemods? `--codemods-only` proceeds on a dirty tree with a warning —"), console.error("  it rewrites source without bumping or installing."), 1;
+	let m = O(l.root), g = m ?? l.root, _ = () => U(l.root) ?? (m ? U(m) : void 0), v = l.from ?? _() ?? /^\d+\.\d+\.\d+$/.exec(p.find((e) => e.name === "@voltro/cli")?.spec.replace(/^[\^~]/, "") ?? "")?.[0];
+	if (!v) return console.error("voltro update: could not determine the source framework version."), console.error("  Run your package manager install first, or pass --from <version>."), 1;
+	let y = E(l.root), b = l.to ?? (l.codemodsOnly ? _() : void 0) ?? n("@voltro/cli", y);
+	if (!b) return console.error(`voltro update: could not resolve the latest @voltro/cli version via ${y}.`), console.error("  Pin an explicit target with --to <version>."), 1;
+	if (l.codemodsOnly) return v === b ? (console.log(`voltro update: --codemods-only with from === to (${b}) — no delta, nothing to apply.`), console.log("  Pass --from <earlier-version> to re-run the codemods you skipped."), 0) : (console.log(`voltro update: re-applying codemods ${v} → ${b} (no version bump)…`), $([
+		"--root",
+		l.root,
+		"--from",
+		v,
+		"--to",
+		b,
+		...l.dryRun ? ["--dry-run"] : [],
+		...l.only.length > 0 ? ["--only", l.only.join(",")] : []
+	]));
+	if (v === b && !l.force) return console.log(`voltro update: already on ${b} — nothing to do.`), console.log("  (Bumped @voltro/* by hand? Re-run the skipped codemods with"), console.log("   `voltro update --codemods-only --from <earlier-version>`.)"), 0;
+	let x = [u, ...m ? k(m) : []], S = [], C = /* @__PURE__ */ new Set();
+	for (let e of x) if (!C.has(e)) {
+		if (C.add(e), e === u) {
+			S.push({
+				path: e,
+				pkg: d
+			});
+			continue;
+		}
+		try {
+			S.push({
+				path: e,
+				pkg: B(e)
+			});
+		} catch {}
+	}
+	let w = q(S, b, l.exact);
+	console.log(`voltro update: ${v} → ${b}`);
+	let T = w.length > 1;
+	m && console.log(`  workspace: ${m} (${w.length} package.json with @voltro/* deps)`);
+	for (let e of w) {
+		let t = T ? "    " : "  ";
+		T && console.log(`  ${o(g, e.path) || e.path}`);
+		for (let n of e.entries.filter((e) => !e.skipped)) console.log(`${t}${n.name}: ${n.from} → ${n.to}`);
+		for (let n of e.entries.filter((e) => e.skipped)) console.log(`${t}${n.name}: kept (${n.skipped})`);
+	}
+	console.log(`  package manager: ${y}`), console.log(`  install runs in: ${g}`);
+	let D = L(b, y);
+	if (D === void 0) console.log(`  codemods: applied from ${b} after install`), console.log(`    (could not preview — ${b} publishes no codemod manifest, or the registry`), console.log("     could not be reached. This is NOT the same as \"no codemods\".)");
+	else {
+		let e = R(D, v, b);
+		if (e.length === 0) console.log(`  codemods: none in range for ${v} → ${b}`);
+		else {
+			console.log(`  codemods: ${e.length} in range for ${v} → ${b}`);
+			for (let t of e) console.log(`    ${t.kind === "transform" ? "✎" : "☰"} ${t.id} — ${t.title}`);
+			console.log("    ✎ rewrites source · ☰ prints written steps"), console.log("    In RANGE, not necessarily applicable: each one still tests your source"), console.log("    before doing anything. This is the upper bound on what a run can touch.");
+		}
+	}
+	if (l.dryRun) return console.log("\n(dry-run — nothing written, nothing installed.)"), 0;
+	for (let e of J(S, w)) f(e.path, JSON.stringify(e.pkg, null, 2) + "\n");
+	if (l.noInstall) return console.log(`\nvoltro update: bumped ${w.length} package.json to ${b}. Install NOT run (--no-install).`), console.log("  The tree is half-upgraded until you finish both steps:"), console.log("    1. install however this project installs (container, CI image, offline mirror)"), console.log(`    2. voltro update --codemods-only --from ${v} --to ${b}`), console.log("  Step 2 is not optional: the codemods for this jump ship INSIDE the target"), console.log("  version, so nothing could have run them before the install put them on disk."), 0;
+	console.log(`\nInstalling with ${y} in ${g}…`);
+	let j = s(y, g);
+	if (j !== 0) return console.error(`\nvoltro update: ${y} install failed in ${g}.`), console.error(`  • package.json was bumped to ${b} (${w.length} file${w.length === 1 ? "" : "s"}).`), console.error("  • CODEMODS WERE NOT APPLIED — they ship inside the target version, which the"), console.error("    failed install did not put on disk, so there was nothing to run."), console.error("  Fix the install, re-run it, then apply the codemods you are missing:"), console.error(`    voltro update --codemods-only --from ${v} --to ${b}`), console.error("  If this project's install CANNOT run on this host — a containerised install"), console.error("  with its own store, an offline mirror — use `--no-install` next time: it writes"), console.error("  the bump, says so, and leaves the install to you."), j;
+	let M = G(g, S, y, s);
+	if (M !== 0) return M;
+	let N = [l.root, g].map((e) => a(e, "node_modules", ".bin", "voltro")).find((e) => c(e));
+	if (N) {
+		console.log("\nApplying codemods…");
+		let e = h(N, [
+			"_apply-codemods",
+			"--root",
+			l.root,
+			"--from",
+			v,
+			"--to",
+			b,
+			...l.only.length > 0 ? ["--only", l.only.join(",")] : []
+		], {
+			cwd: l.root,
+			stdio: "inherit",
+			env: Z(process.env)
+		});
+		if (e.status !== 0) {
+			let t = X(e.status, e.signal);
+			return t !== void 0 && console.error(`\n${t}`), e.status ?? 1;
+		}
+	} else console.log("\nApplying codemods (in-process — installed bin not found)…"), await $([
+		"--root",
+		l.root,
+		"--from",
+		v,
+		"--to",
+		b,
+		...l.only.length > 0 ? ["--only", l.only.join(",")] : []
+	]);
+	return console.log("\n✓ update complete. Next:"), console.log("  • voltro db apply      # reconcile any changed framework tables (NOT db migrate)"), console.log("  • <your typecheck>     # verify the codemods + your code compile against the new API"), 0;
+}, X = (e, t) => {
+	if (t === "SIGABRT" || e === 134) return "The codemod pass ran out of memory (V8 aborts rather than failing cleanly, which is why\nnothing above names a limit).\n\n  • It already sizes its heap from this machine — raise it explicitly with\n    NODE_OPTIONS=--max-old-space-size=<MB> voltro update\n  • Or narrow the pass: voltro update --only <codemod-id>, or --root <subdir>\n    to run one workspace at a time.";
+	if (t !== null) return `The codemod pass was killed by ${t} — it did not fail, something stopped it.\nOn a container, this is usually the memory cgroup; give it more, or narrow the pass
+with \`--only\` / \`--root\`.`;
+}, Z = (e, t = p()) => {
+	if (e.NODE_OPTIONS?.includes("--max-old-space-size")) return e;
+	let n = Math.floor(t / 1024 / 1024 * .75);
+	if (!Number.isFinite(n) || n < 4096) return e;
+	let r = e.NODE_OPTIONS;
+	return {
+		...e,
+		NODE_OPTIONS: `${r ? `${r} ` : ""}--max-old-space-size=${n}`
+	};
+}, Q = (e, t) => {
+	let n = [];
+	for (let r = 0; r < e.length; r++) {
+		let i = e[r];
+		if (i !== void 0) {
+			if (i === t) {
+				n.push(e[++r] ?? "");
+				continue;
+			}
+			i.startsWith(`${t}=`) && n.push(i.slice(t.length + 1));
+		}
+	}
+	return n;
+}, oe = (e) => {
+	let t = (t) => Q(e, t)[0];
+	return {
+		root: s(t("--root") ?? process.cwd()),
+		from: t("--from") ?? "0.0.0",
+		to: t("--to") ?? "0.0.0",
+		dryRun: e.includes("--dry-run"),
+		only: Q(e, "--only").flatMap((e) => e.split(",")).filter((e) => e.length > 0)
+	};
+}, $ = async (t) => {
+	let n = oe(t), r = await e({
+		root: n.root,
+		from: n.from,
+		to: n.to,
+		dryRun: n.dryRun,
+		only: n.only,
+		log: (e) => console.log(`  ${e}`)
+	});
+	if (r.applied.length === 0 && r.manual.length === 0) return console.log("codemods: nothing to apply for this jump."), 0;
+	let i = n.dryRun ? "·" : "✓";
+	for (let e of r.applied) {
+		let t = [];
+		e.renamedFiles.length > 0 && t.push(`${e.renamedFiles.length} renamed`), e.changedFiles.length > 0 && t.push(`${e.changedFiles.length} edited`);
+		let r = t.length > 0 ? ` (${t.join(", ")})` : " (nothing to do)";
+		console.log(`${i} ${e.id} — ${e.title}${r}${n.dryRun ? " [would apply]" : ""}`);
+	}
+	if (r.manual.length > 0) {
+		console.log("\nManual steps required (could not be automated):");
+		for (let e of r.manual) {
+			console.log(`\n▸ ${e.id} — ${e.title}`);
+			for (let t of e.note.split("\n")) console.log(`  ${t}`);
+		}
+	}
+	return n.dryRun && console.log("\n(dry-run — no files written)"), 0;
+};
+//#endregion
+export { X as a, O as c, q as d, $ as f, k as g, Z as h, R as i, F as l, P as m, H as n, E as o, ae as p, J as r, L as s, Y as t, K as u };

package/dist/updateCommand-us1_hdIC.js

@@ -0,0 +1,2 @@
+import { f as e, p as t } from "./updateCommand-Bkptutss.js";
+export { e as runApplyCodemods, t as runUpdateCommand };