@officexapp/vidfarm-devcli 0.21.14 → 0.21.16

package/dist/src/cli.js

@@ -27,7 +27,7 @@ import { initTelemetry, reportCliCrash } from "./devcli/telemetry.js";
 import { resolveLocalDataDir, localBackendAvailable, LocalModeUnavailableError, localApiRequest } from "./devcli/local-backend.js";
 import { startLocalFrontendServer, serveShellsPresent } from "./devcli/local-frontend-server.js";
 import { readStoredAuth, writeStoredAuth, clearStoredAuth, hostsMatch } from "./devcli/auth-store.js";
-import { COST_MODES, CostModeBlockedError, assertBilledAllowed, clearStoredCostMode, costModeExplainer, costModeSummaryLine, normalizeCostMode, resolveCostMode, writeStoredCostMode, COST_MODE_BLURB } from "./devcli/cost-mode.js";
+import { CostModeBlockedError, assertBilledAllowed, clearStoredCostMode, costModeExplainer, costModeSummaryLine, normalizeCostMode, resolveCostMode, writeStoredCostMode, COST_MODE_BLURB, COST_MODE_DISPLAY_LIST, costModeDisplayName } from "./devcli/cost-mode.js";
 // vidfarm-devcli — command-line bridge for the Vidfarm video studio. The
 // `serve` command boots the FULL editor locally (single origin, disk-backed
 // records + storage) so power users edit compositions on disk while a browser
@@ -71,7 +71,7 @@ Account (persisted login — points the CLI + \`serve\` at cloud prod):
   logout                    Clear the persisted credential
   whoami                    Show the logged-in account, host, plan, and cost mode
   cost-mode [mode]          Show or set the money-saving preference all billed
-                            commands respect: minimize | hybrid | pure-ai.
+                            commands respect: minimize | hybrid | rich-ai.
                             No arg = show current + explain the three simply.
                             --clear forgets it · --note "<why>" annotates the save.
                             Override per-run with --cost-mode <m> / VIDFARM_COST_MODE;
@@ -632,10 +632,10 @@ Cost spectrum (default to the cheapest approach that works; see SKILL.director.m
   $10+       Heavy AI generation (many/long AI clips, custom characters).
   Notes: image gen is cheap (use freely); AI VIDEO gen is expensive (ask the user
   first). Decompose is a one-time ~$0.10 — or skip it by forking a decomposed template.
-  Set 'vidfarm cost-mode <minimize|hybrid|pure-ai>' once and every billed command
+  Set 'vidfarm cost-mode <minimize|hybrid|rich-ai>' once and every billed command
   (generate, music, decompose, cloud render/TTS/STT/greenscreen, create, replicate)
   respects it: minimize refuses billed spend without --yes and points you at the free
-  local path; hybrid/pure-ai run but print each op's cost. FREE local engines never gate
+  local path; hybrid/rich-ai run but print each op's cost. FREE local engines never gate
   (local render, tts --engine local, stt --engine whisper, remove-greenscreen --local).
 
 Escape hatch — call ANY route directly:
@@ -2974,11 +2974,218 @@ async function runForkCommand(argv) {
     const tId = result.json?.template_id ?? templateId;
     emitResult(result, ctx.json, [["Open editor ", forkId ? editorFrontendUrl(ctx.host, tId, forkId) : null]]);
 }
+// A weak, UNLICENSED fallback guide for free-tier local decompose. It deliberately
+// omits Vidfarm's proprietary methodology (that lives in the paid HARNESS.md) and
+// tells the agent to produce a best-effort decomposition with open reasoning only.
+const WEAK_FREE_DECOMPOSE_GUIDE = `# Local Decompose — Free Tier (weak, unlicensed)
+
+You are on Vidfarm's FREE tier. This is a stripped-down, best-effort decompose guide.
+It does NOT include Vidfarm's licensed decomposition methodology (viral-DNA extraction,
+editor/replication harnesses, the generative character-card→storyboard→animate
+workflow). Expect noticeably weaker results than Vidfarm cloud decompose, and expect
+to burn more of your own desktop-agent tokens iterating to something usable.
+
+Do your honest best from first principles: watch the source, split it into scenes with
+timestamps, transcribe any on-screen text into captions, and write a short summary.
+Fill \`smart-decompose.template.json\` as far as you can — leave the harness/viral-DNA
+sub-objects mostly empty; you are not licensed to Vidfarm's method for those.
+
+To get the FULL licensed harness (much better results, runs on your own tokens, and
+lets you sync the decomposition back to the shared library so others reuse it free),
+subscribe to Vidfarm and re-run \`vidfarm decompose <forkId> --local\`.
+`;
+// The result skeleton the desktop agent fills in and drops at smart-decompose.json.
+// Kept intentionally sparse — the field docs live in HARNESS.md (paid) or the weak
+// guide (free); this is just the shape the sync endpoint coerces.
+const LOCAL_DECOMPOSE_RESULT_TEMPLATE = JSON.stringify({
+    summary: "",
+    durationSeconds: 0,
+    width: 720,
+    height: 1280,
+    scenes: [{ slug: "scene_1", start: 0, duration: 0, label: "", description: "", viral_note: "" }],
+    captions: [{ slug: "caption_1", text: "", start: 0, duration: 0, x: 8, y: 68, width: 84, height: 12, font_size: 0, color: "#ffffff", background: "#000000", background_style: "highlight-translucent", font_family: "", font_weight: 700, viral_note: "" }],
+    viralDna: {},
+    editorHarness: {},
+    replicationHarness: { generative_workflow: { applies: false, steps: [], character_card: {}, storyboard: {}, animation: { default_motion: "ken_burns_static", scenes: [] } } },
+    transcript: null
+}, null, 2);
+function buildLocalDecomposeTask(input) {
+    const syncLine = input.paid
+        ? `4. Sync it back to cloud (shared library): \`vidfarm decompose ${input.forkId} --local --sync --dir ${input.dir}\``
+        : `4. (Sync to cloud is PAID-only. Your free decomposition stays local. Subscribe to contribute it back.)`;
+    return `# Decompose task — fork ${input.forkId}
+
+You are the desktop AI agent. Run this decompose on your OWN tokens.
+
+Source video: ${input.sourceUrl || "(unknown — pass --source <url> or read it from cloud-video-context.json)"}
+${input.contextNote ? `\n${input.contextNote}\n` : ""}
+Steps:
+1. Read ${input.harnessSaved ? "**HARNESS.md** in this folder — it is Vidfarm's LICENSED decomposition methodology (paid). Follow it exactly, including the character-card → storyboard → (ken-burns vs AI-video) generative workflow detection." : "**HARNESS.md** in this folder (free-tier weak guide) and do your honest best."}
+2. Analyze the source video (sample frames, read on-screen text, transcribe audio if any).
+3. Produce **smart-decompose.json** in this folder, matching the shape in smart-decompose.template.json${input.harnessSaved ? " and every rule in HARNESS.md" : ""}. Fill scenes + captions with real timestamps; ${input.harnessSaved ? "fully populate viralDna, editorHarness, and replicationHarness (including replicationHarness.generative_workflow when the template fits the image→video pipeline)." : "fill what you can."}
+${syncLine}
+
+Do NOT invent footage or audio you cannot see/hear. Ground every scene and caption on a real moment.
+`;
+}
+// Resolve the on-disk staging folder for a local decompose (next to the CWD so the
+// desktop agent sees the harness, the task, and drops its smart-decompose.json here).
+function resolveLocalDecomposeDir(forkId, dirFlag) {
+    const raw = typeof dirFlag === "string" && dirFlag.trim() ? dirFlag.trim() : `vidfarm-decompose-${forkId}`;
+    return path.resolve(process.cwd(), raw);
+}
+// Read the caller's paid/subscription status from the self endpoint. Used to gate
+// the licensed harness fetch and to warn free users before a weak local run.
+async function fetchCustomerPaidStatus(ctx) {
+    try {
+        const res = await apiRequest({ method: "GET", host: ctx.host, path: "/api/v1/user/me", auth: ctx.auth });
+        if (!res.ok || !res.json || typeof res.json !== "object")
+            return { ok: false, paid: false, email: null, planTier: null };
+        const customer = res.json.customer ?? {};
+        return {
+            ok: true,
+            paid: Boolean(customer.isPaidPlan),
+            email: typeof customer.email === "string" ? customer.email : null,
+            planTier: typeof customer.planTier === "string" ? customer.planTier : null
+        };
+    }
+    catch {
+        return { ok: false, paid: false, email: null, planTier: null };
+    }
+}
+// Local decompose — the paid-vs-free, prepare-vs-sync workflow behind
+// `vidfarm decompose <forkId> --local`. PREPARE stages the harness + task + result
+// skeleton for the desktop agent; SYNC (--sync) posts the agent's produced
+// smart-decompose.json back to cloud (paid-only). Free users get a weak, unlicensed,
+// local-only run with an upgrade nudge — so the ethics/licensing live in the tool,
+// not just the doc, and a customer's agent complies by default.
+async function runLocalDecomposeCommand(forkId, values) {
+    const ctx = commonContext(values);
+    const dir = resolveLocalDecomposeDir(forkId, values.dir);
+    const resultPath = path.join(dir, "smart-decompose.json");
+    // -------- SYNC phase: push the agent's local result back to the shared library.
+    if (values.sync) {
+        if (!existsSync(resultPath)) {
+            throw new Error(`No decomposition to sync at ${resultPath}. Run \`vidfarm decompose ${forkId} --local\` first, have your agent produce smart-decompose.json, then re-run with --sync.`);
+        }
+        let result;
+        try {
+            result = JSON.parse(readFileSync(resultPath, "utf8"));
+        }
+        catch (e) {
+            throw new Error(`smart-decompose.json is not valid JSON: ${e instanceof Error ? e.message : String(e)}`);
+        }
+        const res = await apiRequest({
+            method: "POST",
+            host: ctx.host,
+            path: `/api/v1/compositions/${encodeURIComponent(forkId)}/auto-decompose/sync`,
+            auth: ctx.auth,
+            body: {
+                result,
+                source_url: typeof values.source === "string" && values.source.trim() ? values.source.trim() : undefined,
+                provider: "local",
+                model: process.env.VIDFARM_LOCAL_DECOMPOSE_MODEL || "desktop-agent"
+            }
+        });
+        if (res.status === 402) {
+            throw new Error("Syncing a local decompose to cloud requires a PAID Vidfarm subscription — the shared template library is a paid, licensed asset. Subscribe to contribute this back, or keep the decomposition local-only.");
+        }
+        assertApiOk(res, "decompose --local --sync");
+        if (ctx.json) {
+            emitResult(res, true);
+            return;
+        }
+        const j = (res.json ?? {});
+        console.log(`${GREEN}Synced decomposition to cloud.${RESET} fork=${j.fork_id ?? forkId} scenes=${j.scene_count ?? "?"} captions=${j.caption_count ?? "?"}${j.generative_workflow_applies ? `  ${BOLD}generative_workflow: applies${RESET}` : ""}`);
+        console.log(`${DIM}The next creator who forks this template gets your decomposition for free.${RESET}`);
+        return;
+    }
+    // -------- PREPARE phase: stage inputs for the desktop agent.
+    const paid = await fetchCustomerPaidStatus(ctx);
+    mkdirSync(dir, { recursive: true });
+    // Pull any existing cloud grounding for the fork (source URL + prior context).
+    let sourceUrl = typeof values.source === "string" && values.source.trim() ? values.source.trim() : "";
+    let contextNote = "";
+    try {
+        const ctxRes = await apiRequest({ method: "GET", host: ctx.host, path: `/api/v1/compositions/${encodeURIComponent(forkId)}/video-context.json`, auth: ctx.auth });
+        if (ctxRes.ok && ctxRes.json && typeof ctxRes.json === "object") {
+            writeFileSync(path.join(dir, "cloud-video-context.json"), JSON.stringify(ctxRes.json, null, 2));
+            const scloud = ctxRes.json.source_url;
+            if (!sourceUrl && typeof scloud === "string" && scloud.trim())
+                sourceUrl = scloud.trim();
+            contextNote = "A prior cloud context was saved to cloud-video-context.json — reuse it where useful.";
+        }
+    }
+    catch {
+        /* fork may not be decomposed yet — fine */
+    }
+    // Fetch the LICENSED harness (paid only). Free users get the weak, unlicensed guide.
+    let harnessSaved = false;
+    if (paid.paid) {
+        try {
+            const hRes = await apiRequest({ method: "GET", host: ctx.host, path: "/api/v1/decompose/harness.md", auth: ctx.auth });
+            if (hRes.ok && typeof hRes.text === "string" && hRes.text.trim().length > 0) {
+                writeFileSync(path.join(dir, "HARNESS.md"), hRes.text);
+                harnessSaved = true;
+            }
+        }
+        catch {
+            /* fall through to the weak guide */
+        }
+    }
+    if (!harnessSaved) {
+        writeFileSync(path.join(dir, "HARNESS.md"), WEAK_FREE_DECOMPOSE_GUIDE);
+    }
+    writeFileSync(path.join(dir, "smart-decompose.template.json"), LOCAL_DECOMPOSE_RESULT_TEMPLATE);
+    writeFileSync(path.join(dir, "DECOMPOSE_TASK.md"), buildLocalDecomposeTask({ forkId, dir, sourceUrl, paid: paid.paid, harnessSaved, contextNote }));
+    if (ctx.json) {
+        emitResult({
+            status: 200,
+            ok: true,
+            json: {
+                ok: true,
+                prepared: true,
+                dir,
+                paid: paid.paid,
+                harness: harnessSaved ? "licensed" : "weak-free",
+                source_url: sourceUrl || null,
+                task: path.join(dir, "DECOMPOSE_TASK.md"),
+                result_expected: resultPath,
+                sync_cmd: paid.paid ? `vidfarm decompose ${forkId} --local --sync --dir ${dir}` : null
+            },
+            text: ""
+        }, true);
+        return;
+    }
+    if (paid.paid) {
+        console.log(`${GREEN}Local decompose prepared (PAID — latest licensed harness fetched).${RESET}`);
+    }
+    else {
+        console.log(`${RED}Local decompose prepared (FREE tier — WEAK, UNLICENSED).${RESET}`);
+        console.log(`${DIM}Heads up: the free local decompose uses a stripped-down method and your OWN desktop-agent tokens. It typically produces WORSE viral-DNA / harness quality than Vidfarm cloud AND burns more tokens iterating. Cloud decompose (\`vidfarm decompose ${forkId}\`) is ~$0.10 one-time, runs Vidfarm's best models, and its result is shared free with the network. You also CANNOT sync a free local decompose back to cloud.${RESET}`);
+        console.log(`${DIM}Subscribe to run the licensed harness locally on your own tokens AND contribute your decompositions back to the shared library.${RESET}`);
+    }
+    console.log("");
+    console.log(`  1. Open ${BOLD}${path.join(dir, "DECOMPOSE_TASK.md")}${RESET} and follow it (your desktop AI agent does the analysis).`);
+    console.log(`  2. Your agent writes ${BOLD}${resultPath}${RESET} matching smart-decompose.template.json${harnessSaved ? " + HARNESS.md" : ""}.`);
+    if (paid.paid)
+        console.log(`  3. Sync back:  ${BOLD}vidfarm decompose ${forkId} --local --sync --dir ${dir}${RESET}`);
+    else
+        console.log(`  3. ${DIM}(Sync to cloud is paid-only — subscribe to contribute this back.)${RESET}`);
+}
 async function runDecomposeCommand(argv) {
-    const parsed = parseArgs({ args: argv, allowPositionals: true, options: { ...commonOptions(), mode: { type: "string", default: "smart" }, prompt: { type: "string" } } });
+    const parsed = parseArgs({ args: argv, allowPositionals: true, options: { ...commonOptions(), mode: { type: "string", default: "smart" }, prompt: { type: "string" }, sync: { type: "boolean", default: false }, dir: { type: "string" }, source: { type: "string" } } });
     const forkId = parsed.positionals[0];
     if (!forkId)
         throw new Error("decompose requires a fork id.");
+    // `--local` runs decompose on the user's OWN desktop AI-agent tokens instead of
+    // billing Vidfarm cloud. Paid users pull the latest licensed harness + can sync
+    // the result back to the shared library; free users get a weaker, unlicensed,
+    // local-only path (with an upgrade nudge). See runLocalDecomposeCommand.
+    if (parsed.values.local) {
+        await runLocalDecomposeCommand(forkId, parsed.values);
+        return;
+    }
     const ctx = commonContext(parsed.values);
     guardBilled(ctx, {
         label: "AI decompose (scene split + annotations)",
@@ -6026,12 +6233,12 @@ async function runWhoamiCommand(argv) {
         console.log(`${GREEN}${BOLD}${who}${RESET} → ${ctx.host}`);
         console.log(`  plan        ${customer.isPaidPlan ? `${GREEN}paid${plan}${RESET}` : `${DIM}free${plan}${RESET}`}`);
         console.log(`  credential  ${DIM}${stored ? "persisted login (vidfarm login)" : "env/flag key — not persisted (run vidfarm login to persist)"}${RESET}`);
-        console.log(`  ${costModeSummaryLine(ctx.costMode).replace("cost mode: ", "cost mode   ")}${!ctx.costMode.isSet ? `  ${DIM}(set with: vidfarm cost-mode <minimize|hybrid|pure-ai>)${RESET}` : ""}`);
+        console.log(`  ${costModeSummaryLine(ctx.costMode).replace("cost mode: ", "cost mode   ")}${!ctx.costMode.isSet ? `  ${DIM}(set with: vidfarm cost-mode <minimize|hybrid|rich-ai>)${RESET}` : ""}`);
         return;
     }
     emitResult(result, ctx.json);
 }
-// `vidfarm cost-mode [minimize|hybrid|pure-ai]` — show or set the money-saving
+// `vidfarm cost-mode [minimize|hybrid|rich-ai]` — show or set the money-saving
 // preference every billed command respects. No arg = show current + explain the
 // three simply so an agent can relay them to the user (and be reminded to ask
 // about saving the choice into whatever agent memory it has). `--clear` forgets it.
@@ -6054,14 +6261,14 @@ async function runCostModeCommand(argv) {
     if (requested) {
         const mode = normalizeCostMode(requested);
         if (!mode) {
-            throw new Error(`Unknown cost mode "${requested}". Choose one of: ${COST_MODES.join(", ")}.`);
+            throw new Error(`Unknown cost mode "${requested}". Choose one of: ${COST_MODE_DISPLAY_LIST.join(", ")}.`);
         }
         // Stamp time on the host so this stays deterministic-friendly for scripts.
         const savedAt = new Date().toISOString();
         const file = writeStoredCostMode(mode, savedAt, parsed.values.note ?? null, home);
         if (json)
             return printJson({ ok: true, cost_mode: mode, saved_at: savedAt, file });
-        console.log(`${GREEN}${BOLD}Cost mode: ${mode}${RESET}`);
+        console.log(`${GREEN}${BOLD}Cost mode: ${costModeDisplayName(mode)}${RESET}`);
         console.log(`${DIM}${COST_MODE_BLURB[mode]}${RESET}`);
         console.log(`${DIM}Saved to ${file} (every billed command now respects it).${RESET}`);
         console.log(`${DIM}Tip: if the user wants this remembered across sessions, offer to also save it to your` +
@@ -6077,7 +6284,7 @@ async function runCostModeCommand(argv) {
     console.log("");
     console.log(costModeExplainer());
     console.log("");
-    console.log(`${DIM}Set it: ${BOLD}vidfarm cost-mode <minimize|hybrid|pure-ai>${RESET}`);
+    console.log(`${DIM}Set it: ${BOLD}vidfarm cost-mode <minimize|hybrid|rich-ai>${RESET}`);
     console.log(`${DIM}Forget it: vidfarm cost-mode --clear · override per-run: --cost-mode <m> or VIDFARM_COST_MODE.${RESET}`);
     if (!resolved.isSet) {
         console.log(`${DIM}Nothing saved yet — ask the user which one they want before spending AI credits.${RESET}`);

package/dist/src/devcli/cost-mode.js

@@ -10,7 +10,7 @@
 //   - hybrid   : free where it's free, spend on AI only where it clearly wins.
 //                (default recommendation.) Billed ops run but print a cost line.
 //   - pure-ai  : best-quality; AI image/video/voice/music used freely. Billed
-//                ops run; cost is still surfaced.
+//                ops run; cost is still surfaced. Shown to humans as "rich-ai".
 //
 // This module lives in the CLI's static import closure and is BACKEND-FREE (only
 // Node built-ins) so it ships in the public cloud-only package.
@@ -33,10 +33,25 @@ export function normalizeCostMode(raw) {
         return "minimize";
     if (["hybrid", "mixed", "balanced", "smart", "default"].includes(v))
         return "hybrid";
-    if (["pure-ai", "pureai", "ai", "best", "best-quality", "premium", "max"].includes(v))
+    if (["pure-ai", "pureai", "rich-ai", "richai", "rich", "ai", "best", "best-quality", "premium", "max"].includes(v))
         return "pure-ai";
     return null;
 }
+/**
+ * Human-facing NAME for a mode. The canonical stored slug for best-quality stays
+ * `pure-ai` (so saved cost-mode.json, --cost-mode flags, and VIDFARM_COST_MODE
+ * keep resolving), but users see and can type "rich-ai".
+ */
+export const COST_MODE_DISPLAY = {
+    minimize: "minimize",
+    hybrid: "hybrid",
+    "pure-ai": "rich-ai"
+};
+/** The three modes as users see them, e.g. for "<minimize|hybrid|rich-ai>". */
+export const COST_MODE_DISPLAY_LIST = COST_MODES.map((m) => COST_MODE_DISPLAY[m]);
+export function costModeDisplayName(mode) {
+    return COST_MODE_DISPLAY[mode];
+}
 /** Read the persisted cost mode, or null if absent/unparseable. */
 export function readStoredCostMode(home) {
     try {
@@ -96,13 +111,13 @@ export const COST_MODE_BLURB = {
     hybrid: "Hybrid (recommended) — free where it's free, spend AI credits only where they " +
         "clearly win (a hero shot, a voice you can't fake locally). Billed ops run but " +
         "each prints its cost so nothing is a surprise.",
-    "pure-ai": "Pure AI — best quality; AI image/video/voice/music used freely. Billed ops run " +
+    "pure-ai": "Rich AI — best quality; AI image/video/voice/music used freely. Billed ops run " +
         "without gating; cost is still shown."
 };
 /** One short human line summarizing the active mode. */
 export function costModeSummaryLine(resolved) {
     const setNote = resolved.isSet ? `set via ${resolved.source}` : "NOT set — assuming hybrid";
-    return `cost mode: ${resolved.mode} (${setNote})`;
+    return `cost mode: ${costModeDisplayName(resolved.mode)} (${setNote})`;
 }
 /** The 3-line "explain it simply" block an agent should relay to the user. */
 export function costModeExplainer() {
@@ -110,7 +125,7 @@ export function costModeExplainer() {
         "How much do you want Vidfarm to spend on AI credits?",
         "  • minimize — cheapest: free local compute + free stock media, no surprise AI spend.",
         "  • hybrid   — recommended: free where free, pay AI only where it clearly wins.",
-        "  • pure-ai  — best quality: use AI image/video/voice/music freely.",
+        "  • rich-ai  — best quality: use AI image/video/voice/music freely.",
         "Tip: before paying to generate music/SFX/images/video, try the free stock catalog —",
         '  vidfarm media search "<meaning>" --type bgm|sfx|image|vector|icon|video.',
         "  Check the keyless sources first — Openverse (CC/CC0 music, SFX, images) and iconify (icons)",
@@ -150,9 +165,9 @@ export function assertBilledAllowed(input) {
         return;
     if (!resolved.isSet) {
         log(`[cost] No spend preference set — ${label}${cost} will bill the account. ` +
-            `Ask the user minimize / hybrid / pure-ai and save it: vidfarm cost-mode <choice>.`);
+            `Ask the user minimize / hybrid / rich-ai and save it: vidfarm cost-mode <choice>.`);
         return;
     }
-    log(`[cost] ${label}${cost} — billed (mode: ${resolved.mode}${yes ? ", confirmed" : ""}).`);
+    log(`[cost] ${label}${cost} — billed (mode: ${costModeDisplayName(resolved.mode)}${yes ? ", confirmed" : ""}).`);
 }
 //# sourceMappingURL=cost-mode.js.map

package/dist/src/hyperframes/composition.js

@@ -705,7 +705,7 @@ function layerStyle(layer) {
     }
     if (["caption", "text", "shape", "html"].includes(layer.kind)) {
         const fontFamily = layer.fontFamily || "TikTok Sans";
-        styles.push("display:flex", "align-items:center", "justify-content:center", "padding:3px", `font-family:${fontCssFamily(fontFamily)}, 'TikTok Sans', Montserrat, Abel, sans-serif`, `font-weight:${positiveInteger(layer.fontWeight, 700)}`, `line-height:${positiveNumber(layer.lineHeight, 1.18)}`, "text-align:center", "text-transform:none", `font-size:${positiveInteger(layer.fontSize, 32)}px`, `color:${layer.color || "#ffffff"}`, layer.kind === "shape" && layer.textBackgroundStyle === "panel"
+        styles.push("display:flex", "align-items:center", "justify-content:center", "padding:3px", `font-family:${fontCssFamily(fontFamily)}, 'TikTok Sans', Montserrat, Abel, sans-serif, 'Noto Color Emoji'`, `font-weight:${positiveInteger(layer.fontWeight, 700)}`, `line-height:${positiveNumber(layer.lineHeight, 1.18)}`, "text-align:center", "text-transform:none", `font-size:${positiveInteger(layer.fontSize, 32)}px`, `color:${layer.color || "#ffffff"}`, layer.kind === "shape" && layer.textBackgroundStyle === "panel"
             ? `background:${layer.background || "transparent"}`
             : "background:transparent");
     }
@@ -733,7 +733,7 @@ function textInlineCss(style, color, background, fontFamily, fontWeight) {
     else if (style === "highlight-translucent") {
         styles.push("padding:0.07em 0.46em 0.09em", "border-radius:0.32em", `background:${rgbaFromColor(background, 0.34)}`, "text-shadow:none", "-webkit-text-stroke:0 transparent");
     }
-    styles.push(`font-family:${fontCssFamily(fontFamily)}, 'TikTok Sans', sans-serif`);
+    styles.push(`font-family:${fontCssFamily(fontFamily)}, 'TikTok Sans', sans-serif, 'Noto Color Emoji'`);
     styles.push(`font-weight:${fontWeight}`);
     styles.push(`color:${color}`);
     return styles.join(";");

package/dist/src/services/clip-curation/hunt.js

@@ -20,15 +20,16 @@ export const DEFAULT_CLIPS_PER_10_MIN = 10;
 export const DEFAULT_CLIP_ASPECT = "9:16";
 /**
  * Fill the unspecified-prompt defaults on a normalized hunt spec: a 5–15s
- * duration band, vertical 9:16 crop, and avoid-text ON. Only fills gaps — an
- * explicit user choice (including avoid_text:false) is preserved.
+ * duration band and a vertical 9:16 crop. avoid-text is deliberately NOT
+ * defaulted on — most social sources (TikTok/Shorts/Reels) are captioned
+ * wall-to-wall, so an implicit avoid_text:true rejects EVERY scene and yields a
+ * silent 0-clip hunt. avoid_text stays opt-in (set true only when the user asks
+ * to avoid on-screen text); an explicit choice either way is preserved.
  */
 export function applyHuntSpecDefaults(spec) {
     const out = { ...spec };
     if (!out.duration_band)
         out.duration_band = { ...DEFAULT_CLIP_DURATION_BAND };
-    if (out.avoid_text === undefined)
-        out.avoid_text = true;
     if (!out.aspect)
         out.aspect = DEFAULT_CLIP_ASPECT;
     return out;

package/dist/src/services/clip-curation/media-select.js

@@ -103,50 +103,96 @@ export function pickBestVideoMedia(medias) {
 // bare programmatic fetches, and the top-res server-side "merge" rendition
 // transiently 403s while the merge runs or when rate-limited.
 const MEDIA_DOWNLOAD_UA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36";
-const RETRYABLE_DOWNLOAD_STATUS = new Set([403, 408, 425, 429, 500, 502, 503, 504]);
+// Retryable within a round only for genuinely transient failures. A bot-challenge
+// (Cloudflare "Just a moment…") is NOT retryable in-round — the same signed URL
+// stays gated; only a fresh re-lookup (new token/proxy edge) can clear it.
+const RETRYABLE_DOWNLOAD_STATUS = new Set([408, 425, 429, 500, 502, 503, 504]);
 function delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
+/**
+ * A response that is HTML (or an explicit anti-bot challenge) is NOT the video —
+ * the snapvideo.co CDN hosts sit behind Cloudflare, which answers server-side
+ * fetches with a `text/html` "Just a moment…" interstitial (usually 403, but it
+ * can also come back 200). Streaming that to disk would save a bogus "video", so
+ * we treat any HTML body as a download failure regardless of status code.
+ */
+function looksLikeBotChallenge(response) {
+    const ct = (response.headers.get("content-type") || "").toLowerCase();
+    if (ct.includes("text/html") || ct.includes("application/xhtml"))
+        return true;
+    // Cloudflare stamps its edge on the challenge response.
+    const cfMitigated = (response.headers.get("cf-mitigated") || "").toLowerCase();
+    return cfMitigated.includes("challenge");
+}
 /**
  * Download the first playable rendition that actually responds, walking the
  * ranked candidates highest-res first. The RapidAPI resolver returns SEVERAL
  * copies it hosts itself (e.g. a progressive 360p plus server-side-merged
- * 720p/1080p); the merge renditions can transiently 403 while merging or when
- * rate-limited, so we retry a rendition once and then fall back to the next copy
- * rather than hard-failing the whole ingest. Returns the live Response (caller
- * streams `response.body` to disk/S3) plus the winning candidate. Throws only if
- * EVERY rendition is unreachable, with each failure in the message.
+ * 720p/1080p). The merge renditions sit behind a Cloudflare bot-challenge that a
+ * Lambda fetch can't clear, and even the progressive proxy gets *intermittently*
+ * challenged — so a single lookup can momentarily return an all-gated set. We
+ * therefore (a) reject HTML/challenge bodies instead of saving them as video,
+ * (b) fall back across renditions within a lookup, and (c) when `reResolve` is
+ * supplied, re-run the resolver for a FRESH signed set (new token + proxy edge,
+ * which is what actually clears a transient full-gate) and walk it again.
+ * Returns the live Response (caller streams `response.body` to disk/S3) plus the
+ * winning candidate. Throws only if every rendition across every round is
+ * unreachable, with each failure in the message.
  */
-export async function fetchFirstDownloadableMedia(medias) {
-    const ranked = rankPlayableVideoMedias(medias);
-    if (!ranked.length) {
-        throw new Error("Video download lookup returned no playable MP4 media URL.");
-    }
+export async function fetchFirstDownloadableMedia(medias, opts = {}) {
+    const { reResolve } = opts;
+    const maxRounds = reResolve ? 3 : 1;
     const failures = [];
-    for (const media of ranked) {
-        const url = media.url;
-        if (!url)
-            continue;
-        const label = media.quality ?? media.label ?? "?";
-        for (let attempt = 0; attempt < 2; attempt++) {
-            if (attempt > 0)
-                await delay(750);
+    let current = medias;
+    let lastRankedCount = 0;
+    for (let round = 0; round < maxRounds; round++) {
+        if (round > 0) {
+            // Back off, then mint a fresh signed set — the only thing that recovers a
+            // transient Cloudflare gate on the CDN hosts.
+            await delay(1000 * round);
             try {
-                const response = await fetch(url, { headers: { "user-agent": MEDIA_DOWNLOAD_UA, accept: "*/*" } });
-                if (response.ok && response.body) {
-                    return { response, media };
-                }
-                failures.push(`${label}:HTTP ${response.status}`);
-                await response.body?.cancel?.().catch(() => { });
-                // A non-transient status won't fix itself on retry — move to the next copy.
-                if (!RETRYABLE_DOWNLOAD_STATUS.has(response.status))
-                    break;
+                current = await reResolve();
             }
             catch (error) {
-                failures.push(`${label}:${error instanceof Error ? error.message : String(error)}`);
+                failures.push(`re-lookup:${error instanceof Error ? error.message : String(error)}`);
+                break;
+            }
+        }
+        const ranked = rankPlayableVideoMedias(current);
+        lastRankedCount = ranked.length;
+        if (!ranked.length) {
+            failures.push(round === 0 ? "no playable media in lookup" : `round ${round + 1}: no playable media`);
+            continue;
+        }
+        for (const media of ranked) {
+            const url = media.url;
+            if (!url)
+                continue;
+            const label = media.quality ?? media.label ?? "?";
+            for (let attempt = 0; attempt < 2; attempt++) {
+                if (attempt > 0)
+                    await delay(750);
+                try {
+                    const response = await fetch(url, { headers: { "user-agent": MEDIA_DOWNLOAD_UA, accept: "*/*" } });
+                    const challenged = looksLikeBotChallenge(response);
+                    if (response.ok && response.body && !challenged) {
+                        return { response, media };
+                    }
+                    failures.push(`${label}:HTTP ${response.status}${challenged ? " bot-challenge" : ""}`);
+                    await response.body?.cancel?.().catch(() => { });
+                    // A bot-challenge or any non-transient status won't clear on an
+                    // immediate retry of the same URL — move to the next rendition (and,
+                    // ultimately, the next re-lookup round).
+                    if (challenged || !RETRYABLE_DOWNLOAD_STATUS.has(response.status))
+                        break;
+                }
+                catch (error) {
+                    failures.push(`${label}:${error instanceof Error ? error.message : String(error)}`);
+                }
             }
         }
     }
-    throw new Error(`Source video download failed; all ${ranked.length} rendition(s) unavailable (${failures.join("; ")}).`);
+    throw new Error(`Source video download failed; all ${lastRankedCount} rendition(s) unavailable (${failures.join("; ")}).`);
 }
 //# sourceMappingURL=media-select.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@officexapp/vidfarm-devcli",
-  "version": "0.21.14",
+  "version": "0.21.16",
   "description": "Local bridge for the Vidfarm Trackpad Editor. `vidfarm serve <template_id>` boots the FULL editor on localhost (disk-backed records/storage, free in-process render); edit composition.html on disk (Claude Code, Codex, etc.) and the browser live-morphs it.",
   "type": "module",
   "bin": {

package/public/serve-shells/editor.html

@@ -367,7 +367,10 @@
 /* chat column */
 .rk-aichat-main{flex:1;min-width:0;display:flex;flex-direction:column}
 .rk-aichat-head{display:flex;align-items:center;gap:8px;padding:14px 14px;border-bottom:1px solid var(--rk-border);flex:none}
-.rk-aichat-head-main{flex:1;min-width:0;display:grid;gap:1px}
+.rk-aichat-head-main{flex:1;min-width:0;display:flex;align-items:center;gap:10px}
+.rk-aichat-head-titles{display:grid;gap:1px;min-width:0}
+.rk-aichat-watch{display:inline-flex;align-items:center;gap:5px;border:0;background:transparent;color:var(--rk-text-muted);font-size:12px;font-weight:400;font-family:inherit;cursor:pointer;padding:3px 8px;border-radius:8px;white-space:nowrap;transition:color .15s,background .15s}
+.rk-aichat-watch:hover{color:var(--rk-ink);background:var(--rk-n-100)}
 .rk-aichat-title{font-family:var(--rk-font-display);font-weight:800;font-size:15px;color:var(--rk-ink);letter-spacing:-.01em}
 .rk-aichat-sub{font-size:11.5px;color:var(--rk-text-muted)}
 .rk-aichat-back{flex:1;min-width:0;display:inline-flex;align-items:center;gap:8px;padding:7px 12px 7px 9px;
@@ -1125,6 +1128,17 @@ html,body{margin:0;background:#050604;color:#fffbe6}
 .rk-vf-btn:hover:not(:disabled){background:#262b1a;border-color:var(--rk-border-strong)}
 .rk-vf-btn:disabled{opacity:.45;cursor:default}
 .rk-vf-status{font-size:11.5px;color:var(--rk-text-muted);margin:0}
+.rk-vf-renders{display:grid;gap:5px;margin-top:2px}
+.rk-vf-renders-head{display:flex;align-items:center;justify-content:space-between}
+.rk-vf-renders-refresh{background:none;border:none;color:var(--rk-text-muted);cursor:pointer;
+  font-size:13px;line-height:1;padding:2px 4px;border-radius:6px}
+.rk-vf-renders-refresh:hover{color:var(--rk-ink);background:#262b1a}
+.rk-vf-render-row{display:flex;align-items:center;justify-content:space-between;gap:8px;
+  padding:7px 10px;border-radius:var(--rk-r-lg);border:1px solid var(--rk-border);background:#171b10;
+  color:var(--rk-ink);font-size:12px;text-decoration:none;
+  transition:background var(--rk-dur) var(--rk-ease),border-color var(--rk-dur) var(--rk-ease)}
+.rk-vf-render-row:hover{background:#222717;border-color:var(--rk-border-strong)}
+.rk-vf-render-label{font-weight:600}
 
 /* ── Rebrand: the sealed upstream <StudioApp/> header renders a "HeyGen ·
    HyperFrames" logo SVG (aria-label="Hyperframes"). The actual swap to a VidFarm
@@ -1189,10 +1203,6 @@ html,body{margin:0;background:#050604;color:#fffbe6}
   </div>
   <div class="rk-aichat-main">
     <header class="rk-aichat-head">
-      <a class="rk-aichat-back" id="rkAichatBack" href="/library" title="Back to your library">
-        <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M19 12H5"/><path d="m12 19-7-7 7-7"/></svg>
-        <span>Back to Library</span>
-      </a>
       <div class="rk-aichat-skill"><div class="vf-skill-install vf-skill-install-nav" data-skill-install>
     <button
       class="vf-skill-install-main"