@officexapp/vidfarm-devcli 0.21.31 → 0.21.33

package/dist/src/devcli/dedupe-local.js

@@ -0,0 +1,209 @@
+// Bundle-safe LOCAL deduplication for the published devcli.
+//
+// Deduplication = nudging a finished render's geometry, color, timing and grain
+// by a couple of percent so a platform's duplicate-content fingerprint reads it
+// as a NEW upload, while a human sees no difference. It is what lets one good
+// video be posted across several accounts/slots without the second and third
+// posts being suppressed as reused content.
+//
+// This is a pure ffmpeg op with zero server dependency (exactly like
+// greenscreen-local.ts), so it runs FREE and offline in the shipped CLI. Every
+// transform comes from lib/dedupe-recipe.ts — the SAME module the cloud
+// primitive (services/media-processing.dedupeMediaAsset) uses — so local output
+// matches cloud output knob for knob. No backend module is imported here, which
+// keeps the pack guard happy.
+import { spawn } from "node:child_process";
+import { existsSync, statSync } from "node:fs";
+import path from "node:path";
+import { resolveFfmpeg, resolveFfprobe, hasFfmpeg } from "../services/clip-curation/ffmpeg.js";
+import { buildDedupeFfmpegPlan, dedupeCrfForVariant, describeDedupeEffects, resolveDedupeEffects, DEDUPE_DEFAULT_PRESET } from "../lib/dedupe-recipe.js";
+export { DEDUPE_PRESETS, DEDUPE_DEFAULT_PRESET, describeDedupeEffects, isDedupePresetName, resolveDedupeEffects } from "../lib/dedupe-recipe.js";
+/** True when a usable ffmpeg is available (bundled ffmpeg-static or on PATH). */
+export async function localDedupeAvailable() {
+    return hasFfmpeg();
+}
+async function runFfmpeg(bin, args) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(bin, args, { stdio: ["ignore", "ignore", "pipe"] });
+        let stderr = "";
+        child.stderr.on("data", (d) => (stderr += d.toString()));
+        child.on("error", reject);
+        child.on("close", (code) => resolve({ code: code ?? 0, stderr }));
+    });
+}
+async function probe(filePath) {
+    const ffprobe = await resolveFfprobe();
+    const args = ["-v", "error", "-print_format", "json", "-show_format", "-show_streams", filePath];
+    const raw = await new Promise((resolve) => {
+        const child = spawn(ffprobe, args, { stdio: ["ignore", "pipe", "ignore"] });
+        let out = "";
+        child.stdout.on("data", (d) => (out += d.toString()));
+        child.on("error", () => resolve(""));
+        child.on("close", () => resolve(out));
+    });
+    let parsed = {};
+    try {
+        parsed = JSON.parse(raw || "{}");
+    }
+    catch {
+        parsed = {};
+    }
+    const streams = (Array.isArray(parsed.streams) ? parsed.streams : []);
+    const video = streams.find((stream) => stream.codec_type === "video");
+    const format = (parsed.format ?? {});
+    let fps = null;
+    if (typeof video?.avg_frame_rate === "string") {
+        const [numerator, denominator] = video.avg_frame_rate.split("/").map(Number);
+        if (numerator && denominator)
+            fps = numerator / denominator;
+    }
+    return {
+        width: typeof video?.width === "number" ? video.width : null,
+        height: typeof video?.height === "number" ? video.height : null,
+        durationSec: Number(format.duration ?? video?.duration ?? 0) || 0,
+        fps,
+        hasAudio: streams.some((stream) => stream.codec_type === "audio"),
+        hasVideo: Boolean(video)
+    };
+}
+/**
+ * Deduplicate an image or video LOCALLY with ffmpeg — free, offline, no wallet.
+ * Cloud-parity: identical filter graph to `primitive:media_dedupe` (engine
+ * `ffmpeg`).
+ *
+ * Two things happen beyond the visible transforms:
+ *   • `-map_metadata -1` strips creation time / encoder / source handler, which
+ *     some platforms compare BEFORE they compare pixels.
+ *   • The CRF is walked ±1 per variant, so the coded bitstream differs even
+ *     where the decoded frames are near-identical.
+ *
+ * Retries without the `perspective` (skew) stage on ffmpeg builds compiled
+ * without vf_perspective rather than failing the whole pass.
+ */
+export async function dedupeMediaLocal(input) {
+    if (!existsSync(input.sourcePath))
+        throw new Error(`No such source file: ${input.sourcePath}`);
+    const info = await probe(input.sourcePath);
+    const mediaType = input.mediaType
+        ?? (info.hasVideo && info.durationSec > 0.25 ? "video" : "image");
+    const variant = Math.max(1, Math.round(input.variant ?? 1) || 1);
+    const preset = input.preset ?? DEDUPE_DEFAULT_PRESET;
+    const effects = resolveDedupeEffects({
+        preset,
+        effects: input.effects,
+        variant,
+        seed: input.seed,
+        jitter: input.jitter
+    });
+    const plan = buildDedupeFfmpegPlan({
+        effects,
+        mediaType,
+        width: info.width ?? input.width ?? 1080,
+        height: info.height ?? input.height ?? 1920,
+        outWidth: input.width ?? info.width ?? null,
+        outHeight: input.height ?? info.height ?? null,
+        sourceFps: info.fps,
+        tintColor: input.tintColor ?? null,
+        tintOpacity: input.tintOpacity ?? null
+    });
+    const crf = dedupeCrfForVariant(input.crf ?? 21, variant, input.seed ?? "");
+    const stripMetadata = input.stripMetadata ?? true;
+    const isWebp = /\.webp$/i.test(input.outputPath);
+    const isJpeg = /\.jpe?g$/i.test(input.outputPath);
+    const ffmpeg = await resolveFfmpeg();
+    const buildArgs = (videoFilter) => mediaType === "video"
+        ? [
+            "-hide_banner", "-y",
+            "-i", input.sourcePath,
+            "-map", "0:v:0",
+            "-map", "0:a:0?",
+            "-vf", videoFilter,
+            ...(plan.audioFilter && info.hasAudio ? ["-af", plan.audioFilter] : []),
+            ...(stripMetadata ? ["-map_metadata", "-1"] : []),
+            "-c:v", "libx264",
+            "-preset", input.x264Preset ?? "veryfast",
+            "-crf", String(crf),
+            "-pix_fmt", "yuv420p",
+            "-movflags", "+faststart",
+            "-c:a", "aac",
+            "-b:a", `${input.audioBitrateKbps ?? 128}k`,
+            "-ar", "48000",
+            input.outputPath
+        ]
+        : [
+            "-hide_banner", "-y",
+            "-i", input.sourcePath,
+            "-frames:v", "1",
+            "-vf", videoFilter,
+            ...(stripMetadata ? ["-map_metadata", "-1"] : []),
+            ...(isWebp ? ["-c:v", "libwebp", "-quality", "92"] : []),
+            ...(isJpeg ? ["-q:v", "3"] : []),
+            input.outputPath
+        ];
+    // Distinguish "this recipe has no shear" from "the shear was dropped": only
+    // the latter is worth warning about.
+    const skewRequested = plan.videoFilter !== plan.videoFilterWithoutSkew;
+    let skewApplied = skewRequested;
+    let run = await runFfmpeg(ffmpeg, buildArgs(plan.videoFilter));
+    if ((run.code !== 0 || !existsSync(input.outputPath)) && skewRequested) {
+        // Minimal ffmpeg builds ship without vf_perspective. Losing the shear beats
+        // losing the whole dedupe pass.
+        skewApplied = false;
+        run = await runFfmpeg(ffmpeg, buildArgs(plan.videoFilterWithoutSkew));
+    }
+    if (run.code !== 0 || !existsSync(input.outputPath)) {
+        throw new Error(`Local dedupe failed (ffmpeg exit ${run.code})${tail(run.stderr)}.`);
+    }
+    const skewDropped = skewRequested && !skewApplied;
+    return {
+        outputPath: input.outputPath,
+        mediaType,
+        effects,
+        preset,
+        variant,
+        notes: skewDropped ? [...plan.notes, "skew skipped — this ffmpeg has no vf_perspective"] : plan.notes,
+        effectiveZoom: plan.effectiveZoom,
+        speed: plan.speed,
+        crf,
+        skewApplied,
+        skewDropped,
+        sourceWidth: info.width,
+        sourceHeight: info.height,
+        bytes: safeSize(input.outputPath)
+    };
+}
+/** One-line summary of what a resolved recipe does, for CLI output. */
+export function describeLocalDedupe(result) {
+    const summary = describeDedupeEffects(result.effects, result.preset);
+    // A rotate forces a bigger centre-crop than asked for (the zoom that hides the
+    // black corners). Say so — on a tall frame it is a real framing change.
+    if (result.effectiveZoom > result.effects.zoom + 0.0005) {
+        const applied = `${((result.effectiveZoom - 1) * 100).toFixed(1)}%`;
+        return `${summary} → crops ${applied} to hide the rotate corners (--rotate 0 keeps your framing)`;
+    }
+    return summary;
+}
+/**
+ * Default output path next to a source: `<stem>.dedupe.<ext>` for a one-off,
+ * `<stem>.dedupe-02.<ext>` and up for batch variants (variant 1 keeps the plain
+ * name so a single-copy run reads cleanly).
+ */
+export function defaultDedupeOutPath(sourcePath, variant = 1) {
+    const ext = path.extname(sourcePath) || ".mp4";
+    const stem = path.basename(sourcePath, ext);
+    const suffix = variant > 1 ? `.dedupe-${String(variant).padStart(2, "0")}` : ".dedupe";
+    return path.resolve(path.dirname(path.resolve(sourcePath)), `${stem}${suffix}${ext}`);
+}
+function safeSize(filePath) {
+    try {
+        return statSync(filePath).size;
+    }
+    catch {
+        return 0;
+    }
+}
+function tail(stderr) {
+    const trimmed = stderr.trim().split("\n").slice(-3).join("\n");
+    return trimmed ? `:\n${trimmed}` : "";
+}
+//# sourceMappingURL=dedupe-local.js.map

package/dist/src/devcli/qa-check.js

@@ -103,6 +103,38 @@ function radiusPx(style) {
     const num = Number((raw.match(/(-?[\d.]+)px/) ?? [])[1] ?? 0);
     return Number.isFinite(num) ? num : 0;
 }
+/** Walk self + ancestors up to the composition root. */
+function selfAndAncestors(node) {
+    const chain = [];
+    let cursor = node;
+    while (cursor && typeof cursor.getAttribute === "function") {
+        chain.push(cursor);
+        if (cursor.getAttribute("data-composition-id") != null)
+            break;
+        cursor = cursor.parentNode;
+    }
+    return chain;
+}
+/**
+ * Is this node part of an animated caption run? The active-word highlight IS a
+ * pill, and it is the one legitimate pill in a video — it tracks the spoken
+ * word instead of sitting there like a badge.
+ */
+function isAnimatedCaptionPart(node) {
+    return selfAndAncestors(node).some((n) => n.getAttribute("data-caption-animation") != null || n.getAttribute("data-cap-word") != null);
+}
+// Native platform artifacts that legitimately use rounded, filled bubbles:
+// iMessage/DM threads, TikTok comment cards, fake chat UI. These are social
+// furniture, not web furniture, so the badge rule must never fire on them.
+const MOCK_UI_HINT = /(imessage|messenger|whatsapp|bubble|chat|sms|dm-|comment|reply|tweet|notification|caption-pill)/i;
+function isMockSocialUi(node) {
+    return selfAndAncestors(node).some((n) => {
+        if (n.getAttribute("data-vf-mock-ui") != null)
+            return true;
+        const hay = `${n.getAttribute("class") ?? ""} ${n.getAttribute("data-label") ?? ""} ${n.getAttribute("data-slug") ?? ""} ${n.getAttribute("id") ?? ""}`;
+        return MOCK_UI_HINT.test(hay);
+    });
+}
 function primaryFamily(raw) {
     return String(raw).split(",")[0].replace(/['"]/g, "").trim().toLowerCase();
 }
@@ -264,6 +296,42 @@ export function qaCompositionHtml(html) {
             fix: "Say each benefit as its OWN timed caption line on the footage, one at a time, in the font regime. One idea per beat reads far better than a chip strip."
         });
     }
+    // ── Rule: standalone badge pill ────────────────────────────────────────────
+    // The lonely capsule: ONE rounded, padded, filled tag holding a static stat or
+    // label — "10 hrs / week", "STEP 2", "EP.01", "+40%". badge-chip-row needs two
+    // siblings and cta-button needs action copy, so a single stat pill used to slip
+    // through both — and it is the most common surviving web tell in practice.
+    // Two signals: a capsule shape (radius well past a caption band) AND a fill.
+    // Excluded on purpose: active-word caption highlights (they MOVE with the
+    // spoken word — the one legitimate pill) and mock social UI, which is native.
+    for (const node of all) {
+        const text = textOf(node);
+        if (!text || text.length > 45)
+            continue;
+        const style = styleString(node);
+        const radius = radiusPx(style);
+        const filled = /background(?:-color|-image)?\s*:/.test(style) && !/background[^;]*:\s*(none|transparent)/.test(style);
+        // A caption band tops out around 8px; 20px+ on a text-sized box is a capsule.
+        if (!filled || radius < 20)
+            continue;
+        // Padding is what turns a hugging band into a tag. Either axis counts.
+        const padded = hasDecl(style, "padding") || hasDecl(style, "padding-left") || hasDecl(style, "padding-inline") ||
+            hasDecl(style, "padding-top") || hasDecl(style, "padding-block");
+        if (!padded)
+            continue;
+        if (isAnimatedCaptionPart(node) || isMockSocialUi(node))
+            continue;
+        // A capsule wrapping several elements is a card — card-panel's job, not ours.
+        if (Array.from(node.children ?? []).filter((c) => textOf(c)).length >= 2)
+            continue;
+        push({
+            rule: "static-pill",
+            severity: "error",
+            message: `Badge pill ("${text.slice(0, 30)}") — a filled ${radius >= 9999 ? "fully-rounded" : `${Math.round(radius)}px`} capsule with padding around static text. One is still a badge.`,
+            where: label(node, "pill"),
+            fix: "Drop the capsule and set the words themselves: bigger, heavier, ALL-CAPS, or an accent color — or circle/underline them. The only legitimate pill tracks the spoken word (set_captions spotlight/karaoke). Mock social UI is exempt: mark it data-vf-mock-ui."
+        });
+    }
     // ── Rule: card / panel / glassmorphism ─────────────────────────────────────
     // A rounded box with a border, shadow, or frosted blur, holding more than one
     // piece of content. A tight caption BAND is legal (small radius, one run) —