reelforge 1.18.2

package/dist/commands/pipelines.js

@@ -0,0 +1,142 @@
+import fs from "node:fs/promises";
+import { post } from "../client.js";
+import { waitForTask } from "../utils/task-waiter.js";
+import { downloadTo } from "../utils/download.js";
+import { print, success, warn } from "../utils/output.js";
+async function submitAndMaybeWait(endpoint, body, common) {
+    const { task_id, status } = await post(endpoint, body);
+    if (common.wait === false) {
+        print({ task_id, status });
+        return;
+    }
+    const t = await waitForTask(task_id, {
+        pollMs: common.pollMs ?? 1500,
+        timeoutMs: common.timeoutMs,
+    });
+    if (t.status !== "completed") {
+        throw new Error(t.error || `Task ended with status ${t.status}`);
+    }
+    const result = t.result;
+    if (common.output && result?.video_url) {
+        await downloadTo(result.video_url, common.output);
+        success(`Saved → ${common.output}`);
+    }
+    print({ task_id: t.id, status: t.status, ...result });
+}
+function commonOptions(cmd) {
+    return cmd
+        .option("--no-wait", "submit and return task_id immediately (do not poll)")
+        .option("-o, --output <file>", "save the final video to this path (only when waiting)")
+        .option("--poll-ms <ms>", "poll interval while waiting", (v) => parseInt(v, 10), 1500)
+        .option("--timeout-ms <ms>", "max wait time before aborting (default unlimited)", (v) => parseInt(v, 10));
+}
+export function registerPipelines(program) {
+    const pl = program
+        .command("pipelines")
+        .alias("pipeline")
+        .description("端到端视频流水线 (与 rf create 等价, 暴露更多底层参数)")
+        .helpOption("-h, --help", "show help");
+    commonOptions(pl
+        .command("standard")
+        .description("Audio-first pipeline: topic|script → master TTS → ASR → scene/subtitle layers → final MP4")
+        .helpOption("-h, --help", "show help")
+        .option("-t, --topic <text>", "video topic (mode=generate). Use @file to read from disk.")
+        .option("--script <text>", "your own master script text (mode=fixed). Use @file to read from disk.")
+        .option("--title <text>", "hard-override video title; LLM will NOT auto-summarize. Useful for compliance-sensitive content. Use @file to read from disk. Pass --title '' (empty) to explicitly suppress title rendering. Omit to keep LLM auto-title.")
+        .option("-d, --duration <sec>", "target video duration in seconds (generate mode; default 45)", (v) => parseInt(v, 10))
+        .option("-p, --pace <pace>", "visual rhythm hint: slow | normal | fast (default normal)")
+        .option("--motion <preset>", "per-scene image animation: off | lite (default) | max")
+        .option("--layout <preset>", "image layout: full (default) | blur-bg | letterbox. See below.")
+        .option("--layout-matte-color <css>", "letterbox matte color (CSS). Ignored unless --layout letterbox. Default: black.")
+        .option("--subtitle-style <preset>", "subtitle visual style: plate (default) | stroke | cinema")
+        .option("--preview-only", "只生成可预览的网页版,不出 MP4(快很多)。后续用 `rf render <task-id>` 再出 MP4。")
+        .option("--image-model <id>", "image model (rx-image-z | rx-image-flux | rx-image-qwen | rx-image-qwen-edit)")
+        .option("--prompt-prefix <text>", "style prefix prepended to every image prompt")
+        .option("--character-ref <urlOrPath>", "main character ref for cross-scene identity lock")
+        .option("--voice-id <id>", "TTS voice id (default 专业解说); see `rf tts voices`")
+        .option("--tts-speed <n>", "speech speed (0.5..2; default 1.0). Only honored by some TTS backends; the default cloud model ignores it.", parseFloat)
+        .option("--video-fps <n>", "output video fps (default 24 — cinema-standard, ~20% faster render vs 30; pass 30 if you want smoother motion)", (v) => parseInt(v, 10))
+        .option("--segment-min-chars <N>", "subtitle SEGMENT (分段) min chars (default 10). Segment = one on-screen subtitle unit, not a visual line.", (v) => parseInt(v, 10))
+        .option("--segment-max-chars <N>", "subtitle SEGMENT (分段) max chars (default 28 ≈ 2 visual lines at 820px safe width). HTML clamps to 2 lines + ellipsis.", (v) => parseInt(v, 10))
+        .addHelpText("after", [
+        "",
+        "Two content modes (exactly one required):",
+        "  generate    AI writes the script.   --topic / -t <text>  + optional --duration -d",
+        "  fixed       You supply the script.  --script <text-or-@file>",
+        "",
+        "Pace (LLM visual rhythm hint):  slow | normal | fast",
+        "Motion (per-scene animation):    off | lite | max",
+        "Subtitle style:                  plate | stroke | cinema",
+        "",
+        "Layout — how the AI image sits in the 1080×1920 canvas:",
+        "  full        image fills the whole canvas (default; punchy, 9:16-native content).",
+        "  blur-bg     image at 1080×1080 centered + same image scaled/blurred as background",
+        "              (小红书 / 抖音 style; best for charts, screenshots, non-9:16 source).",
+        "  letterbox   image at 1080×1080 centered + solid matte top/bottom (cinematic).",
+        "              tweak with --layout-matte-color (default 'black').",
+        "  · Image is generated at the actual on-screen size, so you don't pay for cropped pixels.",
+        "",
+        "Examples:",
+        " rf pipelines standard -t 'why we explore space' -d 60 -o space.mp4",
+        " rf pipelines standard --script @script.txt -p slow --motion max -o out.mp4",
+        " rf pipelines standard -t '财经日报' --layout blur-bg --subtitle-style plate -o out.mp4",
+        " rf pipelines standard -t '纪录片' --layout letterbox --motion max -o film.mp4",
+        "",
+        "Tip: `rf create` is a more ergonomic wrapper around the same endpoint.",
+    ].join("\n"))).action(async (opts) => {
+        const hasTopic = typeof opts.topic === "string" && opts.topic.length > 0;
+        const hasScript = typeof opts.script === "string" && opts.script.length > 0;
+        if (!hasTopic && !hasScript) {
+            throw new Error("either --topic / -t or --script is required");
+        }
+        if (hasTopic && hasScript) {
+            throw new Error("--topic and --script are mutually exclusive");
+        }
+        if (opts.pace && !["slow", "normal", "fast"].includes(opts.pace)) {
+            throw new Error(`--pace must be one of slow|normal|fast (got: ${opts.pace})`);
+        }
+        if (opts.motion && !["off", "lite", "max"].includes(opts.motion)) {
+            throw new Error(`--motion must be one of off|lite|max (got: ${opts.motion})`);
+        }
+        if (opts.layout && !["full", "blur-bg", "letterbox"].includes(opts.layout)) {
+            throw new Error(`--layout must be one of full|blur-bg|letterbox (got: ${opts.layout})`);
+        }
+        if (opts.subtitleStyle && !["plate", "stroke", "cinema"].includes(opts.subtitleStyle)) {
+            throw new Error(`--subtitle-style must be one of plate|stroke|cinema (got: ${opts.subtitleStyle})`);
+        }
+        if (opts.ttsSpeed !== undefined &&
+            (!opts.ttsModel || opts.ttsModel.startsWith("vox/"))) {
+            const m = opts.ttsModel || "default";
+            warn(`--tts-speed=${opts.ttsSpeed} will be ignored by TTS model "${m}". Speed control is only honored by Edge-TTS-backed models.`);
+        }
+        let topic = opts.topic;
+        let script = opts.script;
+        let title = opts.title;
+        if (topic?.startsWith("@"))
+            topic = await fs.readFile(topic.slice(1), "utf-8");
+        if (script?.startsWith("@"))
+            script = await fs.readFile(script.slice(1), "utf-8");
+        if (title?.startsWith("@"))
+            title = await fs.readFile(title.slice(1), "utf-8");
+        await submitAndMaybeWait("/api/v1/pipelines/standard", {
+            topic,
+            script,
+            title,
+            duration: opts.duration,
+            pace: opts.pace,
+            motion: opts.motion,
+            layout: opts.layout,
+            layout_matte_color: opts.layoutMatteColor,
+            subtitle_style: opts.subtitleStyle,
+            image_model: opts.imageModel,
+            prompt_prefix: opts.promptPrefix,
+            character_ref: opts.characterRef,
+            voice_id: opts.voiceId,
+            tts_speed: opts.ttsSpeed,
+            video_fps: opts.videoFps,
+            segment_min_chars: opts.segmentMinChars,
+            segment_max_chars: opts.segmentMaxChars,
+            preview_only: opts.previewOnly,
+        }, { wait: opts.wait, output: opts.output, pollMs: opts.pollMs, timeoutMs: opts.timeoutMs });
+    });
+}

package/dist/commands/platform.js

@@ -0,0 +1,218 @@
+import kleur from "kleur";
+import { isJson, print, table } from "../utils/output.js";
+const CANVAS_W = 1080;
+const CANVAS_H = 1920;
+const IMAGE_SIDE = 1080;
+const SLACK = CANVAS_H - IMAGE_SIDE;
+const PLATFORMS = {
+    douyin: {
+        label: "Douyin (抖音)",
+        top: 250,
+        bottom: 400,
+        left: 150,
+        right: 250,
+        centerMax: 820,
+        reason: "Cover-crop on tall phones cuts ~96-180px per side; status bar ~250px; bottom caption + progress + buttons ~400px; right action-button column ~150px from the visible edge.",
+        recommendedAnchor: 0.40,
+        anchorVariants: [
+            { value: 0.50, case: "短描述 / 无评论弹幕(默认)" },
+            { value: 0.40, case: "长描述,留更多底部 matte(推荐)" },
+            { value: 0.30, case: "很长描述 / 评论弹幕活跃" },
+        ],
+    },
+    tiktok: {
+        label: "TikTok",
+        top: 220,
+        bottom: 380,
+        left: 150,
+        right: 240,
+        centerMax: 820,
+        reason: "Same cover-crop behaviour as Douyin; slightly smaller top tab area and bottom caption.",
+        recommendedAnchor: 0.42,
+        anchorVariants: [
+            { value: 0.50, case: "short caption(default)" },
+            { value: 0.42, case: "long caption / hashtags(recommended)" },
+            { value: 0.30, case: "verbose caption + many hashtags" },
+        ],
+    },
+    wechat: {
+        label: "WeChat Channels (视频号)",
+        top: 200,
+        bottom: 350,
+        left: 120,
+        right: 120,
+        centerMax: 880,
+        reason: "Cover-crop similar; right-side action buttons less obtrusive than 抖音/TikTok, so right padding can be smaller.",
+        recommendedAnchor: 0.45,
+        anchorVariants: [
+            { value: 0.50, case: "短描述(默认)" },
+            { value: 0.45, case: "长描述(推荐)" },
+            { value: 0.30, case: "评论弹幕活跃" },
+        ],
+    },
+};
+const ALIASES = {
+    抖音: "douyin",
+    dy: "douyin",
+    tt: "tiktok",
+    视频号: "wechat",
+    weixin: "wechat",
+    wx: "wechat",
+};
+function resolveKey(input) {
+    const lower = input.toLowerCase();
+    if (PLATFORMS[lower])
+        return lower;
+    if (ALIASES[input])
+        return ALIASES[input];
+    if (ALIASES[lower])
+        return ALIASES[lower];
+    return null;
+}
+function anchorRange(z) {
+    const minAnchor = z.top / SLACK;
+    const maxAnchor = (SLACK - z.bottom) / SLACK;
+    return [Math.max(0, minAnchor), Math.min(1, maxAnchor)];
+}
+function imageYRange(anchor) {
+    const top = Math.round(anchor * SLACK);
+    const bottom = top + IMAGE_SIDE;
+    return { top, bottom, bottomMatte: CANVAS_H - bottom };
+}
+function printOverview() {
+    process.stdout.write(kleur.bold("Reference safe zones for short-video platforms (1080×1920)\n") +
+        kleur.dim("Numbers cover ~90% of mainstream phones — verify on your own target devices.\n\n"));
+    const rows = Object.entries(PLATFORMS).map(([key, z]) => {
+        const [lo, hi] = anchorRange(z);
+        return {
+            platform: key,
+            label: z.label,
+            top: z.top,
+            bottom: z.bottom,
+            left: z.left,
+            right: z.right,
+            "anchor-range": `[${lo.toFixed(2)}, ${hi.toFixed(2)}]`,
+            recommended: z.recommendedAnchor.toFixed(2),
+        };
+    });
+    table(rows);
+    process.stdout.write("\n" +
+        kleur.dim("Detail + anchor variants: ") +
+        kleur.cyan("rf platform <name>") +
+        "\n" +
+        kleur.dim("Aliases: 抖音=douyin · 视频号=wechat · tt=tiktok\n"));
+}
+function printDetail(key, z) {
+    const [lo, hi] = anchorRange(z);
+    const lines = [];
+    lines.push(kleur.bold(`${z.label} — safe zones for 1080×1920 vertical video.`));
+    lines.push("");
+    lines.push(kleur.dim("Why: ") + z.reason);
+    lines.push("");
+    lines.push(kleur.bold("Safe zones (padding from canvas edge, pixels):"));
+    lines.push(`  top              ${String(z.top).padStart(4)}    (status bar / Dynamic Island)`);
+    lines.push(`  bottom           ${String(z.bottom).padStart(4)}    (description + progress + buttons)`);
+    lines.push(`  left             ${String(z.left).padStart(4)}    (cover-crop buffer)`);
+    lines.push(`  right            ${String(z.right).padStart(4)}    (cover-crop + right action column)`);
+    lines.push(`  center-max width ${String(z.centerMax).padStart(4)}    (max safe horizontal width for centred elements)`);
+    lines.push("");
+    lines.push(kleur.bold("For blur-bg / letterbox layouts (--media-anchor-y):"));
+    lines.push(`  Safe range:  ${kleur.cyan(`[${lo.toFixed(2)}, ${hi.toFixed(2)}]`)}` +
+        kleur.dim(`   (image top ≥ ${z.top}, image bottom ≤ ${CANVAS_H - z.bottom})`));
+    lines.push("");
+    lines.push("  Variants:");
+    for (const v of z.anchorVariants) {
+        const r = imageYRange(v.value);
+        const inRange = v.value >= lo && v.value <= hi;
+        const tag = inRange ? kleur.green("✓") : kleur.red("⚠");
+        const recommended = v.value === z.recommendedAnchor ? kleur.cyan(" (recommended)") : "";
+        lines.push(`    ${tag} ${kleur.bold(v.value.toFixed(2))}  ${v.case}${recommended}`);
+        lines.push(kleur.dim(`         image y=${r.top}..${r.bottom},  bottom matte ${r.bottomMatte}px`));
+    }
+    lines.push("");
+    const outsideVariants = z.anchorVariants.filter((v) => v.value < lo || v.value > hi);
+    if (outsideVariants.length) {
+        lines.push(kleur.yellow("⚠ Caveats:"));
+        for (const v of outsideVariants) {
+            if (v.value < lo) {
+                lines.push(kleur.dim(`    anchor=${v.value.toFixed(2)} pushes image top to y=${Math.round(v.value * SLACK)}, below ${z.label} safe top (${z.top}px) — may be clipped by Dynamic Island / status bar on some devices.`));
+            }
+            else {
+                lines.push(kleur.dim(`    anchor=${v.value.toFixed(2)} pushes image bottom to y=${Math.round(v.value * SLACK) + IMAGE_SIDE}, beyond ${z.label} safe bottom (${CANVAS_H - z.bottom}) — content may be covered by platform UI.`));
+            }
+        }
+        lines.push("");
+    }
+    lines.push(kleur.bold("Quick start:"));
+    lines.push("  " +
+        kleur.cyan(`rf create "..." --layout blur-bg --media-anchor-y ${z.recommendedAnchor.toFixed(2)}`));
+    lines.push("");
+    lines.push(kleur.dim(`Note: 'full' layout fills the canvas and ignores --media-anchor-y. For platforms with heavy bottom UI like ${z.label}, prefer blur-bg or letterbox so you have a matte band to lift the image into.`));
+    process.stdout.write(lines.join("\n") + "\n");
+}
+export function registerPlatform(program) {
+    program
+        .command("platform [name]")
+        .description("查询竖屏平台 (抖音 / TikTok / 视频号) 的安全区参数与推荐 --media-anchor-y 值")
+        .helpOption("-h, --help", "show help")
+        .addHelpText("after", [
+        "",
+        "Why this exists:",
+        "  Different short-video apps overlay their own UI (status bar, caption,",
+        "  progress bar, action buttons) on top of your video. The",
+        "  --media-anchor-y knob lifts the central 1080×1080 image up or down",
+        "  inside the 1920-high canvas to keep important content out of those",
+        "  UI zones. This command tells you what anchor value to dial for each",
+        "  platform.",
+        "",
+        "Examples:",
+        "  rf platform                 # overview table for all platforms",
+        "  rf platform 抖音             # detail (alias of `douyin`)",
+        "  rf platform douyin",
+        "  rf platform tiktok",
+        "  rf platform wechat          # 视频号",
+        "  rf platform douyin --json   # machine-readable",
+    ].join("\n"))
+        .action((name) => {
+        if (isJson()) {
+            if (name) {
+                const key = resolveKey(name);
+                if (!key) {
+                    print({ ok: false, error: `unknown platform: ${name}`, known: Object.keys(PLATFORMS) });
+                    process.exit(1);
+                }
+                const z = PLATFORMS[key];
+                const [lo, hi] = anchorRange(z);
+                print({
+                    ok: true,
+                    platform: key,
+                    ...z,
+                    anchorRange: { min: lo, max: hi },
+                    canvas: { width: CANVAS_W, height: CANVAS_H, imageSide: IMAGE_SIDE },
+                });
+            }
+            else {
+                const out = {};
+                for (const [k, z] of Object.entries(PLATFORMS)) {
+                    const [lo, hi] = anchorRange(z);
+                    out[k] = { ...z, anchorRange: { min: lo, max: hi } };
+                }
+                print({ ok: true, canvas: { width: CANVAS_W, height: CANVAS_H, imageSide: IMAGE_SIDE }, platforms: out });
+            }
+            return;
+        }
+        if (name) {
+            const key = resolveKey(name);
+            if (!key) {
+                process.stderr.write(kleur.red(`✗ unknown platform: ${name}\n`) +
+                    `  known: ${Object.keys(PLATFORMS).join(", ")}\n` +
+                    `  aliases: ${Object.keys(ALIASES).join(", ")}\n`);
+                process.exit(1);
+            }
+            printDetail(key, PLATFORMS[key]);
+        }
+        else {
+            printOverview();
+        }
+    });
+}

package/dist/commands/regen.js

@@ -0,0 +1,134 @@
+import { post, get, getServer } from "../client.js";
+import { waitForTask } from "../utils/task-waiter.js";
+import { downloadTo } from "../utils/download.js";
+import { info, print, success, warn } from "../utils/output.js";
+const VALID_KINDS = [
+    "image",
+    "chart-bar",
+    "chart-line",
+    "chart-donut",
+    "kpi-grid",
+    "stat-counter",
+    "comparison-vs",
+    "tweet-card",
+    "ios-messages",
+    "notification",
+    "quote-card",
+    "terminal",
+    "code-editor",
+    "kinetic-text",
+    "bullet-list",
+];
+export function registerRegen(program) {
+    program
+        .command("regen")
+        .description("重生成已有任务里某个 scene 的画面 (音频和时间轴保持不变)")
+        .helpOption("-h, --help", "show help")
+        .argument("<task-id>", "task id from `rf create` or `rf create --preview-only`")
+        .option("--scene <n>", "1-based scene index to regenerate (REQUIRED)", (v) => parseInt(v, 10))
+        .option("--kind <kind>", `force a specific visual kind (one of: ${VALID_KINDS.join(", ")})`, (v) => {
+        if (!VALID_KINDS.includes(v)) {
+            throw new Error(`--kind must be one of: ${VALID_KINDS.join(", ")} (got "${v}")`);
+        }
+        return v;
+    })
+        .option("--hint <text>", "natural-language guidance to steer the regen (e.g. \"数字要大一点 / 用左右两栏不是上下\")")
+        .option("-o, --output <file>", "save the re-rendered MP4 to this exact path (completed-task path only)")
+        .option("--no-download", "skip downloading the re-rendered MP4 (completed-task path only)")
+        .option("--no-wait", "submit and return job id immediately (do not poll)")
+        .option("--poll-ms <ms>", "poll interval while waiting", (v) => parseInt(v, 10), 1500)
+        .option("--timeout-ms <ms>", "max wait time (default: unlimited)", (v) => parseInt(v, 10))
+        .addHelpText("after", [
+        "",
+        "What happens:",
+        "  • LLM picks a fresh { kind, spec } for the target scene only.",
+        "  • Image scenes also re-call image gen (~5-15s, ~$0.003).",
+        "  • Composition is rebuilt — opens in /preview/<task-id> after refresh.",
+        "  • If the task was already MP4-rendered, MP4 is re-rendered too.",
+        "",
+        "Behavior matrix:",
+        "  preview-only task → composition only,   ~5-30s,  no MP4 in response",
+        "  completed task    → composition + MP4,  ~45-90s, MP4 downloaded",
+        "",
+        "Examples:",
+        " rf regen 2026-05-28T12-00-00-000Z_abcd --scene 3",
+        " rf regen 2026-05-28T12-00-00-000Z_abcd --scene 3 --kind kinetic-text",
+        " rf regen 2026-05-28T12-00-00-000Z_abcd --scene 5 --kind chart-bar -o out.mp4",
+    ].join("\n"))
+        .action(async (taskId, opts) => {
+        if (opts.scene === undefined) {
+            throw new Error("--scene <n> is required (1-based scene index)");
+        }
+        if (!Number.isFinite(opts.scene) || opts.scene < 1) {
+            throw new Error("--scene must be a positive integer (1-based)");
+        }
+        info(`Regenerating scene ${opts.scene} on task ${taskId}` +
+            (opts.kind ? ` (kind=${opts.kind})` : " (free pick)") +
+            "…");
+        const body = { scene_index: opts.scene };
+        if (opts.kind)
+            body.kind = opts.kind;
+        if (opts.hint)
+            body.hint = opts.hint;
+        const submitted = await post(`/api/v1/pipelines/standard/${encodeURIComponent(taskId)}/regenerate-scene`, body);
+        if (opts.wait === false) {
+            print({ task_id: submitted.task_id, status: submitted.status });
+            return;
+        }
+        info(`Regen job: ${submitted.task_id} — waiting…`);
+        const t = await waitForTask(submitted.task_id, {
+            pollMs: opts.pollMs,
+            timeoutMs: opts.timeoutMs,
+        });
+        if (t.status !== "completed") {
+            throw new Error(t.error || `Regen ended with status ${t.status}`);
+        }
+        const result = t.result;
+        const newKind = result?.new_kind ?? "(unknown)";
+        const rerendered = !!result?.rerendered_mp4;
+        success(`Scene ${opts.scene} → kind=${newKind}, ` +
+            (rerendered ? "MP4 re-rendered" : "composition only"));
+        if (result?.price_usd !== undefined) {
+            info(`Cost: $${result.price_usd.toFixed(4)}`);
+        }
+        const serverBase = getServer().replace(/\/+$/, "");
+        info(`预览页 (刷新即可看到新画面): ${serverBase}/preview/${taskId}`);
+        if (rerendered && result?.video_url) {
+            const stdoutIsPipe = !process.stdout.isTTY;
+            const skipDownload = opts.download === false || (stdoutIsPipe && !opts.output);
+            let savedPath = opts.output;
+            if (!savedPath && !skipDownload) {
+                let title;
+                try {
+                    const list = await get("/api/v1/history?limit=200");
+                    title = list.items?.find((it) => it.task_id === taskId)?.title;
+                }
+                catch {
+                }
+                const safeTitle = (title || "video")
+                    .replace(/[\\/:*?"<>|]/g, "_")
+                    .slice(0, 80);
+                savedPath = `./${safeTitle}-${taskId}.mp4`;
+            }
+            if (savedPath) {
+                await downloadTo(result.video_url, savedPath);
+                success(`MP4 saved → ${savedPath}`);
+            }
+        }
+        else if (!rerendered) {
+            warn("Task is in preview state — no MP4 produced. Run `rf render " +
+                taskId +
+                "` when you're happy with the preview.");
+        }
+        print({
+            task_id: taskId,
+            scene_index: opts.scene,
+            new_kind: newKind,
+            rerendered_mp4: rerendered,
+            video_url: result?.video_url ?? null,
+            file_size: result?.file_size ?? null,
+            price_usd: result?.price_usd ?? null,
+            preview_urls: result?.preview_urls,
+        });
+    });
+}

package/dist/commands/render.js

@@ -0,0 +1,82 @@
+import { post, get, getServer } from "../client.js";
+import { waitForTask } from "../utils/task-waiter.js";
+import { downloadTo } from "../utils/download.js";
+import { humanDuration, info, print, success } from "../utils/output.js";
+export function registerRender(program) {
+    program
+        .command("render")
+        .description("把先前已生成预览的任务最终渲染成 MP4")
+        .helpOption("-h, --help", "show help")
+        .argument("<task-id>", "task id from `rf create --preview-only`")
+        .option("-o, --output <file>", "save the MP4 to this exact path (must include filename, e.g. ./out/x.mp4)")
+        .option("--no-download", "do not save the video locally — just print JSON with video_url")
+        .option("--fps <n>", "override FPS for this render (default: storyboard.config.videoFps)", (v) => parseInt(v, 10))
+        .option("--no-wait", "submit and return task_id immediately (do not poll)")
+        .option("--poll-ms <ms>", "poll interval while waiting", (v) => parseInt(v, 10), 1500)
+        .option("--timeout-ms <ms>", "max wait time before aborting (default unlimited)", (v) => parseInt(v, 10))
+        .addHelpText("after", [
+        "",
+        "Two-step workflow:",
+        '  1. rf create "topic" --preview-only       # builds composition, opens browser preview',
+        "  2. rf render <task-id>                    # produces the MP4",
+        "",
+        "Notes:",
+        "  • The task must already exist and have a preview-able composition",
+        "    built (via `rf create --preview-only`).",
+        "  • This re-renders from the existing composition only — it does NOT",
+        "    re-run scene-plan / TTS / ASR / image generation.",
+        "  • If you've already rendered once, calling render again will overwrite.",
+        "",
+        "Examples:",
+        " rf render 2026-05-28T12-00-00-000Z_abcd",
+        " rf render 2026-05-28T12-00-00-000Z_abcd -o ./final/space.mp4",
+        " rf render 2026-05-28T12-00-00-000Z_abcd --fps 60",
+    ].join("\n"))
+        .action(async (taskId, opts) => {
+        info(`Submitting render for ${taskId}…`);
+        const body = {};
+        if (opts.fps !== undefined)
+            body.fps = opts.fps;
+        const submitted = await post(`/api/v1/tasks/${encodeURIComponent(taskId)}/render`, body);
+        if (opts.wait === false) {
+            print({ task_id: submitted.task_id, status: submitted.status });
+            return;
+        }
+        info(`Render task: ${submitted.task_id} — waiting for completion…`);
+        const t = await waitForTask(submitted.task_id, {
+            pollMs: opts.pollMs,
+            timeoutMs: opts.timeoutMs,
+        });
+        if (t.status !== "completed") {
+            throw new Error(t.error || `Render ended with status ${t.status}`);
+        }
+        const result = t.result;
+        if (result?.video_url) {
+            const stdoutIsPipe = !process.stdout.isTTY;
+            const skipDownload = !!opts.noDownload || (stdoutIsPipe && !opts.output);
+            let savedPath = opts.output;
+            if (!savedPath && !skipDownload) {
+                let title;
+                try {
+                    const list = await get("/api/v1/history?limit=200");
+                    title = list.items?.find((it) => it.task_id === taskId)?.title;
+                }
+                catch { }
+                const safeTitle = (title || "video").replace(/[\\/:*?"<>|]/g, "_").slice(0, 80);
+                savedPath = `./${safeTitle}-${taskId}.mp4`;
+            }
+            if (savedPath) {
+                await downloadTo(result.video_url, savedPath);
+                success(`Saved → ${savedPath}`);
+            }
+        }
+        if (result?.file_size) {
+            info(`MP4 size: ${(result.file_size / 1024 / 1024).toFixed(1)} MB`);
+        }
+        void humanDuration;
+        const serverBase = getServer().replace(/\/+$/, "");
+        info(`预览页 (全功能): ${serverBase}/preview/${taskId}`);
+        info(`纯播放器:    ${serverBase}/preview/${taskId}/player`);
+        print({ task_id: taskId, ...result });
+    });
+}