@voltro/cli 0.33.0 → 0.34.0

package/dist/renderModeScan-D7J1B7Kw.js

@@ -0,0 +1,105 @@
+import { join as e } from "node:path";
+import { readFile as t } from "node:fs/promises";
+//#region src/isrCache.ts
+var n = () => {
+	let e = /* @__PURE__ */ new Map();
+	return {
+		get(t) {
+			return e.get(t);
+		},
+		set(t, n) {
+			e.set(t, n);
+		},
+		invalidate(t) {
+			e.delete(t);
+		},
+		invalidateBy(t) {
+			let n = 0;
+			for (let r of e.keys()) t(r) && (e.delete(r), n++);
+			return n;
+		},
+		clear() {
+			e.clear();
+		},
+		size() {
+			return e.size;
+		},
+		snapshot() {
+			return Array.from(e.entries());
+		}
+	};
+}, r = (e) => {
+	if (typeof e == "number" && Number.isFinite(e) && e > 0) return e * 1e3;
+	if (typeof e != "string") return null;
+	let t = /^\s*(\d+)\s*(s|seconds?|m|minutes?|h|hours?|d|days?)\s*$/i.exec(e);
+	if (!t) return null;
+	let n = parseInt(t[1], 10);
+	if (!Number.isFinite(n) || n <= 0) return null;
+	let r = t[2].toLowerCase();
+	return r === "s" || r.startsWith("second") ? n * 1e3 : r === "m" || r.startsWith("minute") ? n * 6e4 : r === "h" || r.startsWith("hour") ? n * 36e5 : r === "d" || r.startsWith("day") ? n * 864e5 : null;
+}, i = (e, t = {}) => {
+	let n = [e];
+	return t.tenant !== void 0 && t.tenant !== "" && n.push(`tenant=${t.tenant}`), t.locale !== void 0 && t.locale !== "" && n.push(`lang=${t.locale}`), n.join("|");
+}, a = (e, t) => e.expiresAt > t, o = (e, t) => e.expiresAt <= t && e.servableUntil > t, s = [
+	"static",
+	"spa",
+	"ssr",
+	"isr"
+], c = (e) => typeof e == "string" && s.includes(e), l = s.map((e) => `'${e}'`).join(" | "), u = (e, t) => `[voltro] ${e}: unknown renderMode '${t}'.\n  Valid values: ${l}.${t === "client" || t === "csr" || t === "browser" ? "\n  A page that renders only in the browser is 'spa': it is skipped by the prerender and mounts on the client. If its route has a layout, that layout still renders server-side as an SSR shell." : t === "server" || t === "dynamic" ? "\n  A page rendered per request is 'ssr'." : t === "ssg" || t === "prerender" ? "\n  A page rendered once at build time is 'static' (the default)." : ""}`, d = class extends Error {
+	page;
+	value;
+	name = "InvalidRenderModeError";
+	constructor(e, t) {
+		super(u(e, t)), this.page = e, this.value = t;
+	}
+}, f = (e, t = "<page>") => {
+	if (e.renderMode !== void 0 && e.renderMode !== null) {
+		if (!c(e.renderMode)) throw new d(t, String(e.renderMode));
+		return e.renderMode;
+	}
+	return e.dynamic === "force-dynamic" ? "ssr" : (e.dynamic, "static");
+}, p = (e, t = "<page>") => ({
+	renderMode: f(e, t),
+	tenantAware: e.tenantAware === !0,
+	revalidateMs: r(e.revalidate),
+	staleWhileRevalidateMs: r(e.staleWhileRevalidate) ?? 0,
+	cacheInvalidatesOn: Array.isArray(e.cacheInvalidatesOn) ? e.cacheInvalidatesOn : [],
+	interactive: e.interactive ?? "full",
+	hasLoader: typeof e.loader == "function",
+	hasMeta: e.meta != null,
+	hasGetStaticPaths: typeof e.getStaticPaths == "function"
+}), m = /export\s+const\s+renderMode\s*(?::[^=]+)?=\s*['"]([^'"]*)['"]/, h = (e) => m.exec(e)?.[1] ?? null, g = /export\s*\{([^}]*)\}\s*from\s*['"]([^'"]+)['"]/g, _ = (e) => {
+	g.lastIndex = 0;
+	let t;
+	for (; (t = g.exec(e)) !== null;) {
+		let e = t[2];
+		if (e.startsWith(".")) for (let n of t[1].split(",")) {
+			let t = n.lastIndexOf(" as ");
+			if ((t === -1 ? n : n.slice(t + 4)).trim() === "renderMode") return e;
+		}
+	}
+	return null;
+}, v = /export\s*\{([^}]*)\}/g, y = (e) => {
+	if (/export\s+default\b/.test(e)) return !0;
+	v.lastIndex = 0;
+	let t;
+	for (; (t = v.exec(e)) !== null;) for (let e of t[1].split(",")) {
+		let t = e.lastIndexOf(" as ");
+		if ((t === -1 ? e : e.slice(t + 4)).trim() === "default") return !0;
+	}
+	return !1;
+}, b = async (n, r) => {
+	let i = (await Promise.all(r.map(async (r) => {
+		let i;
+		try {
+			i = await t(e(n, r.file), "utf8");
+		} catch {
+			return null;
+		}
+		let a = h(i);
+		return a !== null && !c(a) ? u(e("src", "pages", r.file), a) : y(i) ? null : `${e("src", "pages", r.file)} is a route (a \`page.tsx\` under src/pages/) but exports no default.\n\n  A page's default export IS its component — the router has nothing to render without it,\n  and the failure would otherwise surface only in \`voltro build\`'s prerender as\n  "SSR received a descriptor with no Component", long after the file was written.\n\n  Fix: \`export default function Page() { … }\`, or re-export another page's component\n  (\`export { default } from '../page'\`). If this file is NOT a route, rename it —\n  only the reserved names route, and anything else under src/pages/ is ordinary code\n  that may live beside the page that uses it.`;
+	}))).filter((e) => e !== null);
+	if (i.length !== 0) throw Error(i.join("\n\n"));
+};
+//#endregion
+export { p as a, f as c, o as d, n as f, s as i, i as l, h as n, c as o, r as p, _ as r, u as s, b as t, a as u };

package/dist/renderProfile-1OWWAAtx.js

@@ -0,0 +1,81 @@
+import { m as e } from "./fileConventions-Cof68_BL.js";
+import { i as t, n, o as r, r as i, s as a } from "./renderModeScan-D7J1B7Kw.js";
+import { dirname as o, join as s, relative as c, resolve as l } from "node:path";
+import { Effect as u } from "effect";
+import { readFile as d, readdir as f } from "node:fs/promises";
+//#region src/static/renderProfile.ts
+var p = /* @__PURE__ */ new Set([
+	"node_modules",
+	"dist",
+	"build",
+	".turbo",
+	".vite",
+	".framework",
+	".git"
+]), m = /export\s+const\s+dynamic\s*=\s*['"]force-(dynamic|static)['"]/, h = /export\s+(?:const|async\s+function|function)\s+getStaticPaths\b/, g = 5, _ = async (e) => {
+	for (let t of [
+		e,
+		`${e}.tsx`,
+		`${e}.ts`,
+		s(e, "index.tsx"),
+		s(e, "index.ts")
+	]) if (/\.[jt]sx?$/.test(t)) try {
+		return {
+			src: await d(t, "utf8"),
+			path: t
+		};
+	} catch {}
+	return null;
+}, v = async (e, t, s) => {
+	let c = e, u = t, d = s;
+	for (let e = 0; e <= g; e++) {
+		let e = n(c);
+		if (e !== null) {
+			if (!r(e)) throw Error(a(u, e));
+			return e;
+		}
+		let t = m.exec(c);
+		if (t) return t[1] === "dynamic" ? "ssr" : "static";
+		let s = i(c);
+		if (s === null) return "static";
+		let f = await _(l(o(d), s));
+		if (f === null) return "static";
+		c = f.src, u = f.path, d = f.path;
+	}
+	return "static";
+}, y = async (n) => {
+	let r = s(n, "src", "pages"), i = [], a = async (t) => {
+		let n;
+		try {
+			n = await f(t, { withFileTypes: !0 });
+		} catch {
+			return;
+		}
+		for (let o of n) {
+			if (p.has(o.name)) continue;
+			let n = s(t, o.name);
+			if (o.isDirectory()) await a(n);
+			else if (o.isFile() && e.test(o.name)) {
+				let e = c(r, n), t = await d(n, "utf8");
+				i.push({
+					file: e,
+					mode: await v(t, s("src", "pages", e), n),
+					dynamic: e.includes("["),
+					hasStaticPaths: h.test(t)
+				});
+			}
+		}
+	};
+	await a(r);
+	let o = Object.fromEntries(t.map((e) => [e, 0]));
+	for (let e of i) o[e.mode]++;
+	let l = i.filter((e) => e.mode === "static" && e.dynamic && !e.hasStaticPaths).map((e) => e.file);
+	return {
+		pages: i,
+		counts: o,
+		dynamicMissing: l,
+		staticSafe: o.ssr === 0 && o.isr === 0 && l.length === 0
+	};
+}, b = (e) => u.promise(() => y(e));
+//#endregion
+export { y as n, b as t };

package/dist/runtimeRegistry-DMeKfTHP.js

@@ -0,0 +1,81 @@
+import { join as e } from "node:path";
+import { promises as t } from "node:fs";
+import { homedir as n } from "node:os";
+//#region src/runtimeRegistry.ts
+var r = e(n(), ".voltro"), i = e(r, "runtime-registry.json"), a = 3e4, o = () => {
+	let e = Math.random().toString(36).slice(2, 10);
+	return `${i}.${process.pid}.${Date.now()}.${e}.tmp`;
+}, s = async () => {
+	await t.mkdir(r, { recursive: !0 });
+}, c = async () => {
+	try {
+		let e = await t.readFile(i, "utf8"), n = JSON.parse(e);
+		return n.version !== 1 || !Array.isArray(n.apps) ? {
+			version: 1,
+			apps: []
+		} : n;
+	} catch {
+		return {
+			version: 1,
+			apps: []
+		};
+	}
+}, l = async (e) => {
+	await s();
+	let n = o();
+	try {
+		await t.writeFile(n, JSON.stringify(e, null, 2), {
+			encoding: "utf8",
+			mode: 384
+		}), await t.rename(n, i), await t.chmod(i, 384).catch(() => {});
+	} catch (e) {
+		try {
+			await t.unlink(n);
+		} catch {}
+		throw e;
+	}
+}, u = (e) => {
+	try {
+		return process.kill(e, 0), !0;
+	} catch {
+		return !1;
+	}
+}, d = (e) => {
+	let t = Date.now();
+	return e.filter((e) => u(e.pid) ? t - new Date(e.heartbeatAt).getTime() < a : !1);
+}, f = async () => {
+	let e = await c(), t = d(e.apps);
+	if (t.length === e.apps.length) return e;
+	try {
+		await l({
+			version: 1,
+			apps: t
+		});
+	} catch {}
+	return {
+		version: 1,
+		apps: t
+	};
+}, p = async (e) => {
+	let t = await c(), n = (/* @__PURE__ */ new Date()).toISOString(), r = t.apps.findIndex((t) => t.id === e.id), i = e.inspectToken ?? process.env.VOLTRO_INSPECT_TOKEN, a = {
+		...e,
+		...i !== void 0 && i !== "" ? { inspectToken: i } : {},
+		registeredAt: r >= 0 ? t.apps[r].registeredAt : n,
+		heartbeatAt: n
+	};
+	await l({
+		version: 1,
+		apps: r >= 0 ? t.apps.map((e, t) => t === r ? a : e) : [...t.apps, a]
+	});
+}, m = async (e) => {
+	try {
+		let t = await c(), n = t.apps.filter((t) => t.id !== e);
+		if (n.length === t.apps.length) return;
+		await l({
+			version: 1,
+			apps: n
+		});
+	} catch {}
+}, h = (e, t, n) => `${e}:${t}:${n}`;
+//#endregion
+export { p as i, f as n, m as r, h as t };

package/dist/runtimeTrace-CRxalXTs.js

@@ -0,0 +1,91 @@
+import { n as e } from "./apiBuild-DZF_f0_I.js";
+import { join as t, resolve as n, sep as r } from "node:path";
+import { existsSync as i, promises as a } from "node:fs";
+import { createLogger as o } from "@voltro/logger";
+import { createRequire as s } from "node:module";
+//#region src/runtimeTrace.ts
+var c = o({ scope: "voltro:build" }), l = [
+	[
+		".framework",
+		"dist-web",
+		"startBundle",
+		"startEntry.js"
+	],
+	[
+		".framework",
+		"dist",
+		"server",
+		"ssrEntry.js"
+	],
+	[
+		".framework",
+		"dist",
+		"server",
+		"appConfig.js"
+	],
+	[
+		".framework",
+		"dist-api",
+		"serveBundle",
+		"serveEntry.js"
+	]
+], u = ["pg", ...e.filter((e) => !e.includes("*"))], d = async (e) => {
+	let o = t(e, "node_modules");
+	if (!i(o)) return null;
+	let d;
+	try {
+		({nodeFileTrace: d} = await import("@vercel/nft"));
+	} catch {
+		return c.warn("runtime trace skipped — @vercel/nft not installed (image keeps the full node_modules)"), null;
+	}
+	let f = l.map((n) => t(e, ...n)).filter((e) => i(e));
+	if (f.length === 0) return null;
+	let p = s(t(e, "_.js")), m = 0;
+	for (let e of u) try {
+		f.push(p.resolve(e)), m++;
+	} catch {}
+	let { fileList: h } = await d(f, { base: e }), g = /* @__PURE__ */ new Set();
+	for (let t of h) {
+		let i = n(e, t);
+		i.startsWith(o + r) && g.add(i);
+	}
+	let _ = 0, v = async (e) => {
+		let n = !1;
+		for (let r of await a.readdir(e, { withFileTypes: !0 })) {
+			let i = t(e, r.name);
+			if (r.isSymbolicLink()) {
+				n = !0;
+				continue;
+			}
+			r.isDirectory() ? await v(i) ? n = !0 : await a.rmdir(i).catch(() => {
+				n = !0;
+			}) : g.has(i) ? n = !0 : (await a.rm(i).catch(() => {}), _++);
+		}
+		return n;
+	}, y = await v(o);
+	return y || await a.rm(o, {
+		recursive: !0,
+		force: !0
+	}).catch(() => {}), c.info("runtime trace: pruned node_modules to the reachable set", {
+		nativeLeaves: m > 0 ? u.filter((e) => {
+			try {
+				return !!p.resolve(e);
+			} catch {
+				return !1;
+			}
+		}).join(", ") : "none",
+		filesRemoved: _,
+		nodeModules: y ? "pruned" : "removed (fully self-contained)"
+	}), m;
+}, f = async (e) => {
+	let t = e.find((e) => !e.startsWith("-"));
+	if (!t) return c.error("usage: voltro prune-runtime <deploy-dir>"), 1;
+	try {
+		await d(n(t));
+	} catch (e) {
+		c.warn("runtime trace failed — image keeps the full node_modules (not fatal)", {}, e);
+	}
+	return 0;
+};
+//#endregion
+export { f as runPruneRuntimeCommand };

package/dist/scheduleCmd--jksTrf6.js

@@ -0,0 +1,69 @@
+import { n as e } from "./cliOutput-D1tSBoRM.js";
+import { n as t, o as n, r, t as i } from "./inspectFetch-Cm8_wVvp.js";
+import { ansi as a } from "@voltro/logger";
+//#region src/scheduleCmd.ts
+var o = () => {
+	console.log(`${a.bold("voltro schedule")} — operate on registered schedules
+
+  ${a.bold("run <name>")}   fire the named schedule once, now
+
+Options
+  --process NAME    target one app by name (default: every live api)
+  --trigger manual|external
+                    how the run is recorded (default: manual)
+  --format pretty|json
+  --url URL         address a process directly instead of via the local registry
+
+Examples
+  voltro schedule run nightly-reconcile
+  voltro schedule run nightly-reconcile --process billing --format json
+
+The target must expose the inspect surface: set ${a.bold("VOLTRO_INSPECT_TOKEN")} on the
+server and in this shell. \`voltro dev\` mints one per project; \`serve\` / \`start\`
+never mint — inspect stays closed until an operator opens it.`);
+}, s = (t, n, r, i) => {
+	if (i === "json") {
+		e({
+			app: t,
+			schedule: n,
+			runId: r
+		});
+		return;
+	}
+	if (r === null) {
+		console.log(`${a.yellow("○")} ${t}: ${a.bold(n)} not started — no run id.\n  Another replica holds the coordination lock, or the previous run is still going and this schedule's onOverlap is 'skip'.`);
+		return;
+	}
+	console.log(`${a.green("✓")} ${t}: ${a.bold(n)} fired — run ${a.bold(r)}`), console.log(`  watch it: voltro inspect schedules --process ${t}`);
+}, c = async (e) => {
+	let [c, ...l] = e;
+	if (c === void 0 || c === "--help" || c === "-h") return o(), +(c === void 0);
+	if (c !== "run") return console.error(`voltro schedule: unknown subcommand "${c}" (expected: run)`), 1;
+	let u = l.find((e) => !e.startsWith("-"));
+	if (u === void 0) return console.error("voltro schedule run: a schedule name is required — `voltro schedule run <name>`"), 1;
+	let d = t(l);
+	if ("error" in d) return console.error(`voltro schedule run: ${d.error}`), 1;
+	let { format: f } = d, { process: p, target: m, rest: h, error: g } = r(d.rest);
+	if (g !== void 0) return console.error(`voltro schedule run: ${g}`), 1;
+	let _ = h[h.indexOf("--trigger") + 1], v = h.includes("--trigger") && _ === "external" ? "external" : "manual", y = await n(p, m);
+	if (y.length === 0) return console.error("voltro schedule run: no live api found.\n  Start one (`voltro dev` / `voltro serve`), or address it directly with --url."), 1;
+	let b = 0;
+	for (let e of y) {
+		let t = await i(e, `/_voltro/inspect/schedules/${encodeURIComponent(u)}/fire?trigger=${v}`, { method: "POST" });
+		if (t.kind === "err") {
+			b += 1, console.error(`${a.red("✗")} ${e.name}: ${t.error}`);
+			continue;
+		}
+		if (t.status < 200 || t.status >= 300) {
+			b += 1;
+			let n = t.data, r = n?.message === void 0 ? n?.error === void 0 ? `HTTP ${t.status}` : String(n.error) : String(n.message);
+			console.error(`${a.red("✗")} ${e.name}: ${r}`), t.status === 401 && console.error("  Set VOLTRO_INSPECT_TOKEN on the server and in this shell."), t.status === 404 && console.error("  A 404 here means the app is older than this endpoint, or it is a web app (schedules are api-only).");
+			continue;
+		}
+		let n = t.data?.runId ?? null;
+		s(e.name, u, n, f);
+	}
+	return +(b > 0);
+};
+//#endregion
+export { c as runScheduleCommand };

package/dist/scheduleManifestCmd-D2x0CTTY.js

@@ -0,0 +1,249 @@
+import { n as e, t } from "./cliArgs-D4p8n7EE.js";
+import { dirname as n, join as r, resolve as i } from "node:path";
+import { promises as a } from "node:fs";
+import { pathToFileURL as o } from "node:url";
+import { createLogger as s } from "@voltro/logger";
+import { isScheduleDefinition as c } from "@voltro/runtime";
+//#region src/scheduleManifest.ts
+var l = (e) => `/_voltro/schedule/${encodeURIComponent(e)}/fire?trigger=external`, u = (e) => {
+	let t = e.trim().split(/\s+/);
+	return t.length === 6 ? `6-field (seconds) cron "${e}" can't drive an external scheduler — k8s/gcp/aws are minute-resolution. Use a 5-field expression or trigger:'self'.` : t.length === 5 ? null : `expected a 5-field cron expression, got ${t.length} fields: "${e}"`;
+}, d = (e, t) => {
+	let n = t.tokenEnv ?? "VOLTRO_SCHEDULE_TOKEN", r = e.name.toLowerCase().replace(/[^a-z0-9-]/g, "-");
+	return `---
+# ${e.description ?? `schedule "${e.name}"`}
+# Generated from defineSchedule("${e.name}") — do not edit by hand;
+# re-run \`voltro schedule-manifest\` after changing the cron.
+apiVersion: batch/v1
+kind: CronJob
+metadata:
+  name: ${t.appName}-${r}
+spec:
+  schedule: "${e.cron}"
+  timeZone: "${e.timezone}"
+  concurrencyPolicy: Forbid
+  jobTemplate:
+    spec:
+      backoffLimit: 2
+      template:
+        spec:
+          restartPolicy: Never
+          containers:
+            - name: trigger
+              image: curlimages/curl:8.11.0
+              env:
+                - name: ${n}
+                  valueFrom:
+                    secretKeyRef:
+                      name: ${t.appName}-schedule
+                      key: token
+              command: ["sh", "-c"]
+              args:
+                - >
+                  curl -fsS -X POST
+                  -H "Authorization: Bearer $(${n})"
+                  "${t.baseUrl}${l(e.name)}"
+`;
+}, f = (e, t) => {
+	let n = t.tokenEnv ?? "VOLTRO_SCHEDULE_TOKEN", r = e.name.toLowerCase().replace(/[^a-z0-9-]/g, "-");
+	return `# ${e.description ?? `schedule "${e.name}"`}
+gcloud scheduler jobs create http ${t.appName}-${r} \\
+  --schedule="${e.cron}" \\
+  --time-zone="${e.timezone}" \\
+  --uri="${t.baseUrl}${l(e.name)}" \\
+  --http-method=POST \\
+  --headers="Authorization=Bearer $${n}"
+`;
+}, p = (e) => {
+	let [t, n, r, i, a] = e.trim().split(/\s+/), o = r, s = a, c = null;
+	return r === "*" && a === "*" ? s = "?" : r !== "*" && a !== "*" ? c = `AWS cron can't constrain BOTH day-of-month AND day-of-week — review "${e}" manually.` : a === "*" ? s = "?" : o = "?", {
+		expr: `cron(${t} ${n} ${o} ${i} ${s} *)`,
+		note: c
+	};
+}, m = (e, t) => {
+	let n = e.name.replace(/[^a-zA-Z0-9-_]/g, "-"), { expr: r, note: i } = p(e.cron);
+	return `# ${e.description ?? `schedule "${e.name}"`}${i ? `\n# ⚠ ${i}` : ""}
+# EventBridge Scheduler → HTTP needs an API destination + connection
+# (holds the bearer secret). Create those once, then:
+aws scheduler create-schedule \\
+  --name "${t.appName}-${n}" \\
+  --schedule-expression "${r}" \\
+  --schedule-expression-timezone "${e.timezone}" \\
+  --flexible-time-window '{"Mode":"OFF"}' \\
+  --target '{
+    "Arn": "<API_DESTINATION_ARN>",
+    "RoleArn": "<SCHEDULER_ROLE_ARN>",
+    "HttpParameters": { "HeaderParameters": {} },
+    "Input": ""
+  }'
+# Target endpoint: ${t.baseUrl}${l(e.name)}
+`;
+}, h = (e, t) => `// ${e.description ?? `schedule "${e.name}"`}
+// Azure has no direct cron→HTTP primitive. Two options:
+//   1. Logic App with a Recurrence trigger (skeleton below) → HTTP action.
+//   2. An Azure Function with a timer trigger ("${e.cron}") that does the POST.
+// Logic App recurrence skeleton (paste into the App's definition):
+{
+  "triggers": {
+    "${e.name}": {
+      "type": "Recurrence",
+      "recurrence": { "frequency": "Minute", "interval": 1, "timeZone": "${e.timezone}" },
+      "note": "Translate cron '${e.cron}' into the recurrence schedule; the Recurrence trigger is interval-based, not cron — a timer-trigger Function matches cron exactly."
+    }
+  },
+  "actions": {
+    "fire": {
+      "type": "Http",
+      "inputs": {
+        "method": "POST",
+        "uri": "${t.baseUrl}${l(e.name)}",
+        "headers": { "Authorization": "Bearer @{parameters('scheduleToken')}" }
+      }
+    }
+  }
+}
+`, g = (e, t) => {
+	let n = t.tokenEnv ?? "VOLTRO_SCHEDULE_TOKEN", r = e.map((e) => `| \`${e.name}\` | \`${e.cron}\` | ${e.timezone} | \`POST ${l(e.name)}\` |`).join("\n");
+	return `# External-trigger schedules — ${t.appName}
+
+These schedules use \`trigger: 'external'\`. The app does NOT run an
+in-process timer for them; an outside scheduler must POST the fire
+endpoint on the cadence below. Each call is authenticated with a
+bearer token (env \`${n}\`).
+
+| Schedule | Cron | Timezone | Endpoint |
+|---|---|---|---|
+${r}
+
+## curl shape
+
+\`\`\`sh
+curl -fsS -X POST \\
+  -H "Authorization: Bearer $${n}" \\
+  "${t.baseUrl}/_voltro/schedule/<name>/fire?trigger=external"
+\`\`\`
+
+The endpoint returns \`{ "runId": "sr_..." }\` on success (or \`null\`
+when the schedule lost a coordination race — harmless). It is
+idempotent-safe to call at-most-once per intended firing; the
+external scheduler owns the once-only guarantee.
+`;
+}, _ = (e, t, n) => {
+	let r = [], i = [];
+	for (let t of e) {
+		let e = u(t.cron);
+		if (e) {
+			r.push(`schedule "${t.name}": ${e}`);
+			continue;
+		}
+		i.push(t);
+	}
+	if (i.length === 0) return {
+		files: [],
+		warnings: r
+	};
+	let a = [];
+	switch (t) {
+		case "kubernetes":
+			a.push({
+				path: ".voltro/scheduling/kubernetes-cronjobs.yaml",
+				content: i.map((e) => d(e, n)).join("\n")
+			});
+			break;
+		case "gcp":
+			a.push({
+				path: ".voltro/scheduling/gcp-cloud-scheduler.sh",
+				content: `#!/bin/sh\n# GCP Cloud Scheduler jobs — generated from defineSchedule(...).\nset -e\n\n${i.map((e) => f(e, n)).join("\n")}`
+			});
+			break;
+		case "aws":
+			a.push({
+				path: ".voltro/scheduling/aws-eventbridge.sh",
+				content: `#!/bin/sh\n# AWS EventBridge Scheduler — generated from defineSchedule(...).\n# Review the cron translations flagged with ⚠ before applying.\nset -e\n\n${i.map((e) => m(e, n)).join("\n")}`
+			});
+			break;
+		case "azure":
+			a.push({
+				path: ".voltro/scheduling/azure-recurrence.jsonc",
+				content: i.map((e) => h(e, n)).join("\n")
+			});
+			break;
+		case "generic": break;
+	}
+	return a.push({
+		path: ".voltro/scheduling/README.md",
+		content: g(i, n)
+	}), {
+		files: a,
+		warnings: r
+	};
+}, v = s({ scope: "voltro:schedule-manifest" }), y = /* @__PURE__ */ new Set([
+	"kubernetes",
+	"aws",
+	"gcp",
+	"azure",
+	"generic"
+]), b = /* @__PURE__ */ new Set([
+	"node_modules",
+	"dist",
+	"build",
+	".turbo",
+	".vite",
+	".git",
+	".framework",
+	".voltro"
+]), x = async (e) => {
+	let t = [], n = async (e) => {
+		let i = await a.readdir(e, { withFileTypes: !0 });
+		for (let a of i) {
+			if (b.has(a.name)) continue;
+			let i = r(e, a.name);
+			a.isDirectory() ? await n(i) : a.isFile() && /\.cron\.tsx?$/.test(a.name) && t.push(i);
+		}
+	};
+	return await n(e), t;
+}, S = [
+	"--provider",
+	"--base-url",
+	"--token-env"
+], C = async (s) => {
+	let l = i(t(s, S) ?? process.cwd()), u, d = "app";
+	try {
+		let e = (await import(o(r(l, "app.config.ts")).href)).default ?? {};
+		d = typeof e.name == "string" ? e.name : d, u = e.scheduling?.externalProvider;
+	} catch {}
+	let f = e(s, "--provider") ?? u ?? "generic";
+	if (!y.has(f)) return v.error(`unknown --provider "${f}" (expected: ${[...y].join(", ")})`), 1;
+	let p = f, m = e(s, "--base-url") ?? process.env.VOLTRO_PUBLIC_URL ?? "https://CHANGE-ME.example.com", h = e(s, "--token-env") ?? "VOLTRO_SCHEDULE_TOKEN", g = "self";
+	try {
+		g = (await import(o(r(l, "app.config.ts")).href)).default?.scheduling?.trigger ?? "self";
+	} catch {}
+	let b = await x(l), C = [];
+	for (let e of b) {
+		let t = (await import(o(e).href)).default;
+		c(t) && (t.trigger ?? g) === "external" && C.push({
+			name: t.name,
+			cron: t.cron,
+			timezone: t.timezone,
+			...t.description === void 0 ? {} : { description: t.description }
+		});
+	}
+	if (C.length === 0) return v.info("no external-trigger schedules found — nothing to emit", { scanned: b.length }), 0;
+	let { files: w, warnings: T } = _(C, p, {
+		baseUrl: m,
+		tokenEnv: h,
+		appName: d
+	});
+	for (let e of T) v.warn(e);
+	for (let e of w) {
+		let t = r(l, e.path);
+		await a.mkdir(n(t), { recursive: !0 }), await a.writeFile(t, e.content, "utf8"), v.info("wrote", { path: e.path });
+	}
+	return v.info("schedule manifests emitted", {
+		provider: p,
+		schedules: C.length,
+		files: w.length
+	}), m.includes("CHANGE-ME") && v.warn("base URL not set — pass --base-url https://your-app or set VOLTRO_PUBLIC_URL"), 0;
+};
+//#endregion
+export { C as runScheduleManifest };