@mevdragon/vidfarm-devcli 0.15.0 → 0.16.0

package/dist/src/app.js

@@ -22,6 +22,7 @@ import { assertForkAccess, resolveForkAccess, ForkAccessDeniedError, ForkNotFoun
 import { writeForkManifest } from "./services/fork-manifest.js";
 import { renderHelpPage } from "./help-page.js";
 import { renderHomepage } from "./homepage.js";
+import { POPULAR_INSPIRATION_GROUPS } from "./frontend/homepage-shared.js";
 import { COMPOSITION_RUNTIME_SCRIPT_BODY } from "./composition-runtime.js";
 import { CAPTION_ANIM_CSS, CAPTION_STYLE_MARKER, KEN_BURNS_CSS, KEN_BURNS_STYLE_MARKER, TRANSITION_CSS, TRANSITION_STYLE_MARKER, upgradeLegacyTransitionCss } from "./hyperframes/composition.js";
 import { normalizeCompositionZIndexHtml, sanitizeCompositionHtml } from "./services/composition-sanitize.js";
@@ -59,7 +60,7 @@ import { analyzeCastMembers, annotateScenesFromSource, buildSmartDecomposedHtml,
 import { buildPendingSceneAnnotationsState } from "./services/scene-annotations.js";
 import { createPrimitiveJobContext } from "./primitive-context.js";
 import { buildPendingCastState, castMemberFromRaw, extractCastStill, isolateCastMember } from "./services/cast.js";
-import { MediaDurationExceededError, probeMediaAsset } from "./services/media-processing.js";
+import { MediaDurationExceededError, probeMediaAsset, trimVideoAsset } from "./services/media-processing.js";
 import { estimateGhostcutCostUsd, isGhostcutConfigured, mirrorGhostcutVideoToStorage, pollStatus as pollGhostcutStatus, submitSubtitleRemoval } from "./services/ghostcut.js";
 import { hasUpstreamKey, isUpstreamEnabled, proxyRequestToUpstream, seedFromUpstream, upstreamHost, upstreamJson } from "./services/upstream.js";
 import { TemplateSourceService } from "./services/template-sources.js";
@@ -4937,6 +4938,28 @@ app.get("/editor/:templateId", async (c) => {
         if (!forkRecord || forkRecord.deletedAt) {
             effectiveForkParam = null;
         }
+        else if (customer) {
+            // A caller who can VIEW but not EDIT this fork (e.g. a public template's
+            // default fork opened via a shared deep link) must not be pinned onto it:
+            // the editor would happily let them "edit", but every composition.html PUT
+            // is 403'd and the change silently reverts on reload — the exact "the AI
+            // said it changed the text but it didn't" failure. Drop the fork and fall
+            // through to per-user resolution so they get (or mint) their own editable
+            // copy instead.
+            try {
+                const access = await resolveForkAccess({
+                    forkId: effectiveForkParam,
+                    customerId: customer.id,
+                    shareToken: readShareToken(c) ?? undefined
+                });
+                if (!access.capabilities.canEdit) {
+                    effectiveForkParam = null;
+                }
+            }
+            catch {
+                effectiveForkParam = null;
+            }
+        }
     }
     if (!effectiveForkParam) {
         // Per-user default fork resolution: prefer caller's most-recently-updated
@@ -4953,8 +4976,14 @@ app.get("/editor/:templateId", async (c) => {
             if (mostRecent)
                 targetForkId = mostRecent.id;
         }
-        if (!targetForkId)
+        // Only fall back to the template's canonical default fork when the caller can
+        // actually edit it — i.e. they own the template. A non-owner sent to the
+        // default fork would land back on a read-only fork (and, since it's also the
+        // page we just dropped, loop). Leaving targetForkId null routes them to the
+        // bare editor, where the client mints their own editable fork on first save.
+        if (!targetForkId && template.customerId === customer?.id) {
             targetForkId = template.defaultForkId;
+        }
         if (targetForkId) {
             // Do NOT auto-attach a thread_id here: the caller's browser is the
             // source of truth for "which chat is active" via localStorage. Injecting
@@ -5062,6 +5091,11 @@ app.get("/discover/feed", async (c) => {
     }
     const templates = await serverlessRecords.listTemplatesFeed({ limit, query });
     for (const template of templates) {
+        // Curated "Popular" picks live only under the Popular toggle
+        // (GET /discover/popular) — keep them out of the continuously-grown Feed
+        // so the two views stay distinct.
+        if (typeof template.popularGroup === "string" && template.popularGroup.trim().length > 0)
+            continue;
         const entry = buildTemplateHomepageEntry(template);
         if (entry)
             templateEntries.push(entry);
@@ -5078,7 +5112,7 @@ app.get("/discover/feed", async (c) => {
         const upstreamFeed = (await upstreamJson(`/discover/feed?${search.toString()}`)).json?.templates ?? [];
         const seen = new Set(templateEntries.map((entry) => entry.templateId));
         for (const entry of upstreamFeed) {
-            if (entry && typeof entry.templateId === "string" && !seen.has(entry.templateId)) {
+            if (entry && typeof entry.templateId === "string" && !seen.has(entry.templateId) && !entry.popularGroup) {
                 templateEntries.push(entry);
                 seen.add(entry.templateId);
             }
@@ -5093,16 +5127,60 @@ app.get("/discover/feed", async (c) => {
         next_cursor: null
     });
 });
+// Curated "Popular" feed: the editorial list surfaced under the /discover
+// Popular toggle. Same template records as Feed, just the ones flagged with a
+// popularGroup — rendered client-side as autoplay TemplateCards grouped by that
+// label. Public + identical for everyone, so it caches shared. Mirrors upstream
+// (vidfarm serve) exactly like /discover/feed so a locally-empty box still sees
+// the cloud-seeded picks. Seed with POST /api/v1/admin/popular/seed.
+app.get("/discover/popular", async (c) => {
+    const templateEntries = [];
+    const seen = new Set();
+    const popular = await serverlessRecords.listPopularTemplates();
+    for (const template of popular) {
+        const entry = buildTemplateHomepageEntry(template);
+        if (entry) {
+            templateEntries.push(entry);
+            seen.add(entry.templateId);
+        }
+    }
+    if (isUpstreamEnabled()) {
+        const upstream = (await upstreamJson(`/discover/popular`)).json?.templates ?? [];
+        for (const entry of upstream) {
+            if (entry && typeof entry.templateId === "string" && !seen.has(entry.templateId) && entry.popularGroup) {
+                templateEntries.push(entry);
+                seen.add(entry.templateId);
+            }
+        }
+    }
+    // Stable editorial order: popularRank is a global sequence assigned by the
+    // seed (group index * 1000 + item index), so a plain rank sort preserves both
+    // group order and within-group order. Group label is only a tiebreak.
+    templateEntries.sort((a, b) => {
+        const rankCompare = (a.popularRank ?? 0) - (b.popularRank ?? 0);
+        if (rankCompare !== 0)
+            return rankCompare;
+        return String(a.popularGroup ?? "").localeCompare(String(b.popularGroup ?? ""));
+    });
+    c.header("cache-control", "public, max-age=60");
+    return c.json({
+        templates: templateEntries,
+        next_cursor: null
+    });
+});
 function buildTemplateHomepageEntry(template) {
     // Undecomposed templates (no defaultForkId yet) still appear on /discover so
     // users can open them and mint the first fork via the Decompose modal.
     if (!template.videoUrl)
         return null;
     const isPrivate = template.visibility === "private";
+    const isPopular = typeof template.popularGroup === "string" && template.popularGroup.trim().length > 0;
     // Older records stored the source host ("youtube.com") as a title fallback —
     // never show that as a card title; the template id is the canonical default.
     const storedTitle = template.title && template.title !== template.sourceHost ? template.title : null;
-    const title = isPrivate ? (storedTitle || template.id) : template.id;
+    // Public feed cards default to the template id, but curated Popular picks show
+    // their editorial title (the whole point of the Popular list).
+    const title = (isPrivate || isPopular) ? (storedTitle || template.id) : template.id;
     const previewUrl = template.thumbnailUrl || template.videoUrl || null;
     return {
         title,
@@ -5122,6 +5200,8 @@ function buildTemplateHomepageEntry(template) {
         summary: template.searchSummary ?? null,
         visibility: template.visibility,
         origin: template.origin ?? "inspiration",
+        popularGroup: template.popularGroup ?? null,
+        popularRank: template.popularRank ?? null,
         notes: template.notes,
         status: "ready"
     };
@@ -5489,6 +5569,8 @@ function buildPendingInspirationHomepageEntry(inspiration) {
         durationSeconds: inspiration.durationSeconds ?? null,
         visibility: "private",
         origin: inspiration.origin ?? "inspiration",
+        popularGroup: inspiration.popularGroup ?? null,
+        popularRank: inspiration.popularRank ?? null,
         notes: inspiration.notes,
         status: inspiration.status === "failed" ? "failed" : "processing"
     };
@@ -7131,6 +7213,13 @@ app.post(`${INSPIRATIONS_PREFIX}/:inspirationId/decompose`, async (c) => {
 // so a forced re-run may start. Must exceed the longest real decompose but stay
 // under the API lambda's 15-min timeout.
 const DECOMPOSE_PROCESSING_STALE_MS = 10 * 60 * 1000;
+// Inspiration ingest + auto-decompose no longer hard-cap the source at 120s.
+// Users can bring longer inspiration; an operator can still re-impose a ceiling
+// via INSPIRATION_MAX_DURATION_SEC (>0). 0 → unlimited, translated to Infinity so
+// probeMediaAsset never rejects a source purely on length.
+const INSPIRATION_PROBE_MAX_DURATION_SECONDS = config.INSPIRATION_MAX_DURATION_SEC > 0
+    ? config.INSPIRATION_MAX_DURATION_SEC
+    : Number.POSITIVE_INFINITY;
 async function readDecomposeJobState(forkId) {
     const text = await storage.readText(storage.compositionForkWorkingKey(forkId, "decompose.json"));
     if (!text)
@@ -7250,7 +7339,10 @@ app.post(`${COMPOSITIONS_PREFIX}/:forkId/auto-decompose`, async (c) => {
         let probedDurationSeconds = null;
         if (sourceUrl) {
             try {
-                const probe = await probeMediaAsset({ sourceUrl });
+                const probe = await probeMediaAsset({
+                    sourceUrl,
+                    maxDurationSeconds: INSPIRATION_PROBE_MAX_DURATION_SECONDS
+                });
                 const probed = probe.metadata.durationSeconds;
                 if (Number.isFinite(probed) && probed && probed > 0) {
                     probedDurationSeconds = probed;
@@ -7298,7 +7390,17 @@ app.post(`${COMPOSITIONS_PREFIX}/:forkId/auto-decompose`, async (c) => {
             ghostcutSkipReason = "ghostcut_not_configured";
             console.warn(`ghostcut: skipping subtitle removal for fork ${fork.id} — GHOSTCUT_KEY/GHOSTCUT_SECRET not configured. Composition will keep the original video with baked-in text.`);
         }
-        if (sourceUrl && sourceIsVideo && isGhostcutConfigured()) {
+        else if (config.GHOSTCUT_DECOMPOSE_MAX_DURATION_SEC > 0 &&
+            probedDurationSeconds !== null &&
+            probedDurationSeconds > config.GHOSTCUT_DECOMPOSE_MAX_DURATION_SEC) {
+            // GhostCut is per-30s-chunk and meant for short clips. Long inspiration is
+            // now allowed through ingest/decompose, but laundering a multi-minute video
+            // through GhostCut is disproportionately expensive — skip it and keep the
+            // original burned-in captions instead.
+            ghostcutSkipReason = `source_too_long:${probedDurationSeconds.toFixed(1)}s>${config.GHOSTCUT_DECOMPOSE_MAX_DURATION_SEC}s`;
+            console.warn(`ghostcut: skipping subtitle removal for fork ${fork.id} — source is ${probedDurationSeconds.toFixed(1)}s, over the ${config.GHOSTCUT_DECOMPOSE_MAX_DURATION_SEC}s decompose ceiling. Composition keeps the original burned-in captions.`);
+        }
+        if (sourceUrl && sourceIsVideo && isGhostcutConfigured() && !ghostcutSkipReason) {
             try {
                 const submission = await submitSubtitleRemoval(sourceUrl);
                 ghostcutTaskId = submission.taskId;
@@ -9118,6 +9220,8 @@ function serializeInspiration(inspiration) {
         summary: inspiration.searchSummary ?? null,
         visibility: inspiration.visibility ?? "public",
         origin: inspiration.origin ?? "inspiration",
+        popular_group: inspiration.popularGroup ?? null,
+        popular_rank: inspiration.popularRank ?? null,
         notes: inspiration.notes ?? null,
         ingester_customer_id: inspiration.customerId,
         error: inspiration.errorMessage,
@@ -11222,7 +11326,10 @@ async function ensureInspirationReadyThenFork(input) {
     // the true length instead of a placeholder.
     if (!inspiration.durationSeconds) {
         try {
-            const probe = await probeMediaAsset({ sourceUrl: inspiration.videoUrl });
+            const probe = await probeMediaAsset({
+                sourceUrl: inspiration.videoUrl,
+                maxDurationSeconds: INSPIRATION_PROBE_MAX_DURATION_SECONDS
+            });
             const probedDuration = probe.metadata.durationSeconds;
             if (Number.isFinite(probedDuration) && probedDuration && probedDuration > 0) {
                 inspiration = (await serverlessRecords.updateInspiration({
@@ -11301,6 +11408,205 @@ function buildTemplateEditorUrl(publicBaseUrl, templateId) {
     const path = `/editor/${encodeURIComponent(templateId)}`;
     return publicBaseUrl ? `${publicBaseUrl.replace(/\/$/, "")}${path}` : path;
 }
+// Curated Popular picks are short-form: a source longer than the 120s ingest
+// limit is clipped to this many seconds (kept safely under 120 for the probe).
+const POPULAR_MAX_CLIP_SEC = 115;
+// Seed the curated "Popular" catalog from POPULAR_INSPIRATION_GROUPS: ingest
+// each URL once into a real PUBLIC template (same path as admin TikTok
+// submissions) and stamp it with the editorial title + popularGroup +
+// popularRank so it always shows under the /discover Popular toggle and
+// autoplays inline exactly like a Feed card. Over-length sources are clipped to
+// POPULAR_MAX_CLIP_SEC. Idempotent — find-or-create by URL, then (re)stamp.
+// Requires RAPIDAPI_KEY (the download primitive), so run this on staging/prod.
+app.post(`${API_PREFIX}/admin/popular/seed`, async (c) => {
+    try {
+        requireSuperagency(c);
+    }
+    catch (error) {
+        return c.json({ error: error instanceof Error ? error.message : "Forbidden" }, 403);
+    }
+    const body = asRecord(await c.req.json().catch(() => ({}))) ?? {};
+    const requestedOwnerEmail = readNonEmptyString(body.owner_email)?.trim().toLowerCase();
+    const ownerEmail = requestedOwnerEmail ?? config.adminEmails[0]?.trim().toLowerCase();
+    if (!ownerEmail)
+        return c.json({ error: "No owner_email supplied and no admin email configured." }, 400);
+    const ownerCustomer = await serverlessRecords.getCustomerByEmail(ownerEmail);
+    if (!ownerCustomer)
+        return c.json({ error: `Owner not found: ${ownerEmail}` }, 404);
+    const primitive = primitiveRegistry.get("primitive:video_download");
+    if (!primitive)
+        return c.json({ error: "video_download primitive missing" }, 500);
+    const operation = primitive.operations["run"];
+    if (!operation)
+        return c.json({ error: "video_download.run missing" }, 500);
+    const publicBaseUrl = config.PUBLIC_BASE_URL?.trim() || "";
+    try {
+        await assertWalletCanQueueJobs(ownerCustomer.id);
+    }
+    catch (error) {
+        if (error instanceof InsufficientWalletFundsError)
+            return insufficientFundsResponse(c, error);
+        throw error;
+    }
+    // Flatten the manifest into one ranked list. popularRank is a global sequence
+    // (group index * 1000 + item index) so a plain rank sort restores both the
+    // group order and the order within each group.
+    const allItems = POPULAR_INSPIRATION_GROUPS.flatMap((group, gi) => group.items.map((item, ri) => ({ title: item.title, url: item.url, group: group.label, rank: gi * 1000 + ri })));
+    // Optional { groups: [...] } filter seeds one category at a time so a large
+    // catalog stays well under the Lambda timeout (each URL downloads inline).
+    // Reconcile below still runs against the FULL manifest, so a partial seed
+    // never retires the groups it skipped.
+    const onlyGroups = Array.isArray(body.groups) ? new Set(body.groups.map((g) => String(g))) : null;
+    const items = onlyGroups ? allItems.filter((it) => onlyGroups.has(it.group)) : allItems;
+    const results = [];
+    for (const item of items) {
+        const originalUrl = stripTrackingParams(item.url);
+        const sourceHost = safeUrlHostname(originalUrl);
+        if (!sourceHost) {
+            results.push({ source_url: item.url, title: item.title, error: "invalid URL" });
+            continue;
+        }
+        let inspiration = await serverlessRecords.findInspirationByOriginalUrl(originalUrl);
+        // (Re)start the download only when there's no usable video yet — a genuine
+        // download failure (no videoUrl) retries, but a pick that DID download and
+        // only tripped the duration limit keeps its bytes and gets clipped below.
+        const needsIngest = !inspiration
+            || (!inspiration.videoUrl && inspiration.status !== "downloading");
+        if (needsIngest) {
+            const payload = operation.inputSchema.parse({ source_url: originalUrl, save_manifest: true });
+            let job;
+            try {
+                job = await jobs.createRootJob({
+                    templateId: primitive.id,
+                    operationName: "run",
+                    workflowName: operation.workflow,
+                    tracer: `popular_seed_ingest:${ownerCustomer.id}`,
+                    payload,
+                    webhookUrl: null,
+                    customer: ownerCustomer,
+                    providerHint: undefined
+                });
+            }
+            catch (error) {
+                results.push({ source_url: item.url, title: item.title, error: error instanceof Error ? error.message : String(error) });
+                continue;
+            }
+            inspiration = inspiration
+                ? ((await serverlessRecords.updateInspiration({
+                    inspirationId: inspiration.id,
+                    patch: { status: "downloading", downloadJobId: job.id, errorMessage: null }
+                })) ?? inspiration)
+                : await serverlessRecords.createInspiration({
+                    customerId: ownerCustomer.id,
+                    sourceUrl: item.url,
+                    originalUrl,
+                    sourceHost,
+                    downloadJobId: job.id,
+                    trendTagline: item.title
+                });
+        }
+        // Stamp the editorial marker + curated title up front so a still-downloading
+        // pick already surfaces under Popular with the right label (pending cards
+        // read trendTagline, which finalize never clobbers).
+        inspiration = (await serverlessRecords.updateInspiration({
+            inspirationId: inspiration.id,
+            patch: { title: item.title, trendTagline: item.title, popularGroup: item.group, popularRank: item.rank, visibility: "public" }
+        })) ?? inspiration;
+        // On a local box (no Step Functions) the download job would queue forever —
+        // run it in-process so ensureInspirationReadyThenFork can finalize.
+        if (!config.VIDFARM_JOB_STATE_MACHINE_ARN && inspiration.status === "downloading" && inspiration.downloadJobId) {
+            const pendingJobId = inspiration.downloadJobId;
+            void runPrimitiveJobInProcess(pendingJobId).catch((error) => {
+                console.error("popular seed download failed", pendingJobId, error instanceof Error ? error.message : error);
+            });
+        }
+        const finalized = await ensureInspirationReadyThenFork({ inspiration, ownerCustomer, publicBaseUrl, note: null });
+        let templateId = typeof finalized.template_id === "string" ? finalized.template_id : null;
+        let clipped = false;
+        let sourceDurationSec = null;
+        // Curated Popular picks are short-form. If the source downloaded fine but was
+        // rejected ONLY for exceeding the 120s ingest limit, clip it to <=115s and
+        // finalize the clip — so a long reference video still becomes a Popular card.
+        if (!templateId) {
+            const rejected = await serverlessRecords.getInspiration(inspiration.id);
+            const tooLong = Boolean(rejected?.videoUrl)
+                && ((Number.isFinite(rejected?.durationSeconds) && Number(rejected?.durationSeconds) > POPULAR_MAX_CLIP_SEC)
+                    || /exceeds/i.test(rejected?.errorMessage ?? ""));
+            if (Number.isFinite(rejected?.durationSeconds))
+                sourceDurationSec = Number(rejected?.durationSeconds);
+            else {
+                const m = /([0-9.]+)s exceeds/.exec(rejected?.errorMessage ?? "");
+                if (m)
+                    sourceDurationSec = Number(m[1]);
+            }
+            if (rejected?.videoUrl && tooLong) {
+                try {
+                    const trimmed = await trimVideoAsset({ sourceUrl: rejected.videoUrl, startMs: 0, durationMs: POPULAR_MAX_CLIP_SEC * 1000 });
+                    // Store under the public "primitives/" prefix so getPublicUrl can hand
+                    // back a directly-fetchable S3 URL (other prefixes resolve to null).
+                    const clipKey = joinStorageKey("primitives", "popular-clips", `${rejected.id}.mp4`);
+                    const stored = await storage.putBuffer(clipKey, trimmed.bytes, "video/mp4");
+                    const clipUrl = stored.url ?? storage.getPublicUrl(clipKey);
+                    if (!clipUrl)
+                        console.error("popular seed clip: no public URL for", clipKey);
+                    const clipDurRaw = trimmed.metadata.trimmed?.durationSeconds;
+                    const clipDur = Number.isFinite(clipDurRaw) && clipDurRaw ? Number(clipDurRaw) : POPULAR_MAX_CLIP_SEC;
+                    if (clipUrl) {
+                        const readyInsp = await serverlessRecords.updateInspiration({
+                            inspirationId: rejected.id,
+                            patch: {
+                                videoUrl: clipUrl,
+                                videoStorageKey: clipKey,
+                                thumbnailUrl: null,
+                                durationSeconds: clipDur,
+                                status: "ready",
+                                errorMessage: null
+                            }
+                        });
+                        if (readyInsp) {
+                            const reFinalized = await ensureInspirationReadyThenFork({ inspiration: readyInsp, ownerCustomer, publicBaseUrl, note: null });
+                            templateId = typeof reFinalized.template_id === "string" ? reFinalized.template_id : null;
+                            clipped = Boolean(templateId);
+                        }
+                    }
+                }
+                catch (error) {
+                    console.error("popular seed clip failed", rejected.id, error instanceof Error ? error.message : error);
+                }
+            }
+        }
+        if (templateId) {
+            await serverlessRecords.updateTemplate({
+                templateId,
+                patch: { title: item.title, popularGroup: item.group, popularRank: item.rank, visibility: "public" }
+            });
+        }
+        results.push({
+            source_url: item.url,
+            title: item.title,
+            group: item.group,
+            rank: item.rank,
+            template_id: templateId,
+            status: templateId ? "ready" : (finalized.status ?? null),
+            clipped,
+            source_duration_sec: sourceDurationSec,
+            pending: finalized.pending ?? false
+        });
+    }
+    // Reconcile: any previously-seeded pick whose URL is no longer in the manifest
+    // (a replaced or removed entry) gets un-flagged so it drops out of the Popular
+    // view — the manifest is the single source of truth. Compared after the same
+    // tracking-param stripping the stored originalUrl went through.
+    const manifestUrls = new Set(allItems.map((it) => stripTrackingParams(it.url)));
+    const retired = [];
+    for (const tmpl of await serverlessRecords.listPopularTemplates()) {
+        if (!manifestUrls.has(tmpl.originalUrl)) {
+            await serverlessRecords.updateTemplate({ templateId: tmpl.id, patch: { popularGroup: null, popularRank: null } });
+            retired.push({ template_id: tmpl.id, title: tmpl.title, original_url: tmpl.originalUrl });
+        }
+    }
+    return c.json({ ok: true, owner_customer_id: ownerCustomer.id, count: results.length, items: results, retired }, 202);
+});
 function buildRawTikTokCompositionHtml(input) {
     const duration = Number.isFinite(input.durationSeconds) && input.durationSeconds > 0
         ? Number(input.durationSeconds.toFixed(3))

package/dist/src/config.js

@@ -73,6 +73,19 @@ const schema = z.object({
     // long video through GhostCut. 15 min default ceiling (per-30s pricing makes
     // long-form runs absurd anyway).
     GHOSTCUT_MAX_DURATION_SEC: z.coerce.number().min(0).default(900),
+    // Auto-decompose kicks off GhostCut subtitle removal on the source video, but
+    // GhostCut prices per-30s chunk and is meant for short clips. Skip it entirely
+    // when the decompose source is longer than this — the composition just keeps
+    // the original burned-in captions rather than paying to launder a multi-minute
+    // video. 0 = never skip on length. Distinct from GHOSTCUT_MAX_DURATION_SEC
+    // (the standalone remove-captions primitive's hard ceiling).
+    GHOSTCUT_DECOMPOSE_MAX_DURATION_SEC: z.coerce.number().min(0).default(180),
+    // Inspiration ingest + auto-decompose used to hard-cap sources at 120s (a
+    // short-form-only assumption). Longer inspiration is now allowed. 0 = unlimited;
+    // set a positive ceiling to re-impose a limit. Kept separate from
+    // MAX_PROBE_DURATION_SECONDS (the per-primitive probe cost-guard) so raising the
+    // inspiration ceiling never loosens the generic probe default.
+    INSPIRATION_MAX_DURATION_SEC: z.coerce.number().min(0).default(0),
     // Cloud passthrough for `vidfarm serve`: the local box keeps editing/render
     // fully local but lists the upstream (prod) catalog in /discover and
     // /library, seeds forks on demand, and can hand a render off to the cloud.

package/dist/src/editor-chat.js

@@ -72,6 +72,7 @@ export function buildTemplateEditorChatSystemPrompt(input) {
         "The editor_context block includes last_export_url, last_export_title, last_export_status, and last_export_render_id when a render has succeeded in this session. Treat last_export_url as the current 'finished Export MP4' for this composition. If the user asks to approve, package, share, or schedule the exported video without providing an explicit URL, use last_export_url as the primary MP4 media (kind=video, role=primary) for POST /api/v1/approved/posts. If last_export_url is null, tell the user to Export first (or offer to call editor_action with action_type=export_composition on their behalf) instead of guessing a URL.",
         "Each layer in editor_context includes element_id (data-hf-id), optional slug (data-hf-slug), and optional note (data-hf-note). layer_key on any editor_action may be EITHER the element_id or the slug — prefer the slug when the user (or a viral DNA blurb) refers to a layer by its human name like 'the hero_image'. Use set_layer_identity to add/change a layer's slug or note. Slugs are the stable AI-friendly handle: when planning viral DNA notes, reference the element by its slug (e.g., 'raise the {{hero_image}} to full canvas at 4s') so future turns can resolve it deterministically.",
         "Treat the most recent <editor_context> block in the user message as the source of truth for current layer_keys, layer indices (called track in HTML: track=layer index, higher = drawn on top), durations, and composition_duration_seconds. Never invent layer_keys for remove/set/duplicate/split actions; only reference keys that appear there.",
+        "CRITICAL — verify your edits actually landed. An editor_action tool result only echoes the arguments you sent; it is NOT proof the change was applied or saved. The real outcome shows up in the NEXT <editor_context>. Before telling the user an edit succeeded, check that block: (1) if it contains save_status:\"error\" (or is_read_only:true / a save_error message), the composition is NOT being saved — do NOT claim any edit worked; tell the user exactly what save_error says (e.g. the video is read-only from this link and they should open their own copy to edit) and stop making mutating editor_action calls until it clears; (2) if it contains recent_action_results, each entry with ok:false is an edit from your previous turn that FAILED (read its error) — acknowledge the failure and retry or explain it rather than repeating a false success; (3) otherwise confirm the intended change is reflected in the layers (e.g. the new text on the target layer) before saying it's done. Never report a timeline edit as successful without this check.",
         "editor_context also carries the canvas shape and free time: composition_width, composition_height, and aspect_ratio (e.g. '9:16') describe the output frame — when generating media to place on this timeline, request the matching aspect_ratio on /videos/generate and /images/generate so it fills the canvas without letterboxing or wrong cropping. timeline_gaps is a precomputed array of {start, end, duration} spans (seconds) where NO visual layer is on screen — i.e. the literal blank/black moments. When the user says something like 'at 00:05:52 there's blank space, add X', map their timestamp (interpret mm:ss or seconds sensibly) to the covering entry in timeline_gaps, set the new layer's start to that gap's start (or the user's exact time if inside the gap) and clamp its duration to fit the gap unless the user asks otherwise. If the requested time is NOT inside any timeline_gaps entry, tell the user it already has content there and offer to overlay on a higher track or replace the existing layer instead of silently colliding.",
         "For add_layer, always supply a stable layer_key (e.g., vf-caption-hook, vf-hero-image, vf-narration-audio) so later tool calls in the same turn can reference the new layer without waiting for the next <editor_context>. The editor uses that layer_key as the new layer's id. Choose kind from video, image, audio, text, or html. Provide src (exact URL) for video/image/audio, text for text layers, and html for html layers. Pick a track index higher than every existing layer on the requested time range, or set start/duration so the range is collision-free. Default visual layers fill roughly the upper-middle of the canvas; text layers default to a lower-third band. Always include explanation.",
         "GENERATE-AND-PLACE (preferred for NEW AI footage/images on the timeline): when the user wants to generate a NEW AI video or image and drop it on the timeline — fill a blank gap, replace a scene, or add an overlay — call editor_action with action_type=generate_layer. This ONE action submits the primitive generate job, immediately drops a 'Generating…' placeholder clip into the target slot, and auto-swaps in the finished media when the job settles — you do NOT poll and you do NOT make a separate add_layer call. Set media_type ('video' or 'image'), prompt, and aspect_ratio to the editor_context aspect_ratio so it fills the canvas. Set intent: 'fill_gap' (also set start=the timeline_gaps span start and duration to fit the gap), 'replace_layer' (also set replace_layer_key to the scene's layer_key/slug — its timing and geometry, including full-canvas, are copied automatically), or 'add' (set start/track/geometry for an overlay). For video pass gen_duration (seconds of footage, e.g. 4) and, for character consistency, input_references=[cast reference_url or still_url]; for image pass prompt_attachments=[reference image URL]. Optionally set provider/model/resolution/generate_audio. Give explanation. Because generation is asynchronous, the placeholder appears now and the real media lands in a later turn — do NOT claim the media is finished; tell the user it is generating and will appear on the timeline shortly.",

package/dist/src/frontend/homepage-client.js

@@ -65,6 +65,10 @@ function HomepageClientApp({ boot }) {
     const bookmarks = useStore(store, (state) => state.bookmarks);
     const loading = useStore(store, (state) => state.loading);
     const error = useStore(store, (state) => state.error);
+    const view = useStore(store, (state) => state.view);
+    const popularTemplates = useStore(store, (state) => state.popularTemplates);
+    const popularLoading = useStore(store, (state) => state.popularLoading);
+    const popularError = useStore(store, (state) => state.popularError);
     const [bookmarksReady, setBookmarksReady] = useState(false);
     const visibleTemplates = useMemo(() => filterTemplates({ templates, searchQuery, bookmarksOnly, bookmarks }), [templates, searchQuery, bookmarksOnly, bookmarks]);
     useEffect(() => {
@@ -121,6 +125,51 @@ function HomepageClientApp({ boot }) {
         }, 8000);
         return () => window.clearInterval(timer);
     }, [hasProcessingTemplates, refreshFeed]);
+    // The curated Popular picks come from a separate endpoint and are the same
+    // for everyone, so they're fetched lazily the first time the toggle is opened
+    // (and re-fetched, without a spinner, while any pick is still downloading).
+    const refreshPopular = useCallback(async (options) => {
+        if (options?.showLoading) {
+            store.getState().setPopularLoading(true);
+        }
+        try {
+            const response = await fetch("/discover/popular", {
+                credentials: "same-origin",
+                cache: "no-store",
+                headers: { Accept: "application/json" }
+            });
+            const payload = await response.json().catch(() => ({}));
+            if (!response.ok) {
+                throw new Error(typeof payload.error === "string" && payload.error ? payload.error : "Unable to load popular formats.");
+            }
+            store.getState().setPopularTemplates(Array.isArray(payload.templates) ? payload.templates : []);
+        }
+        catch (fetchError) {
+            if (options?.showLoading) {
+                store.getState().setPopularError(fetchError instanceof Error ? fetchError.message : "Unable to load popular formats.");
+            }
+            else {
+                debugError("homepage.popular_refresh_failed", { message: fetchError instanceof Error ? fetchError.message : String(fetchError) });
+            }
+        }
+    }, [store]);
+    const popularLoaded = useStore(store, (state) => state.popularLoaded);
+    useEffect(() => {
+        if (view !== "popular" || popularLoaded) {
+            return;
+        }
+        void refreshPopular({ showLoading: true });
+    }, [view, popularLoaded, refreshPopular]);
+    const hasProcessingPopular = view === "popular" && popularTemplates.some((template) => template.status === "processing");
+    useEffect(() => {
+        if (!hasProcessingPopular) {
+            return;
+        }
+        const timer = window.setInterval(() => {
+            void refreshPopular();
+        }, 8000);
+        return () => window.clearInterval(timer);
+    }, [hasProcessingPopular, refreshPopular]);
     const handleDeleteTemplate = useCallback(async (templateId) => {
         try {
             const response = await fetch(`/discover/templates/${encodeURIComponent(templateId)}`, {
@@ -219,7 +268,7 @@ function HomepageClientApp({ boot }) {
             return { ok: false, error: submitError instanceof Error ? submitError.message : "Unable to add that video." };
         }
     }, [refreshFeed]);
-    return (_jsx(HomepageShell, { account: boot.account, templates: templates, visibleTemplates: visibleTemplates, searchQuery: searchQuery, bookmarksOnly: bookmarksOnly, bookmarks: bookmarks, loading: loading, error: error, skillEndpointPrefix: boot.skillEndpointPrefix, onSearchQueryChange: (value) => store.getState().setSearchQuery(value), onBookmarksOnlyChange: (value) => store.getState().setBookmarksOnly(value), onToggleBookmark: (templateId) => store.getState().toggleBookmark(templateId), onAddTemplate: handleAddTemplate, onDeleteTemplate: handleDeleteTemplate }));
+    return (_jsx(HomepageShell, { account: boot.account, templates: templates, visibleTemplates: visibleTemplates, searchQuery: searchQuery, bookmarksOnly: bookmarksOnly, bookmarks: bookmarks, loading: loading, error: error, view: view, popularTemplates: popularTemplates, popularLoading: popularLoading, popularError: popularError, skillEndpointPrefix: boot.skillEndpointPrefix, onSearchQueryChange: (value) => store.getState().setSearchQuery(value), onBookmarksOnlyChange: (value) => store.getState().setBookmarksOnly(value), onViewChange: (value) => store.getState().setView(value), onToggleBookmark: (templateId) => store.getState().toggleBookmark(templateId), onAddTemplate: handleAddTemplate, onDeleteTemplate: handleDeleteTemplate }));
 }
 const boot = readBoot();
 const root = document.getElementById("homepage-root");