framefields 2.9.2 → 2.10.0-canary.0

package/dist/cli.mjs

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
-import { t as failedCheck } from "./check-result-C3jlgV2i.mjs";
+import { i as renderCloud, t as CloudRenderError } from "./cloud-xcfV4J03.mjs";
+import { t as failedCheck } from "./check-result-Culfu7Nx.mjs";
 import { createRequire } from "node:module";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { basename, dirname, join, posix, relative, resolve, sep } from "node:path";
+import path, { basename, dirname, join, posix, relative, resolve, sep } from "node:path";
 import { createHash } from "node:crypto";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { spawn } from "node:child_process";
@@ -373,7 +374,8 @@ const SCRIPTS = {
 	frames: "tsx src/render.ts frames",
 	grid: "tsx src/render.ts grid",
 	preview: "tsx src/render.ts preview",
-	render: "tsx src/render.ts"
+	render: "tsx src/render.ts",
+	"render:cloud": "framefields render src/film.ts --cloud --workers auto"
 };
 /**
 * The `package.json` fields a framefields project needs. npm reads
@@ -570,6 +572,7 @@ ${run("frames")} -- 0 30 60   # PNGs in output/
 ${run("grid")}                # a contact sheet of the motion
 ${run("preview")}             # play it in the browser
 ${run("render")}              # output/output.mp4
+${run("render:cloud")}        # on cloud GPUs, from the pushed commit
 \`\`\`
 
 - \`src/film.ts\` builds the composition, \`src/theme.ts\` holds sizes, colors and fonts,
@@ -578,6 +581,9 @@ ${run("render")}              # output/output.mp4
   one into \`src/components/\`.
 - Optional: the AI gateway generates images, video, music, voice and 3D from code. Copy
   \`.env.example\` to \`.env\` and set \`FRAMEFIELDS_API_KEY\` (keys at ${AI_DASHBOARD}).
+- \`render:cloud\` renders on framefields' GPUs with the same key, and splits a long film
+  across several (\`-- --plan\` shows workers, time and cost first). It renders the
+  commit you pushed, not uncommitted changes.
 - Footage, audio and fonts live in \`assets/\` and are tracked with Git LFS
   (\`git lfs install\` once per machine, \`git lfs pull\` after cloning).
 `;
@@ -863,6 +869,131 @@ function isCheckReport(value) {
 	return typeof value === "object" && value !== null && "schemaVersion" in value && value.schemaVersion === 1 && "diagnostics" in value && Array.isArray(value.diagnostics);
 }
 
+//#endregion
+//#region src/cli/cloud.ts
+/**
+* `framefields render <entry> --cloud`: renders the project on
+* api.framefields.dev and downloads the video. Prints one plain line per
+* phase, and a progress line at most every 10 seconds while frames render.
+*/
+const PROGRESS_EVERY_MS = 1e4;
+async function runCloudRender(o, log, render = renderCloud) {
+	const workers = parseWorkers(o.workers);
+	if (workers === void 0) {
+		log(`--workers must be "auto" or a positive whole number, not "${o.workers}".`);
+		return 2;
+	}
+	if (o.codec && o.codec !== "h264" && o.codec !== "vp9") {
+		log(`--codec must be h264 or vp9, not "${o.codec}".`);
+		return 2;
+	}
+	const codec = o.codec ?? "h264";
+	const outputPath = o.output ?? path.join("output", `${path.basename(o.entry).replace(/\.[^.]+$/, "")}.${codec === "vp9" ? "webm" : "mp4"}`);
+	const controller = new AbortController();
+	const onSigint = () => {
+		log("Cancelling the cloud render…");
+		controller.abort(/* @__PURE__ */ new Error("cancelled"));
+	};
+	process.once("SIGINT", onSigint);
+	const started = Date.now();
+	const narrate = narrator(o.json ? () => {} : log, Date.now);
+	try {
+		const result = await render({
+			entry: o.entry,
+			export: o.export,
+			select: o.select,
+			workers: o.plan && workers === 1 ? "auto" : workers,
+			maxWorkers: o.maxWorkers ? Number(o.maxWorkers) : void 0,
+			codec,
+			quality: o.quality,
+			dryRun: o.plan,
+			outputPath: o.plan ? void 0 : outputPath,
+			signal: controller.signal,
+			onProgress: narrate,
+			onWarning: (m) => log(`warning: ${m}`)
+		});
+		if (o.json) {
+			log(JSON.stringify(result));
+			return 0;
+		}
+		if (result.status === "planned") {
+			log(`Render it: framefields render ${o.entry} --cloud --workers ${o.workers ?? "auto"}`);
+			return 0;
+		}
+		const bytes = result.output?.bytes;
+		log(`Done in ${duration((Date.now() - started) / 1e3)}: ${outputPath}${bytes ? ` (${(bytes / 1e6).toFixed(1)} MB)` : ""}, ${Math.round(result.gpuSeconds)} GPU seconds, ${usd(result.costUsd)}.`);
+		return 0;
+	} catch (err) {
+		if (err instanceof CloudRenderError) {
+			log(err.message);
+			if (err.status && err.status.costUsd > 0) log(`Charged ${usd(err.status.costUsd)} for the GPU time used.`);
+			if (err.code === "insufficient_credits") log("Top up at https://framefields.dev/dashboard/billing");
+			return 1;
+		}
+		throw err;
+	} finally {
+		process.removeListener("SIGINT", onSigint);
+	}
+}
+function parseWorkers(value) {
+	if (value === void 0) return 1;
+	if (value === "auto") return "auto";
+	const n = Number(value);
+	return Number.isInteger(n) && n >= 1 ? n : void 0;
+}
+/** Turns status polls into log lines: one per phase, throttled frame progress. */
+function narrator(log, now) {
+	let phase;
+	let planned = false;
+	let lastProgress = 0;
+	return (s) => {
+		if (!phase) log(`Cloud render ${s.id} started.`);
+		if (s.plan && !planned) {
+			planned = true;
+			log(describePlan(s));
+		}
+		if (s.status !== phase) {
+			phase = s.status;
+			const line = phaseLine(s);
+			if (line) log(line);
+			lastProgress = now();
+			return;
+		}
+		if (s.status === "rendering" && now() - lastProgress >= PROGRESS_EVERY_MS) {
+			lastProgress = now();
+			log(progressLine(s));
+		}
+	};
+}
+function describePlan(s) {
+	const plan = s.plan;
+	if (!plan) return "";
+	const est = s.estimateUsd !== void 0 ? `, estimated ${usd(s.estimateUsd)}` : "";
+	return `Plan: ${plan.workers} ${plan.workers === 1 ? "worker" : "workers"}, ${duration(plan.workSec)} of render work, ready in about ${duration(plan.etaSec)}${est}.`;
+}
+function phaseLine(s) {
+	switch (s.status) {
+		case "probing": return "Measuring frame costs on one worker to plan the split…";
+		case "rendering": return s.workers > 1 ? `Rendering ${s.workers} chunks and the audio in parallel…` : "Rendering on one worker…";
+		case "stitching": return `Joining ${s.workers} chunks…`;
+		default: return;
+	}
+}
+function progressLine(s) {
+	const { frames, totalFrames, etaSec } = s.progress;
+	return `Rendering ${totalFrames ? `${Math.floor(frames / totalFrames * 100)}% (${frames}/${totalFrames} frames)` : `${frames} frames`}${etaSec ? `, about ${duration(etaSec)} left` : ""}, ${usd(s.costUsd)} so far.`;
+}
+function duration(sec) {
+	const s = Math.max(0, Math.round(sec));
+	if (s < 90) return `${s} s`;
+	const m = Math.round(s / 60);
+	if (m < 90) return `${m} min`;
+	return `${Math.floor(m / 60)} h ${m % 60} min`;
+}
+function usd(value) {
+	return value > 0 && value < .01 ? "<$0.01" : `$${value.toFixed(2)}`;
+}
+
 //#endregion
 //#region src/cli/registry.ts
 /**
@@ -913,6 +1044,7 @@ function openRegistry(source, cwd = process.cwd()) {
 *   npx framefields list                 the components you can add
 *   npx framefields fonts add <role...>  install fonts (emoji)
 *   npx framefields fonts list           the fonts you can install
+*   npx framefields render <entry> --cloud   render on api.framefields.dev
 */
 const HELP = `Usage: framefields <command> [options]
 
@@ -932,6 +1064,10 @@ Commands:
                   Install fonts (pinned, hash-checked, with their license)
                   and register them in the generated <components>/fonts.ts.
   fonts list      List the fonts you can install.
+  render <entry> --cloud
+                  Render on api.framefields.dev from the pushed commit of
+                  this git repo, and download the video. Needs
+                  FRAMEFIELDS_API_KEY. --export defaults to buildFilm.
 
 Options for check:
   --export <name>   Composition or builder export (default buildFilm).
@@ -941,6 +1077,20 @@ Options for check:
   --warnings-as-errors  Fail on lint warnings.
   --json            Machine-readable check, component list, or font list result.
 
+Options for render --cloud:
+  --workers <n|auto>  1 (default) renders on one GPU. auto measures the film
+                    first and splits it across as many GPUs as stay
+                    efficient; a number splits it into that many.
+  --max-workers <n> Upper bound for auto.
+  --plan            Measure and plan only: prints workers, time and the
+                    estimated cost, renders nothing.
+  --output <file>   Where the video goes (default output/<entry>.mp4).
+  --codec <codec>   h264 (default) or vp9.
+  --quality <q>     very_low, low, high or very_high (default).
+  --select <name>   When the export returns several compositions.
+  --json            Print the final status as JSON.
+  Ctrl-C cancels the render; GPU time already used is charged.
+
 Options for init:
   --name <name>     Package name (default: the folder's name).
   --pm <manager>    npm, pnpm, yarn or bun (default: the one running this).
@@ -968,6 +1118,7 @@ Examples:
   npx framefields init my-film --install
   npx framefields add mouse-pointer focus-zoom
   npx framefields fonts add emoji
+  npx framefields render src/film.ts --cloud --workers auto --plan
 `;
 async function main(argv) {
 	const { values, positionals } = parseArgs({
@@ -992,6 +1143,13 @@ async function main(argv) {
 			output: { type: "string" },
 			timeout: { type: "string" },
 			"warnings-as-errors": { type: "boolean" },
+			cloud: { type: "boolean" },
+			workers: { type: "string" },
+			"max-workers": { type: "string" },
+			plan: { type: "boolean" },
+			codec: { type: "string" },
+			quality: { type: "string" },
+			select: { type: "string" },
 			help: {
 				type: "boolean",
 				short: "h"
@@ -1034,6 +1192,24 @@ async function main(argv) {
 		}
 		return report$1.status === "passed" ? 0 : 1;
 	}
+	if (command === "render") {
+		if (names.length !== 1 || !values.cloud) {
+			process.stderr.write("Usage: framefields render <entry> --cloud [--workers auto] [--plan]\nLocal renders run your project's render script (`npm run render`).\n");
+			return 2;
+		}
+		return runCloudRender({
+			entry: names[0],
+			export: values.export,
+			select: values.select,
+			workers: values.workers,
+			maxWorkers: values["max-workers"],
+			codec: values.codec,
+			quality: values.quality,
+			output: values.output,
+			plan: values.plan,
+			json: values.json
+		}, log);
+	}
 	if (command === "fonts") return fonts(names, cwd, values, log);
 	if (command === "init") {
 		if (names.length > 1) {