@voltro/cli 0.37.0 → 0.39.0

package/dist/startEntry.js

@@ -1,3 +1,3 @@
 import { t as e } from "./loadEnv-D9nEOClM.js";
-import { t } from "./start-T4VesWiM.js";
+import { t } from "./start-ft_KzFTd.js";
 export { e as loadDotEnv, t as runStartCommand };

package/dist/startup.d.ts

@@ -3,6 +3,35 @@ import { StartupContext } from '@voltro/runtime';
 import { StartupFn } from '@voltro/runtime';
 import { SyncLogger } from '@voltro/logger';
 
+/**
+ * How long a startup may run before the boot refuses it.
+ *
+ * ── Why there is a ceiling at all, and why it used to be 2 seconds ─────────
+ *
+ * The old value was 2000 ms and it was not a ceiling — it was a RACE the boot
+ * always won. A startup slower than that was reported as fine and the boot
+ * moved on, so a rejection arriving afterwards had nothing left to refuse.
+ *
+ * That race existed to protect one shape: a startup that never returns because
+ * it holds a fiber until shutdown. Counted before changing it, that shape
+ * appears in ZERO of the four startups this framework ships — `warm.startup.tsx`
+ * (twice), `searchBackfill.startup.tsx` and the memory fixture's all return.
+ * `warm` is the one to copy: it starts an interval, hands the teardown back
+ * through `onShutdown`, and returns.
+ *
+ * So the race protected the shape we discourage and penalised the shape we
+ * teach — and the penalised one includes `searchBackfill`, our own example,
+ * which awaits a full-table query plus an index backfill and is the likeliest
+ * thing in the box to exceed two seconds. Slow AND failing put a consumer back
+ * in exactly the silent state this file was fixed for.
+ *
+ * 60 seconds because the number now has one job: turn "hangs forever" into
+ * something diagnosable. It must never fire for honest work, and a boot that
+ * refuses after a minute with a message naming the file beats one that waits
+ * for a fiber that is never coming.
+ */
+export declare const DEFAULT_STARTUP_TIMEOUT_MS = 60000;
+
 export declare interface DiscoveredStartup {
     readonly file: string;
     readonly id: string;
@@ -13,7 +42,7 @@ export declare const loadStartupFiles: (files: ReadonlyArray<string>, log: SyncL
 
 /** Run every discovered startup. Returns a handle whose `shutdown()`
  *  drains every registered teardown LIFO. */
-export declare const runStartups: (startups: ReadonlyArray<DiscoveredStartup>, store: DataStore, parentLog: SyncLogger) => Promise<StartupHandle>;
+export declare const runStartups: (startups: ReadonlyArray<DiscoveredStartup>, store: DataStore, parentLog: SyncLogger, ceilingMs?: number) => Promise<StartupHandle>;
 
 export { StartupContext }
 
@@ -23,4 +52,14 @@ export declare interface StartupHandle {
     readonly shutdown: () => Promise<void>;
 }
 
+/**
+ * The ceiling, from `VOLTRO_STARTUP_TIMEOUT_MS`.
+ *
+ * An app with a genuinely long backfill raises it; the env var is the whole
+ * knob, and the refusal names it so nobody has to find this constant. Not an
+ * `app.config.ts` field: this is an operational safety limit, not a design
+ * choice about the app, and the parameter below is the seam if that changes.
+ */
+export declare const startupTimeoutMsFromEnv: (envValue: string | undefined) => number;
+
 export { }

package/dist/startup.js

@@ -1,2 +1,2 @@
-import { n as e, t } from "./startupRunner-DPGFchOa.js";
-export { t as loadStartupFiles, e as runStartups };
+import { i as e, n as t, r as n, t as r } from "./startupRunner-CEqQq7ax.js";
+export { r as DEFAULT_STARTUP_TIMEOUT_MS, t as loadStartupFiles, n as runStartups, e as startupTimeoutMsFromEnv };

package/dist/startupRunner-CEqQq7ax.js

@@ -0,0 +1,108 @@
+import { n as e } from "./appModuleLoader-C9r9mxZt.js";
+import { t } from "./bootRefusal-pgvDxlrU.js";
+import { basename as n } from "node:path";
+import { publishServerError as r } from "@voltro/protocol";
+//#region src/startupRunner.ts
+var i = (e) => e.replace(/\.startup\.tsx?$/, ""), a = async (r, a) => {
+	let o = [];
+	for (let a of r) {
+		let r;
+		try {
+			r = await e(a);
+		} catch (e) {
+			throw t(`startup file \`${a}\` could not be imported — refusing to boot.\n  cause: ${e instanceof Error ? e.message : String(e)}\n
+It was discovered as a startup, so whatever it registers is missing from this process. Skipping it would leave a server that looks healthy.`);
+		}
+		let s = r.default;
+		if (typeof s != "function") throw t(`startup file \`${a}\` has no default-exported function — refusing to boot.\n
+The convention is a DEFAULT-exported function, not a \`defineX\` wrapper:
+
+    export default async (ctx) => { /* register here */ }
+
+A named export is discovered and never runs, which is indistinguishable from a startup that ran and did nothing.`);
+		o.push({
+			file: a,
+			id: i(n(a)),
+			fn: s
+		});
+	}
+	return o;
+}, o = 6e4, s = (e) => {
+	let t = Number(e);
+	return Number.isFinite(t) && t > 0 ? t : o;
+}, c = async (e, n, i, a = s(process.env.VOLTRO_STARTUP_TIMEOUT_MS)) => {
+	let o = [];
+	for (let s of e) {
+		let e = i.child(`startup:${s.id}`), c = {
+			store: n,
+			log: e,
+			id: s.id,
+			onShutdown: (e) => {
+				o.push({
+					id: s.id,
+					cb: e
+				});
+			}
+		}, l, u = !1;
+		try {
+			let e = s.fn(c);
+			if (e instanceof Promise) {
+				let t, n = new Promise((e) => {
+					t = setTimeout(() => e("timeout"), a);
+				});
+				try {
+					u = await Promise.race([e.then(() => "done", (e) => (l = e, r({
+						error: e,
+						source: "startup",
+						name: s.id
+					}), "done")), n]) === "timeout";
+				} finally {
+					t !== void 0 && clearTimeout(t);
+				}
+			}
+		} catch (e) {
+			l = e, r({
+				error: e,
+				source: "startup",
+				name: s.id
+			});
+		}
+		if (l !== void 0) throw e.error("startup: failed", { file: s.file }, l), t(`startup \`${s.id}\` failed — refusing to boot.\n  file: ${s.file}\n  cause: ${l instanceof Error ? l.message : String(l)}\n
+A startup is where an app REGISTERS things the request path depends on (\`setRowFilter\` is the one that matters most). Continuing past a failed one produces a server that looks healthy and is missing whatever the startup was there to install — which is why this used to be a warning and is now a refusal.
+
+If this failure IS acceptable, catch it inside the startup function itself, where the decision is visible to a reviewer.`);
+		if (u) throw e.error("startup: never returned", {
+			file: s.file,
+			ceilingMs: a
+		}), t(`startup \`${s.id}\` did not return within ${a}ms — refusing to boot.\n  file: ${s.file}\n
+A startup must START its work and RETURN. Hand the teardown back through
+\`onShutdown\` instead of awaiting forever:
+
+    export default async ({ store, log, onShutdown }) => {
+      const timer = setInterval(() => sync(store), 60_000)
+      onShutdown(() => clearInterval(timer))
+    }
+
+Awaiting a fiber that resolves only on shutdown used to be allowed, and it
+is what made a slow startup that then FAILED unreportable — the boot had
+already moved on, so nothing was left to refuse.
+
+If this startup is legitimately slower than ${a}ms, raise\nVOLTRO_STARTUP_TIMEOUT_MS — or, better, do the registration first and the
+long work after, so a failure in the long half cannot hide a missing
+registration.`);
+		e.info("startup: registered");
+	}
+	return { shutdown: async () => {
+		for (let e = o.length - 1; e >= 0; e--) {
+			let { id: t, cb: n } = o[e], r = i.child(`startup:${t}`);
+			try {
+				let e = n();
+				e instanceof Promise && await Promise.race([e, new Promise((e) => setTimeout(e, 5e3))]);
+			} catch (e) {
+				r.warn("startup: teardown threw", {}, e);
+			}
+		}
+	} };
+};
+//#endregion
+export { s as i, a as n, c as r, o as t };

package/dist/{test-DIQ0jlkQ.js → test-CLYXrZ2F.js}

@@ -79,7 +79,7 @@ var d = l({ scope: "voltro:test" }), f = (e) => {
 }, C = async (e) => {
 	let t = m(e);
 	if (!o(t.root)) return console.error(`voltro test: no such directory: ${t.root}`), 1;
-	let { checkRpcGroupFreshness: n } = await import("./codegen-uYrrDzQv.js"), r = await n(t.root);
+	let { checkRpcGroupFreshness: n } = await import("./codegen-i8QGcHsi.js"), r = await n(t.root);
 	if (r.kind === "stale") return console.error(`voltro test: ${r.file} is stale — ${r.reason}.`), console.error("  The tests would run against the previously generated procedure group, pass, and prove nothing about the descriptors you just edited.\n  Run `voltro codegen` (or boot `voltro dev` once) and try again."), 1;
 	d.info("running vitest", {
 		root: t.root,

package/dist/{tracesCmd-DStmCJPi.js → tracesCmd-DgtgOUdi.js}

@@ -133,10 +133,13 @@ var a = (e) => {
 	});
 	g.sort((e, t) => t.startMs - e.startMs);
 	let v = g.slice(0, a.tail);
-	if (a.format === "json") return t(_.length > 0 ? {
-		traces: v,
-		fetchErrors: _
-	} : { traces: v }, { pretty: !1 }), +(_.length === c.length);
+	if (a.format === "json") {
+		let e = _.length > 0 ? {
+			traces: v,
+			fetchErrors: _
+		} : { traces: v };
+		return t(e, { pretty: !1 }), +(_.length === c.length);
+	}
 	m(v, a.color), v.length === 0 && console.error("voltro traces: no traces matched the given filters.");
 	for (let e of _) {
 		let t = `# fetch failed: ${e.name}: ${e.error}`;

package/dist/{typecheckCommand-BlsWiCNq.js → typecheckCommand-BuCtT92o.js}

@@ -7,13 +7,13 @@ import { spawn as c } from "node:child_process";
 //#region src/typecheckCommand.ts
 var l = o({ scope: "voltro:typecheck" }), u = (e) => {
 	try {
-		let t = r(n(s(r(i(e), "package.json")).resolve("typescript/package.json")), "bin", "tsc");
-		return a(t) ? t : null;
+		let t = s(r(i(e), "package.json")).resolve("typescript/package.json"), o = r(n(t), "bin", "tsc");
+		return a(o) ? o : null;
 	} catch {
 		return null;
 	}
 }, d = /* @__PURE__ */ new Set(["--project", "-p"]), f = (n, r = process.cwd()) => {
-	let a = i(r, e(n, [...d])[0] ?? "."), o = t(n, "--project") ?? t(n, "-p"), s = [];
+	let a = e(n, [...d]), o = i(r, a[0] ?? "."), s = t(n, "--project") ?? t(n, "-p"), c = [];
 	for (let e = 0; e < n.length; e++) {
 		let t = n[e];
 		if (t.startsWith("-")) {
@@ -22,13 +22,13 @@ var l = o({ scope: "voltro:typecheck" }), u = (e) => {
 				!t.includes("=") && n[e + 1] !== void 0 && !n[e + 1].startsWith("-") && e++;
 				continue;
 			}
-			s.push(t);
+			c.push(t);
 		}
 	}
 	return {
-		root: a,
-		project: o,
-		passthrough: s
+		root: o,
+		project: s,
+		passthrough: c
 	};
 }, p = async (e) => {
 	let t = f(e);

package/dist/updateCommand-6FMU2klq.js

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

package/dist/{updateCommand-9GHHsmDf.js → updateCommand-CHBmCB17.js}

@@ -1,4 +1,4 @@
-import { n as e, r as t, t as n } from "./codemodRunner-cyqu5oxr.js";
+import { n as e, r as t, t as n } from "./codemodRunner-D-jTyvWo.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";
@@ -426,8 +426,10 @@ var g = (e) => {
 		}
 		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;
+	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);