@mevdragon/vidfarm-devcli 0.15.0 → 0.17.0

package/dist/src/services/serverless-records.js

@@ -591,6 +591,15 @@ class ServerlessRecordsServiceImpl {
         // so the coarse keyword filter never fights the TTL cache.
         return filterAndRankBySearch(this.templatesFeedCache.records, input.query).slice(0, limit);
     }
+    // Curated "Popular" picks: the handful of public templates flagged with a
+    // popularGroup. Drawn from the same cached feed as listTemplatesFeed (the set
+    // is tiny), ordered by popularRank so the editorial sequence is preserved.
+    async listPopularTemplates() {
+        const feed = await this.listTemplatesFeed({ limit: ServerlessRecordsServiceImpl.TEMPLATES_FEED_MAX });
+        return feed
+            .filter((record) => typeof record.popularGroup === "string" && record.popularGroup.trim().length > 0)
+            .sort((a, b) => (a.popularRank ?? 0) - (b.popularRank ?? 0));
+    }
     async queryTemplatesFeed() {
         const response = await dynamodb.send(new QueryCommand({
             TableName: requireMainTableName(),
@@ -645,6 +654,16 @@ class ServerlessRecordsServiceImpl {
         const updated = await this.putRecord("ready_post", { ...post, status: "deleted", deletedAt: nowIso(), updatedAt: nowIso() });
         return updated;
     }
+    async setReadyPostMedia(input) {
+        const post = await this.getReadyPost(input.postId);
+        if (!post || post.customerId !== input.customerId)
+            return null;
+        return this.putRecord("ready_post", {
+            ...post,
+            mediaAssets: input.mediaAssets,
+            updatedAt: nowIso()
+        });
+    }
     async setReadyPostZip(input) {
         const post = await this.getReadyPost(input.postId);
         if (!post || post.customerId !== input.customerId)
@@ -656,6 +675,50 @@ class ServerlessRecordsServiceImpl {
             updatedAt: nowIso()
         });
     }
+    async createSwipeCustomization(input) {
+        const timestamp = nowIso();
+        return this.putRecord("swipe_customization", {
+            id: input.id ?? createIdV7("swipe"),
+            customerId: input.customerId,
+            templateId: input.templateId,
+            forkId: input.forkId ?? null,
+            sourceTitle: input.sourceTitle ?? null,
+            status: input.status ?? "customizing",
+            pipelineVersion: input.pipelineVersion ?? null,
+            tailoredTitle: input.tailoredTitle ?? null,
+            tailoredCaption: input.tailoredCaption ?? "",
+            tailoredPinnedComment: input.tailoredPinnedComment ?? null,
+            captionStyleId: input.captionStyleId ?? null,
+            previewSourceUrl: input.previewSourceUrl ?? null,
+            durationSeconds: input.durationSeconds ?? null,
+            aspect: input.aspect ?? null,
+            jobId: input.jobId ?? null,
+            renderJobId: input.renderJobId ?? null,
+            readyPostId: input.readyPostId ?? null,
+            error: input.error ?? null,
+            decidedAt: input.decidedAt ?? null,
+            createdAt: input.createdAt ?? timestamp,
+            updatedAt: timestamp
+        });
+    }
+    async getSwipeCustomization(id) {
+        return this.getById("swipe_customization", id);
+    }
+    async listSwipeCustomizationsForCustomer(customerId) {
+        return this.listByCustomer("swipe_customization", customerId);
+    }
+    async updateSwipeCustomization(input) {
+        const existing = await this.getSwipeCustomization(input.id);
+        if (!existing || existing.customerId !== input.customerId)
+            return null;
+        return this.putRecord("swipe_customization", {
+            ...existing,
+            ...input.patch,
+            id: existing.id,
+            customerId: existing.customerId,
+            updatedAt: nowIso()
+        });
+    }
     async createPostSchedule(input) {
         const timestamp = nowIso();
         return this.putRecord("post_schedule", {

package/dist/src/services/swipe-customize.js

@@ -0,0 +1,434 @@
+// Swipe-mode customization brain + progressive queue.
+//
+// Takes a decomposed template whose footage is GhostCut-clean (plays a `-no-subs`
+// mirror) and that ALREADY has on-screen caption elements, clones its canonical
+// fork into a private derivative, then RE-CAPTIONS it: each original caption's
+// TEXT is rewritten to sell the customer's product while its timing (data-start/
+// duration), position (left/top) and styling stay exactly as the original — so
+// the new ad keeps the source video's caption tempo and choreography. Only the
+// words change. The LLM runs on the customer's own saved keys (BYOK), never billed.
+import { parseHTML } from "linkedom";
+import { serverlessRecords } from "./serverless-records.js";
+import { StorageService } from "./storage.js";
+import { ProviderService } from "./providers.js";
+import { cuesFromText } from "./captions.js";
+import { sanitizeCompositionHtml } from "./composition-sanitize.js";
+import { writeForkManifest } from "./fork-manifest.js";
+import { insertCaptionLayers } from "../devcli/composition-edit.js";
+const storage = new StorageService();
+const providers = new ProviderService();
+export const SWIPE_STACK_TARGET_DEPTH = 5;
+const ELIGIBILITY_SCAN_LIMIT = 80;
+const DEFAULT_CAPTION_STYLE = "word-pop";
+// Minimum original captions a template must have to be worth re-captioning.
+const MIN_CAPTION_SLOTS = 2;
+// Bump when the customize pipeline changes shape enough that variants built by
+// the previous pipeline should be pulled from the deck. v1 = the tack-on
+// pipeline (insertCaptionLayers word-pop over the original captions — the
+// double-caption artifact); v2 = in-place recaption. Un-swiped rows from older
+// versions are lazily marked "superseded" (see reconcileSwipeRows) which drops
+// them from the deck AND frees their template to be customized again properly.
+// Rows the customer already decided on (approved/rejected) are never touched.
+export const SWIPE_PIPELINE_VERSION = 2;
+// A "customizing" row whose lambda died mid-flight would otherwise occupy a
+// refill buffer slot forever; past the api lambda's max runtime it can't still
+// be live, so supersede it. Failed rows get a cooldown then are superseded too,
+// freeing their template for a retry (bounds a deterministic failure to one
+// LLM call per cooldown, and lets transient LLM flakes self-heal).
+const CUSTOMIZING_WEDGE_MS = 20 * 60 * 1000;
+const FAILED_RETRY_COOLDOWN_MS = 30 * 60 * 1000;
+function isStaleSwipeRow(row) {
+    const ageMs = Date.now() - Date.parse(String(row.updatedAt ?? row.createdAt ?? ""));
+    if (row.status === "customizing" && Number.isFinite(ageMs) && ageMs > CUSTOMIZING_WEDGE_MS)
+        return true;
+    if (row.status === "failed" && Number.isFinite(ageMs) && ageMs > FAILED_RETRY_COOLDOWN_MS)
+        return true;
+    if ((row.pipelineVersion ?? 1) >= SWIPE_PIPELINE_VERSION)
+        return false;
+    return row.status === "ready" || row.status === "customizing" || row.status === "failed";
+}
+// Lazily migrate a customer's rows: supersede every un-swiped variant built by
+// an older pipeline. Idempotent (superseded rows are no longer stale) and cheap
+// after the first pass. Returns the rows with the patches applied.
+export async function reconcileSwipeRows(customerId, rows) {
+    const out = [];
+    for (const row of rows) {
+        if (!isStaleSwipeRow(row)) {
+            out.push(row);
+            continue;
+        }
+        const updated = await serverlessRecords.updateSwipeCustomization({
+            customerId,
+            id: row.id,
+            patch: { status: "superseded" }
+        });
+        out.push(updated ?? { ...row, status: "superseded" });
+    }
+    return out;
+}
+const TEXT_MODEL_DEFAULTS = {
+    openai: "gpt-5.4-mini",
+    gemini: "gemini-2.5-flash",
+    openrouter: "qwen/qwen3.6-plus",
+    perplexity: "sonar"
+};
+const TEXT_PROVIDER_PRIORITY = ["openai", "gemini", "openrouter", "perplexity"];
+export class NoProviderKeyError extends Error {
+    constructor() {
+        super("Swipe customization needs an AI provider key. Add an OpenAI, Gemini, or OpenRouter key in Settings.");
+        this.name = "NoProviderKeyError";
+    }
+}
+// ---------------------------------------------------------------------------
+// Eligibility: decomposed (defaultForkId), GhostCut-clean (composition plays a
+// `-no-subs` mirror so there's no baked text to clash with), HAS caption slots
+// to re-caption, and not already customized for this customer.
+const MIRROR_MARKER = /-no-subs|\/ghostcut\//i;
+// Count static caption elements ([data-layer-kind="caption"] that are not the
+// animated word-by-word kind) via cheap regex — canonical forks only carry the
+// original static captions, so this is the recaption slot count. Style blocks
+// are dropped first: caption-animation CSS contains `[data-caption-animation=`
+// selectors that would otherwise inflate the animated count.
+export function countStaticCaptionsInHtml(html) {
+    const markup = html.replace(/<style[\s\S]*?<\/style>/gi, "");
+    const total = (markup.match(/data-layer-kind="caption"/g) ?? []).length;
+    const animated = (markup.match(/data-caption-animation=/g) ?? []).length;
+    return Math.max(0, total - animated);
+}
+async function readCanonicalEligibility(defaultForkId) {
+    const html = await storage.readText(storage.compositionForkWorkingKey(defaultForkId, "composition.html"));
+    if (!html)
+        return { eligible: false, sourceUrl: null };
+    const isMirror = MIRROR_MARKER.test(html);
+    const sourceUrl = readCompositionSourceUrl(html);
+    const captionSlots = countStaticCaptionsInHtml(html);
+    return { eligible: isMirror && captionSlots >= MIN_CAPTION_SLOTS, sourceUrl };
+}
+export async function listEligibleTemplates(customerId, limit = SWIPE_STACK_TARGET_DEPTH * 4) {
+    const feed = await serverlessRecords.listTemplatesFeed({ limit: ELIGIBILITY_SCAN_LIMIT });
+    const listed = await serverlessRecords.listSwipeCustomizationsForCustomer(customerId);
+    const existing = await reconcileSwipeRows(customerId, listed);
+    // Superseded rows do NOT consume their template — the whole point is letting
+    // the current pipeline re-customize what an older one botched.
+    const alreadyCustomized = new Set(existing.filter((row) => row.status !== "superseded").map((row) => row.templateId));
+    const eligible = [];
+    for (const template of feed) {
+        if (eligible.length >= limit)
+            break;
+        if (!template.defaultForkId)
+            continue;
+        if (alreadyCustomized.has(template.id))
+            continue;
+        const { eligible: ok, sourceUrl } = await readCanonicalEligibility(template.defaultForkId);
+        if (!ok)
+            continue;
+        eligible.push({ template, sourceUrl });
+    }
+    return eligible;
+}
+function readCompositionSourceUrl(html) {
+    try {
+        const { document } = parseHTML(html);
+        const root = document.querySelector("[data-composition-id]");
+        const fromAttr = root?.getAttribute("data-source-video")?.trim();
+        if (fromAttr && /^https?:\/\//i.test(fromAttr))
+            return fromAttr;
+        const backing = document.querySelector("[data-vf-playback-source]");
+        const backingSrc = (backing?.getAttribute("src") ?? backing?.getAttribute("data-src"))?.trim();
+        if (backingSrc && /^https?:\/\//i.test(backingSrc))
+            return backingSrc;
+        const video = Array.from(document.querySelectorAll("[data-layer-kind=\"video\"]"))
+            .map((n) => n.getAttribute("src")?.trim())
+            .find((src) => src && /^https?:\/\//i.test(src));
+        return video ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+// ---------------------------------------------------------------------------
+// Context (light — tone/theme only; the caption slots are the real input).
+function loadContext(smartDecomposeText) {
+    if (!smartDecomposeText)
+        return { transcript: "", viralDna: "" };
+    try {
+        const result = JSON.parse(smartDecomposeText)?.result ?? {};
+        const transcript = typeof result?.transcript?.text === "string"
+            ? result.transcript.text
+            : Array.isArray(result?.transcript?.segments)
+                ? result.transcript.segments.map((s) => (typeof s?.text === "string" ? s.text : "")).join(" ").trim()
+                : "";
+        const viralDna = typeof result?.viralDna === "string" ? result.viralDna : result?.viralDna ? JSON.stringify(result.viralDna) : "";
+        return { transcript, viralDna };
+    }
+    catch {
+        return { transcript: "", viralDna: "" };
+    }
+}
+// Decompose emits static captions as <div data-layer-kind="caption" ...><span
+// data-vf-text-lines><span data-vf-text-inline style="…">words</span></span></div>
+// — the inline span carries the outline/stroke treatment, so write the new words
+// INTO it rather than flattening the element (`el.textContent =` on the div
+// would strip the treatment — the same trap /editor's set_layer_text hit).
+// data-label mirrors the words for tooling; keep it in sync.
+export function setCaptionSlotText(el, text) {
+    const inline = typeof el.querySelector === "function" ? el.querySelector("[data-vf-text-inline]") : null;
+    (inline ?? el).textContent = text;
+    if (typeof el.getAttribute === "function" && el.getAttribute("data-label") != null) {
+        el.setAttribute("data-label", text.slice(0, 40));
+    }
+}
+// A canonical fork should only carry the original STATIC captions, but if an
+// editor session (or an older customize pipeline) left animated word-by-word
+// caption layers on it, the clone inherits words that fight the recaption —
+// drop them before rewriting. Returns how many were removed.
+export function stripAnimatedCaptionLayers(document) {
+    const root = document.querySelector("[data-composition-id]") ?? document;
+    const nodes = Array.from(root.querySelectorAll("[data-caption-animation]"));
+    for (const node of nodes)
+        node.parentNode?.removeChild(node);
+    return nodes.length;
+}
+export function collectCaptionSlots(document) {
+    const root = document.querySelector("[data-composition-id]") ?? document;
+    return Array.from(root.querySelectorAll('[data-layer-kind="caption"]:not([data-caption-animation])'))
+        .map((el) => ({
+        el,
+        text: String(el.textContent || "").trim().replace(/\s+/g, " "),
+        start: Number(el.getAttribute("data-start")) || 0,
+        duration: Number(el.getAttribute("data-duration")) || 0
+    }))
+        .filter((s) => s.text)
+        .sort((a, b) => a.start - b.start);
+}
+function buildRecaptionPrompt(input) {
+    const { productDescription, slots, context, sourceTitle } = input;
+    const list = slots.map((s, i) => `${i + 1}. [${s.start.toFixed(1)}s-${(s.start + s.duration).toFixed(1)}s] "${s.text}"`).join("\n");
+    return `You are re-captioning a viral video so it now advertises the customer's product. The video's footage, cuts, timing and caption placement all stay the same — you ONLY rewrite the words of each on-screen caption so they sell the product.
+
+CUSTOMER PRODUCT / OFFER:
+${productDescription.trim()}
+
+THE VIDEO
+- Original title: ${sourceTitle}
+- Why it went viral: ${context.viralDna || "(unknown)"}
+- Spoken/heard: ${(context.transcript || "(none)").slice(0, 800)}
+
+ORIGINAL ON-SCREEN CAPTIONS (in order, with timing):
+${list}
+
+TASK
+Rewrite EACH caption above so the video becomes a native-feeling ad for the product. Rules:
+- Return EXACTLY ${slots.length} captions, in the SAME order, one replacement per original.
+- Keep each replacement roughly the SAME LENGTH as its original (it must fit the same on-screen slot) and the SAME BEAT/ROLE (a hook stays a hook, a reveal stays a reveal, a CTA stays a CTA).
+- Sound like an authentic creator, not a corporate ad. No hashtags inside the on-screen captions.
+
+Return STRICTLY valid JSON, no markdown fences:
+{
+  "title": "<=60 char scroll-stopping post title",
+  "socialCaption": "1-2 sentence post caption (may include 1-3 hashtags)",
+  "pinnedComment": "short first-comment CTA, or null",
+  "captions": [ ${slots.map(() => '"..."').join(", ")} ]
+}`;
+}
+function parseJsonLoose(text) {
+    const trimmed = text.trim().replace(/^```(?:json)?/i, "").replace(/```$/i, "").trim();
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        const start = trimmed.indexOf("{");
+        const end = trimmed.lastIndexOf("}");
+        if (start >= 0 && end > start)
+            return JSON.parse(trimmed.slice(start, end + 1));
+        throw new Error("LLM did not return parseable JSON.");
+    }
+}
+async function generateRecaption(input) {
+    const available = await providers.listAvailableProvidersAsync(input.customerId);
+    const provider = TEXT_PROVIDER_PRIORITY.find((p) => available.includes(p)) ?? available[0];
+    if (!provider)
+        throw new NoProviderKeyError();
+    const generated = await providers.generateText({
+        customerId: input.customerId,
+        jobId: input.jobId,
+        workerId: "swipe-customize",
+        provider,
+        model: TEXT_MODEL_DEFAULTS[provider],
+        prompt: input.prompt,
+        temperature: 0.7,
+        responseFormat: "json"
+    });
+    const parsed = parseJsonLoose(generated.text);
+    const str = (v) => (typeof v === "string" && v.trim() ? v.trim() : "");
+    const captions = Array.isArray(parsed.captions) ? parsed.captions.map((c) => str(c)) : [];
+    return {
+        title: str(parsed.title) || input.jobId,
+        socialCaption: str(parsed.socialCaption) || str(parsed.caption),
+        pinnedComment: str(parsed.pinnedComment) || null,
+        captions
+    };
+}
+// ---------------------------------------------------------------------------
+// Clone the canonical decomposed fork's working state into a private derivative.
+async function cloneDecomposedFork(input) {
+    const canonical = await serverlessRecords.getCompositionFork(input.canonicalForkId);
+    const fork = await serverlessRecords.createCompositionFork({
+        customerId: input.customerId,
+        templateId: input.template.id,
+        parentForkId: input.canonicalForkId,
+        parentVersion: canonical?.latestVersion ?? null,
+        visibility: "private",
+        title: input.title
+    });
+    for (const file of ["composition.html", "composition.json", "cast.json", "product-placement.json", "scene-annotations.json"]) {
+        const text = await storage.readText(storage.compositionForkWorkingKey(input.canonicalForkId, file));
+        if (text == null)
+            continue;
+        const contentType = file.endsWith(".html") ? "text/html; charset=utf-8" : "application/json";
+        await storage.putText(storage.compositionForkWorkingKey(fork.id, file), text, contentType);
+    }
+    await writeForkManifest(storage, fork, { kind: "working" });
+    return fork.id;
+}
+function readCompositionDurationSeconds(html) {
+    try {
+        const { document } = parseHTML(html);
+        const root = document.querySelector("[data-composition-id]") ?? document.querySelector("[data-duration]");
+        const dur = Number(root?.getAttribute("data-duration"));
+        return Number.isFinite(dur) && dur > 0 ? dur : null;
+    }
+    catch {
+        return null;
+    }
+}
+// Run ONE full recaption: clone → read caption slots → AI rewrites each in place
+// → persist. Creates the record up front (status "customizing") and drives it to
+// "ready" or "failed".
+export async function customizeTemplateForProduct(input) {
+    const { customerId, template, productDescription } = input;
+    const sourceTitle = template.title ?? template.id;
+    const availableProviders = await providers.listAvailableProvidersAsync(customerId);
+    if (!availableProviders.length)
+        throw new NoProviderKeyError();
+    const record = await serverlessRecords.createSwipeCustomization({
+        customerId,
+        templateId: template.id,
+        sourceTitle,
+        status: "customizing",
+        pipelineVersion: SWIPE_PIPELINE_VERSION
+    });
+    try {
+        if (!template.defaultForkId)
+            throw new Error("Template is not decomposed (no default fork).");
+        const forkId = await cloneDecomposedFork({ customerId, template, canonicalForkId: template.defaultForkId, title: sourceTitle });
+        const context = loadContext(await storage.readText(storage.compositionForkWorkingKey(template.defaultForkId, "smart-decompose.json")));
+        const rawHtml = await storage.readText(storage.compositionForkWorkingKey(forkId, "composition.html"));
+        if (!rawHtml)
+            throw new Error("Cloned fork has no composition.html.");
+        // Sanitize the BASE document up front (before any LLM text lands in it):
+        // sanitizeCompositionHtml is raw-regex hardening, and run after the rewrite
+        // it can chew visible copy (e.g. a caption containing "hold on tight = ...").
+        // Text inserted below goes through linkedom textContent/setAttribute, which
+        // entity-escapes on serialization, so the persisted doc stays inert.
+        const { html } = sanitizeCompositionHtml(rawHtml);
+        const durationSeconds = readCompositionDurationSeconds(html) ?? 30;
+        // documentElement.outerHTML drops the doctype (it's a sibling node) — keep
+        // the preview iframe out of quirks mode by re-prepending it.
+        const doctype = /^\s*<!doctype/i.test(html) ? "<!DOCTYPE html>\n" : "";
+        const { document } = parseHTML(html);
+        stripAnimatedCaptionLayers(document);
+        // Only rewrite captions that carry WORDS in any script (\p{L} covers CJK,
+        // Cyrillic, Arabic, … — viral sources are not all English). Numeric/emoji-only
+        // captions (e.g. a "6,5,4,3,2,1" countdown overlay) are structural to the
+        // video's rhythm — the user wants that tempo/choreography kept — so leave
+        // them untouched.
+        const slots = collectCaptionSlots(document).filter((s) => /\p{L}/u.test(s.text));
+        const copy = await generateRecaption({
+            customerId,
+            jobId: record.id,
+            prompt: buildRecaptionPrompt({ productDescription, slots, context, sourceTitle })
+        });
+        // The prompt demands EXACTLY slots.length captions. json_object mode only
+        // guarantees valid JSON, not shape — a miscounted/empty/misshapen response
+        // must fail the record (retryable) instead of silently deleting caption
+        // layers below and shipping a caption-stripped card as "ready".
+        if (slots.length) {
+            const usable = copy.captions.filter(Boolean).length;
+            if (copy.captions.length !== slots.length || usable < Math.min(slots.length, MIN_CAPTION_SLOTS)) {
+                throw new Error(`LLM recaption shape mismatch: expected ${slots.length} captions, got ${usable} usable of ${copy.captions.length} returned.`);
+            }
+        }
+        let styleId = "recaption";
+        if (slots.length) {
+            // Rewrite each caption's TEXT in place — timing/position/style untouched.
+            slots.forEach((slot, i) => {
+                const next = copy.captions[i];
+                if (next)
+                    setCaptionSlotText(slot.el, next);
+                else
+                    slot.el.parentNode?.removeChild(slot.el); // no replacement → drop rather than keep off-product text
+            });
+            const serialized = doctype + document.documentElement.outerHTML;
+            await storage.putText(storage.compositionForkWorkingKey(forkId, "composition.html"), serialized, "text/html; charset=utf-8");
+        }
+        else {
+            // No word-bearing caption slots (post-\p{L} this means genuinely word-free:
+            // countdown/emoji overlays only) — page the social caption into fresh
+            // caption layers instead. Serialize from the parsed document so the
+            // animated-layer strip above is kept; the numeric/emoji statics stay (they
+            // are rhythm, and carry no words to conflict with the new copy).
+            const cues = cuesFromText(copy.socialCaption || copy.title, 0, durationSeconds, { maxWordsPerCue: 4 });
+            const applied = insertCaptionLayers(doctype + document.documentElement.outerHTML, cues, { style: DEFAULT_CAPTION_STYLE });
+            styleId = applied.styleId;
+            await storage.putText(storage.compositionForkWorkingKey(forkId, "composition.html"), applied.html, "text/html; charset=utf-8");
+        }
+        const updatedFork = await serverlessRecords.updateCompositionFork({ forkId, patch: {} });
+        if (updatedFork)
+            await writeForkManifest(storage, updatedFork, { kind: "working" });
+        const previewSourceUrl = input.sourceUrl ?? readCompositionSourceUrl(html);
+        return await serverlessRecords.updateSwipeCustomization({
+            customerId,
+            id: record.id,
+            patch: {
+                forkId,
+                status: "ready",
+                tailoredTitle: copy.title,
+                tailoredCaption: copy.socialCaption,
+                tailoredPinnedComment: copy.pinnedComment,
+                captionStyleId: styleId,
+                previewSourceUrl,
+                durationSeconds,
+                jobId: record.id
+            }
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const failed = await serverlessRecords.updateSwipeCustomization({
+            customerId,
+            id: record.id,
+            patch: { status: "failed", error: message }
+        });
+        if (error instanceof NoProviderKeyError)
+            throw error;
+        return failed ?? { ...record, status: "failed", error: message };
+    }
+}
+export async function customizeOneMore(input) {
+    const eligible = await listEligibleTemplates(input.customerId, 1);
+    const pick = eligible[0];
+    if (!pick)
+        return null;
+    return customizeTemplateForProduct({
+        customerId: input.customerId,
+        template: pick.template,
+        sourceUrl: pick.sourceUrl,
+        productDescription: input.productDescription
+    });
+}
+export async function countReadyCustomizations(customerId) {
+    const rows = await serverlessRecords.listSwipeCustomizationsForCustomer(customerId);
+    return rows.filter((row) => row.status === "ready" && !isStaleSwipeRow(row)).length;
+}
+//# sourceMappingURL=swipe-customize.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mevdragon/vidfarm-devcli",
-  "version": "0.15.0",
+  "version": "0.17.0",
   "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": {