npm - @mevdragon/vidfarm-devcli - Versions diffs - 0.17.0 → 0.18.1 - Mend

@mevdragon/vidfarm-devcli 0.17.0 → 0.18.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (55) hide show

package/.agents/skills/vidfarm-media/SKILL.md +43 -6
package/SKILL.director.md +37 -23
package/SKILL.platform.md +6 -6
package/demo/dist/app.js +69 -69
package/demo/dist/favicon.ico +0 -0
package/dist/src/app.js +1832 -213
package/dist/src/cli.js +238 -17
package/dist/src/devcli/clip-store.js +29 -2
package/dist/src/devcli/clips.js +116 -73
package/dist/src/devcli/composition-edit.js +262 -0
package/dist/src/devcli/timeline-edit.js +283 -0
package/dist/src/editor-chat.js +29 -6
package/dist/src/frontend/discover-client.js +130 -0
package/dist/src/frontend/discover-store.js +23 -0
package/dist/src/frontend/file-directory.js +744 -0
package/dist/src/frontend/template-editor-chat.js +22 -19
package/dist/src/landing-page.js +24 -7
package/dist/src/page-shell.js +25 -1
package/dist/src/reskin/agency-page.js +214 -170
package/dist/src/reskin/calendar-page.js +503 -187
package/dist/src/reskin/chat-page.js +739 -299
package/dist/src/reskin/discover-page.js +1450 -279
package/dist/src/reskin/document.js +1392 -16
package/dist/src/reskin/help-page.js +139 -100
package/dist/src/reskin/index-page.js +1 -1
package/dist/src/reskin/inpaint-page.js +547 -0
package/dist/src/reskin/job-runs-page.js +355 -127
package/dist/src/reskin/library-page.js +1188 -317
package/dist/src/reskin/login-page.js +124 -87
package/dist/src/reskin/pricing-page.js +197 -166
package/dist/src/reskin/settings-page.js +566 -187
package/dist/src/reskin/theme.js +434 -17
package/dist/src/services/clip-curation/gemini.js +5 -0
package/dist/src/services/clip-curation/hunt.js +79 -1
package/dist/src/services/clip-curation/index.js +2 -1
package/dist/src/services/clip-curation/local-agent.js +4 -3
package/dist/src/services/clip-curation/media-select.js +85 -0
package/dist/src/services/clip-curation/query.js +5 -1
package/dist/src/services/clip-curation/refine.js +50 -20
package/dist/src/services/clip-curation/scan.js +10 -3
package/dist/src/services/clip-curation/taxonomy.js +3 -1
package/dist/src/services/clip-curation/taxonomy.v1.json +13 -1
package/dist/src/services/clip-records.js +14 -1
package/dist/src/services/clip-search.js +43 -13
package/dist/src/services/file-directory.js +114 -0
package/dist/src/services/storage.js +24 -1
package/dist/src/services/upstream.js +5 -5
package/dist/src/template-editor-shell.js +16 -2
package/package.json +1 -1
package/public/assets/discover-client-app.js +1 -0
package/public/assets/file-directory-app.js +2 -0
package/public/assets/homepage-client-app.js +12 -12
package/public/assets/page-runtime-client-app.js +24 -24
package/src/assets/favicon.ico +0 -0
package/src/assets/logo-vidfarm.png +0 -0

package/dist/src/devcli/composition-edit.js CHANGED Viewed

@@ -606,4 +606,266 @@ export function readTransitions(html) {
         };
     }).sort((a, b) => (a.start - b.start) || (a.track - b.track));
 }
+const KEYFRAME_EASINGS = ["linear", "ease", "ease-in", "ease-out", "ease-in-out", "step-start", "step-end"];
+// Whitelist the CSS timing-function so an easing can never smuggle arbitrary
+// declarations into the injected <style>/inline style. Mirrors the editor's
+// normalizeKeyframeEasing exactly.
+function normalizeKeyframeEasing(raw) {
+    const value = (raw ?? "").trim().toLowerCase();
+    if (KEYFRAME_EASINGS.includes(value))
+        return value;
+    const cb = /^cubic-bezier\(\s*(-?\d*\.?\d+\s*,\s*){3}-?\d*\.?\d+\s*\)$/;
+    if (cb.test(value))
+        return value;
+    const steps = /^steps\(\s*\d+\s*(,\s*(start|end|jump-(start|end|none|both))\s*)?\)$/;
+    if (steps.test(value))
+        return value;
+    return "linear";
+}
+function nodeTimelineId(node) {
+    return node?.getAttribute?.("data-hf-id") || node?.id || "";
+}
+// Couple the timing fields the way the editor's patchElementTiming does: a start
+// or duration change re-derives data-end; a track change re-derives z-index (the
+// runtime/publish normalizer keeps z-index == track); a media in-point (video/
+// audio) rides on data-media-start + data-playback-start together.
+function applyTimingToNode(node, updates) {
+    let start = numAttr(node, "data-start");
+    let duration = numAttr(node, "data-duration");
+    if (updates.start !== undefined) {
+        start = updates.start;
+        node.setAttribute("data-start", String(round3(start)));
+    }
+    if (updates.duration !== undefined) {
+        duration = updates.duration;
+        node.setAttribute("data-duration", String(round3(duration)));
+    }
+    if (updates.start !== undefined || updates.duration !== undefined) {
+        const s = Number.isFinite(start) ? start : 0;
+        const d = Number.isFinite(duration) ? duration : 0;
+        node.setAttribute("data-end", String(round3(s + d)));
+    }
+    if (updates.track !== undefined) {
+        const t = Math.max(0, Math.trunc(updates.track));
+        node.setAttribute("data-track-index", String(t));
+        upsertStyleDecl(node, "z-index", String(t));
+    }
+    if (updates.playbackStart !== undefined) {
+        const ps = String(round3(Math.max(0, updates.playbackStart)));
+        node.setAttribute("data-media-start", ps);
+        node.setAttribute("data-playback-start", ps);
+    }
+}
+// set_layer_keyframes twin: author a script-free CSS @keyframes animation on ONE
+// layer. The rule lives in a <style data-vf-kf="hfk-…"> in <head> (any prior
+// block for the same layer is removed first); the layer gets an inline
+// `animation: hfk-… <dur>s <easing> both paused`. The keyframe name is NEVER
+// vf-* (those are reserved for kenburns/transition/caption machinery); paused +
+// fill:both keeps it seek-safe in preview AND render.
+export function setLayerKeyframes(html, layerKey, opts) {
+    const frames = (opts.keyframes ?? []).filter((f) => Number.isFinite(f.offset)).sort((a, b) => a.offset - b.offset);
+    if (frames.length < 2) {
+        throw new Error("keyframes requires at least 2 stops, each with a numeric offset in 0..1.");
+    }
+    if (frames.every((f) => f.opacity === undefined && f.translate_x === undefined && f.translate_y === undefined && f.scale === undefined && f.rotate === undefined)) {
+        throw new Error("each keyframe needs at least one animated property (opacity, translate_x, translate_y, scale, rotate).");
+    }
+    const { document, root } = readCompositionDoc(html);
+    const node = resolveLayerNode(root, layerKey);
+    if (!node)
+        throw new Error(`Layer not found: ${layerKey}`);
+    const baseId = nodeTimelineId(node) || "layer";
+    const animName = `hfk-${baseId.replace(/[^A-Za-z0-9_-]/g, "-")}`;
+    const clipDuration = numAttr(node, "data-duration");
+    const durationSec = opts.durationSec !== undefined && opts.durationSec > 0
+        ? opts.durationSec
+        : (Number.isFinite(clipDuration) && clipDuration > 0 ? clipDuration : 1);
+    const easing = normalizeKeyframeEasing(opts.easing);
+    const cssFrames = frames.map((f) => {
+        const pct = Math.max(0, Math.min(100, f.offset * 100));
+        const pctLabel = Number(pct.toFixed(3)).toString();
+        const transforms = [];
+        if (f.translate_x !== undefined || f.translate_y !== undefined) {
+            transforms.push(`translate(${f.translate_x ?? 0}%, ${f.translate_y ?? 0}%)`);
+        }
+        if (f.scale !== undefined)
+            transforms.push(`scale(${f.scale})`);
+        if (f.rotate !== undefined)
+            transforms.push(`rotate(${f.rotate}deg)`);
+        const decls = [];
+        if (transforms.length)
+            decls.push(`transform:${transforms.join(" ")}`);
+        if (f.opacity !== undefined)
+            decls.push(`opacity:${Math.max(0, Math.min(1, f.opacity))}`);
+        return `${pctLabel}%{${decls.join(";")}}`;
+    }).join("");
+    const keyframeCss = `@keyframes ${animName}{${cssFrames}}`;
+    // Replace any prior keyframe block authored for THIS layer, then inject fresh.
+    // animName is already restricted to [A-Za-z0-9_-] so no selector escaping needed.
+    for (const old of Array.from(document.querySelectorAll(`style[data-vf-kf="${animName}"]`))) {
+        old.parentNode?.removeChild(old);
+    }
+    const styleEl = document.createElement("style");
+    styleEl.setAttribute("data-vf-kf", animName);
+    styleEl.textContent = keyframeCss;
+    const head = document.querySelector("head") ?? document.body ?? document.documentElement;
+    head.appendChild(styleEl);
+    upsertStyleDecl(node, "animation", `${animName} ${round3(durationSec)}s ${easing} both paused`);
+    return { html: serialize(document), layerKey: nodeTimelineId(node) || layerKey, stops: frames.length, animName, durationSec: round3(durationSec), easing };
+}
+// nudge_layers twin: relative timeline move of one or more layers, group-aware
+// (a grouped clip carries its whole data-vf-group with it). Start/track clamp to
+// >= 0. Applied in one pass; collisions between the moving clips are NOT
+// auto-resolved (unlike the single-layer restack) — the composition-edit helper
+// only resolves one excluded node at a time.
+export function nudgeLayers(html, keys, opts) {
+    const deltaStart = opts.deltaStart ?? 0;
+    const deltaTrack = opts.deltaTrack ?? 0;
+    if (!deltaStart && !deltaTrack) {
+        throw new Error("nudge needs a non-zero --delta-start (seconds) and/or --delta-track (lanes).");
+    }
+    const cleanKeys = keys.filter((k) => typeof k === "string" && k.trim().length > 0);
+    if (!cleanKeys.length)
+        throw new Error("nudge requires --layer <key> (repeatable).");
+    const { document, root } = readCompositionDoc(html);
+    const moveSet = new Map();
+    for (const key of cleanKeys) {
+        const seed = resolveLayerNode(root, key);
+        if (!seed)
+            throw new Error(`Layer not found: ${key}`);
+        const groupId = seed.getAttribute("data-vf-group");
+        if (groupId) {
+            const escaped = groupId.replace(/["\\]/g, "\\$&");
+            for (const gn of Array.from(root.querySelectorAll(`[data-vf-group="${escaped}"]`))) {
+                moveSet.set(nodeTimelineId(gn) || `n${moveSet.size}`, gn);
+            }
+        }
+        else {
+            moveSet.set(nodeTimelineId(seed) || `n${moveSet.size}`, seed);
+        }
+    }
+    for (const node of moveSet.values()) {
+        const start = numAttr(node, "data-start");
+        const track = numAttr(node, "data-track-index");
+        applyTimingToNode(node, {
+            start: Math.max(0, (Number.isFinite(start) ? start : 0) + deltaStart),
+            track: Math.max(0, (Number.isFinite(track) ? track : 0) + Math.trunc(deltaTrack))
+        });
+    }
+    return { html: serialize(document), moved: Array.from(moveSet.values()).map((n) => nodeTimelineId(n)) };
+}
+// ripple_edit twin: insert (delta > 0) or close (delta < 0) time at `at`,
+// shifting every clip whose data-start >= at across ALL tracks so downstream
+// timing stays in sync. Starts clamp to >= 0.
+export function rippleEdit(html, opts) {
+    if (!Number.isFinite(opts.at))
+        throw new Error("ripple requires --at (seconds on the composition timeline).");
+    if (!opts.delta || !Number.isFinite(opts.delta)) {
+        throw new Error("ripple requires a non-zero --delta (seconds; positive inserts a gap, negative closes one).");
+    }
+    const { document, root } = readCompositionDoc(html);
+    const affected = collectClips(root).filter((node) => {
+        const s = numAttr(node, "data-start");
+        return Number.isFinite(s) && s >= opts.at - 0.0001;
+    });
+    if (!affected.length)
+        throw new Error(`No clips start at or after ${opts.at}s to ripple.`);
+    for (const node of affected) {
+        const s = numAttr(node, "data-start");
+        applyTimingToNode(node, { start: Math.max(0, s + opts.delta) });
+    }
+    return { html: serialize(document), affected: affected.length };
+}
+// trim_layer twin: move ONE edge of a clip to a composition time. edge='start'
+// advances data-start, shrinks data-duration, and (video/audio only) pushes the
+// media in-point forward by the same delta so the visible frame is unchanged;
+// edge='end' just changes data-duration. Guards against non-positive duration.
+export function trimLayer(html, layerKey, opts) {
+    if (opts.edge !== "start" && opts.edge !== "end")
+        throw new Error("trim requires --edge start|end.");
+    if (!Number.isFinite(opts.to))
+        throw new Error("trim requires --to (seconds on the composition timeline).");
+    const { document, root } = readCompositionDoc(html);
+    const node = resolveLayerNode(root, layerKey);
+    if (!node)
+        throw new Error(`Layer not found: ${layerKey}`);
+    const start = numAttr(node, "data-start");
+    const duration = numAttr(node, "data-duration");
+    const s = Number.isFinite(start) ? start : 0;
+    const d = Number.isFinite(duration) ? duration : 0;
+    const end = s + d;
+    const tag = String(node.tagName || "").toLowerCase();
+    const isMedia = tag === "video" || tag === "audio";
+    const mediaStart = numAttr(node, "data-media-start");
+    const ms = Number.isFinite(mediaStart) ? mediaStart : 0;
+    const updates = {};
+    if (opts.edge === "start") {
+        if (opts.to <= s + 0.0001) {
+            throw new Error(`Left trim --to (${opts.to}s) must be after the clip start (${s}s). Use \`move\` to shift the clip earlier.`);
+        }
+        if (opts.to >= end - 0.05) {
+            throw new Error("Left trim would leave no duration — pick a --to before the clip's end.");
+        }
+        const delta = opts.to - s;
+        updates.start = opts.to;
+        updates.duration = d - delta;
+        if (isMedia)
+            updates.playbackStart = ms + delta;
+    }
+    else {
+        if (opts.to <= s + 0.05) {
+            throw new Error(`Right trim --to (${opts.to}s) must be after the clip start (${s}s).`);
+        }
+        updates.duration = opts.to - s;
+    }
+    applyTimingToNode(node, updates);
+    const report = {};
+    if (updates.start !== undefined)
+        report.start = round3(updates.start);
+    if (updates.duration !== undefined)
+        report.duration = round3(updates.duration);
+    if (updates.playbackStart !== undefined)
+        report.playback_start = round3(updates.playbackStart);
+    return { html: serialize(document), layerKey: nodeTimelineId(node) || layerKey, updates: report };
+}
+// set_layer_zindex twin: restack a layer. Stacking == data-track-index (higher
+// draws on top). front = maxTrack+1, back = max(0,minTrack-1), forward = track+1,
+// backward = max(0,track-1); an explicit --track wins. The single-node collision
+// resolver (findNonCollidingTrack) re-lanes upward when the target collides, so
+// 'back'/'backward' are best-effort (two time-overlapping clips can't share a lane).
+export function restackLayer(html, layerKey, opts) {
+    if (!opts.order && opts.track === undefined) {
+        throw new Error("restack needs --order front|back|forward|backward or an explicit --track.");
+    }
+    const { document, root } = readCompositionDoc(html);
+    const node = resolveLayerNode(root, layerKey);
+    if (!node)
+        throw new Error(`Layer not found: ${layerKey}`);
+    const clips = collectClips(root);
+    const tracks = clips.map((n) => numAttr(n, "data-track-index")).filter((t) => Number.isFinite(t));
+    const currentTrack = numAttr(node, "data-track-index");
+    const ct = Number.isFinite(currentTrack) ? currentTrack : 0;
+    const maxTrack = tracks.length ? Math.max(...tracks) : ct;
+    const minTrack = tracks.length ? Math.min(...tracks) : ct;
+    let targetTrack;
+    if (opts.track !== undefined)
+        targetTrack = Math.max(0, Math.trunc(opts.track));
+    else if (opts.order === "front")
+        targetTrack = maxTrack + 1;
+    else if (opts.order === "back")
+        targetTrack = Math.max(0, minTrack - 1);
+    else if (opts.order === "forward")
+        targetTrack = ct + 1;
+    else
+        targetTrack = Math.max(0, ct - 1);
+    const excludeId = nodeTimelineId(node);
+    const start = numAttr(node, "data-start");
+    const dur = numAttr(node, "data-duration");
+    const resolvedTrack = findNonCollidingTrack(clips, { start: Number.isFinite(start) ? start : 0, duration: Number.isFinite(dur) ? dur : 0, track: targetTrack }, excludeId);
+    if (resolvedTrack === ct) {
+        throw new Error(`${excludeId || layerKey} is already at track ${ct} — no stacking change.`);
+    }
+    applyTimingToNode(node, { track: resolvedTrack });
+    return { html: serialize(document), layerKey: excludeId || layerKey, track: resolvedTrack, order: opts.order ?? "explicit" };
+}
 //# sourceMappingURL=composition-edit.js.map

package/dist/src/devcli/timeline-edit.js ADDED Viewed

@@ -0,0 +1,283 @@
+// devcli fine timeline control — the local-file twins of the browser editor's
+// trackpad-level verbs (set_layer_keyframes / nudge_layers / ripple_edit /
+// trim_layer / set_layer_zindex). Pure local DOM edits (linkedom) on a
+// composition.html: no cloud, no wallet — a running `vidfarm serve` live-morphs
+// the change into open editor tabs and `publish` pushes it like any browser
+// edit. Same read/write/serialize idioms as `vidfarm place` / `captions` /
+// `transitions`.
+import { existsSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { parseArgs } from "node:util";
+import { nudgeLayers, restackLayer, rippleEdit, setLayerKeyframes, trimLayer } from "./composition-edit.js";
+// Convenience motion presets so `keyframes` is usable without hand-writing JSON.
+// Each is a plain KeyframeStop[] — identical to what --keyframes '<json>' takes.
+const KEYFRAME_PRESETS = {
+    "fade-in": [{ offset: 0, opacity: 0 }, { offset: 1, opacity: 1 }],
+    "fade-out": [{ offset: 0, opacity: 1 }, { offset: 1, opacity: 0 }],
+    "fly-up": [{ offset: 0, opacity: 0, translate_y: 40 }, { offset: 1, opacity: 1, translate_y: 0 }],
+    "fly-down": [{ offset: 0, opacity: 0, translate_y: -40 }, { offset: 1, opacity: 1, translate_y: 0 }],
+    "fly-left": [{ offset: 0, opacity: 0, translate_x: 40 }, { offset: 1, opacity: 1, translate_x: 0 }],
+    "fly-right": [{ offset: 0, opacity: 0, translate_x: -40 }, { offset: 1, opacity: 1, translate_x: 0 }],
+    "pop-in": [{ offset: 0, opacity: 0, scale: 0.6 }, { offset: 0.7, opacity: 1, scale: 1.05 }, { offset: 1, opacity: 1, scale: 1 }],
+    "zoom-in": [{ offset: 0, scale: 1 }, { offset: 1, scale: 1.15 }],
+    "spin-in": [{ offset: 0, opacity: 0, rotate: -90, scale: 0.8 }, { offset: 1, opacity: 1, rotate: 0, scale: 1 }],
+    "pulse": [{ offset: 0, scale: 1 }, { offset: 0.5, scale: 1.08 }, { offset: 1, scale: 1 }]
+};
+const KEYFRAMES_HELP = `vidfarm keyframes — author a script-free CSS @keyframes animation on ONE layer (local file write)
+  keyframes <dir|composition.html> --layer <key> --preset <name>
+  keyframes <dir|composition.html> --layer <key> --keyframes '<json>'
+    --layer <key>            Target layer (data-hf-id / slug / element id) — required
+    --preset <name>          Built-in motion: ${Object.keys(KEYFRAME_PRESETS).join(" | ")}
+    --keyframes '<json>'     Custom stops: an array of >=2 {offset(0..1), opacity?,
+                             translate_x?, translate_y?, scale?, rotate?}. translate_*
+                             are percentages of the layer's OWN box, rotate is degrees.
+                             e.g. --keyframes '[{"offset":0,"opacity":0,"translate_y":40},{"offset":1,"opacity":1,"translate_y":0}]'
+    --easing <fn>            linear (default) | ease | ease-in | ease-out | ease-in-out
+                             | cubic-bezier(...) | steps(...)  (anything else → linear)
+    --duration <sec>         Seconds the animation spans (default: the clip's duration)
+    --json
+Writes a <style data-vf-kf="hfk-<layer>"> keyframe block + an inline
+"animation: hfk-<layer> <dur>s <easing> both paused" on the layer. paused +
+fill:both is seek-safe: it previews, serve-live-morphs, and bakes into the MP4
+identically. The keyframe name is never vf-* (reserved for kenburns/transition/caption).`;
+const MOVE_HELP = `vidfarm move — shift layers on the timeline by a relative delta (local file write)
+  move <dir|composition.html> --layer <key> [--layer <key> …]
+    --layer <key>            Layer to move (repeatable); a grouped clip carries its
+                             whole data-vf-group with it
+    --delta-start <sec>      Shift start by N seconds (clamped to >= 0)
+    --delta-track <lanes>    Shift track/lane by N (clamped to >= 0; higher = on top)
+    --json
+  Alias: move | nudge. Collisions between the moving clips are not auto-resolved
+  (use \`restack\` for single-layer lane resolution).`;
+const RIPPLE_HELP = `vidfarm ripple — insert or close time across the whole timeline (local file write)
+  ripple <dir|composition.html> --at <sec> --delta <sec>
+    --at <sec>               Ripple point on the composition timeline
+    --delta <sec>            Shift every clip that starts at/after --at by N seconds
+                             (positive inserts a gap, negative closes one; clamps >= 0)
+    --json`;
+const TRIM_HELP = `vidfarm trim — move ONE edge of a clip to a time (local file write)
+  trim <dir|composition.html> --layer <key> --edge start|end --to <sec>
+    --layer <key>            Clip to trim — required
+    --edge start|end         'start' advances the in-point (and, for video/audio,
+                             pushes the media start so the visible frame is unchanged);
+                             'end' changes the duration
+    --to <sec>               New edge position on the composition timeline
+    --json`;
+const RESTACK_HELP = `vidfarm restack — change a layer's stacking order (local file write)
+  restack <dir|composition.html> --layer <key> --order front|back|forward|backward
+  restack <dir|composition.html> --layer <key> --track <n>
+    --layer <key>            Layer to restack — required
+    --order <o>              front (top of all) | back | forward (+1) | backward (-1);
+                             stacking == track index (higher draws on top)
+    --track <n>              Explicit target lane (wins over --order)
+    --json
+  Alias: restack | zindex. 'back'/'backward' are best-effort — two time-overlapping
+  clips can't share a lane, so the resolver re-lanes upward on collision.`;
+// Same dir-or-file resolution as `vidfarm place` / `captions` / `transitions`.
+function resolveCompositionHtml(target) {
+    if (!target)
+        throw new Error("Provide the composition dir or composition.html path.");
+    const abs = path.resolve(process.cwd(), target);
+    if (existsSync(abs) && statSync(abs).isDirectory()) {
+        const inside = path.join(abs, "composition.html");
+        if (!existsSync(inside))
+            throw new Error(`No composition.html inside ${abs}. Run \`vidfarm pull <forkId> --dir ${target}\` first.`);
+        return inside;
+    }
+    if (!existsSync(abs))
+        throw new Error(`No such composition file or dir: ${abs}.`);
+    return abs;
+}
+function num(values, key) {
+    const raw = values[key];
+    if (typeof raw !== "string" || !raw.trim())
+        return undefined;
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed))
+        throw new Error(`--${key} must be a number.`);
+    return parsed;
+}
+// ── keyframes ────────────────────────────────────────────────────────────────
+export async function runKeyframesCommand(argv) {
+    if (argv[0] === "help" || argv[0] === "--help" || argv[0] === "-h") {
+        console.log(KEYFRAMES_HELP);
+        return;
+    }
+    const { values, positionals } = parseArgs({
+        args: argv,
+        allowPositionals: true,
+        options: {
+            layer: { type: "string" },
+            preset: { type: "string" },
+            keyframes: { type: "string" },
+            easing: { type: "string" },
+            duration: { type: "string" },
+            json: { type: "boolean" }
+        }
+    });
+    const file = resolveCompositionHtml(positionals[0]);
+    if (typeof values.layer !== "string" || !values.layer.trim()) {
+        throw new Error("keyframes requires --layer <layerKey|slug>.");
+    }
+    let frames;
+    if (typeof values.keyframes === "string" && values.keyframes.trim()) {
+        let parsed;
+        try {
+            parsed = JSON.parse(values.keyframes);
+        }
+        catch {
+            throw new Error("--keyframes must be a JSON array of stops, e.g. '[{\"offset\":0,\"opacity\":0},{\"offset\":1,\"opacity\":1}]'.");
+        }
+        if (!Array.isArray(parsed))
+            throw new Error("--keyframes must be a JSON ARRAY of stops.");
+        frames = parsed;
+    }
+    else if (typeof values.preset === "string" && values.preset.trim()) {
+        const preset = KEYFRAME_PRESETS[values.preset.trim()];
+        if (!preset)
+            throw new Error(`Unknown --preset "${values.preset}". Use one of: ${Object.keys(KEYFRAME_PRESETS).join(", ")} (or pass --keyframes '<json>').`);
+        frames = preset.map((f) => ({ ...f }));
+    }
+    else {
+        throw new Error(`keyframes needs --preset <name> or --keyframes '<json>'. Presets: ${Object.keys(KEYFRAME_PRESETS).join(", ")}.`);
+    }
+    const result = setLayerKeyframes(readFileSync(file, "utf8"), values.layer, {
+        keyframes: frames,
+        easing: typeof values.easing === "string" ? values.easing : undefined,
+        durationSec: num(values, "duration")
+    });
+    writeFileSync(file, result.html, "utf8");
+    if (values.json) {
+        console.log(JSON.stringify({ file, layerKey: result.layerKey, animation: result.animName, stops: result.stops, duration: result.durationSec, easing: result.easing }, null, 2));
+        return;
+    }
+    console.log(`Set a ${result.stops}-stop CSS keyframe animation on ${result.layerKey} (${result.animName} ${result.durationSec}s ${result.easing}).`);
+    console.log(`Wrote ${file}`);
+}
+// ── move / nudge ─────────────────────────────────────────────────────────────
+export async function runMoveCommand(argv) {
+    if (argv[0] === "help" || argv[0] === "--help" || argv[0] === "-h") {
+        console.log(MOVE_HELP);
+        return;
+    }
+    const { values, positionals } = parseArgs({
+        args: argv,
+        allowPositionals: true,
+        options: {
+            layer: { type: "string", multiple: true },
+            "delta-start": { type: "string" },
+            "delta-track": { type: "string" },
+            json: { type: "boolean" }
+        }
+    });
+    const file = resolveCompositionHtml(positionals[0]);
+    const layers = values.layer ?? [];
+    if (!layers.length)
+        throw new Error("move requires --layer <layerKey|slug> (repeatable).");
+    const result = nudgeLayers(readFileSync(file, "utf8"), layers, {
+        deltaStart: num(values, "delta-start"),
+        deltaTrack: num(values, "delta-track")
+    });
+    writeFileSync(file, result.html, "utf8");
+    if (values.json) {
+        console.log(JSON.stringify({ file, moved: result.moved, delta_start: num(values, "delta-start") ?? 0, delta_track: num(values, "delta-track") ?? 0 }, null, 2));
+        return;
+    }
+    console.log(`Moved ${result.moved.length} layer(s) by Δstart=${num(values, "delta-start") ?? 0}s Δtrack=${Math.trunc(num(values, "delta-track") ?? 0)}: ${result.moved.join(", ")}.`);
+    console.log(`Wrote ${file}`);
+}
+// ── ripple ───────────────────────────────────────────────────────────────────
+export async function runRippleCommand(argv) {
+    if (argv[0] === "help" || argv[0] === "--help" || argv[0] === "-h") {
+        console.log(RIPPLE_HELP);
+        return;
+    }
+    const { values, positionals } = parseArgs({
+        args: argv,
+        allowPositionals: true,
+        options: { at: { type: "string" }, delta: { type: "string" }, json: { type: "boolean" } }
+    });
+    const file = resolveCompositionHtml(positionals[0]);
+    const at = num(values, "at");
+    const delta = num(values, "delta");
+    if (at === undefined)
+        throw new Error("ripple requires --at <sec>.");
+    if (delta === undefined)
+        throw new Error("ripple requires --delta <sec>.");
+    const result = rippleEdit(readFileSync(file, "utf8"), { at, delta });
+    writeFileSync(file, result.html, "utf8");
+    if (values.json) {
+        console.log(JSON.stringify({ file, at, delta, affected: result.affected }, null, 2));
+        return;
+    }
+    console.log(`Rippled ${result.affected} clip(s) at ${at}s by ${delta > 0 ? "+" : ""}${delta}s.`);
+    console.log(`Wrote ${file}`);
+}
+// ── trim ─────────────────────────────────────────────────────────────────────
+export async function runTrimCommand(argv) {
+    if (argv[0] === "help" || argv[0] === "--help" || argv[0] === "-h") {
+        console.log(TRIM_HELP);
+        return;
+    }
+    const { values, positionals } = parseArgs({
+        args: argv,
+        allowPositionals: true,
+        options: { layer: { type: "string" }, edge: { type: "string" }, to: { type: "string" }, json: { type: "boolean" } }
+    });
+    const file = resolveCompositionHtml(positionals[0]);
+    if (typeof values.layer !== "string" || !values.layer.trim())
+        throw new Error("trim requires --layer <layerKey|slug>.");
+    if (values.edge !== "start" && values.edge !== "end")
+        throw new Error("trim requires --edge start|end.");
+    const to = num(values, "to");
+    if (to === undefined)
+        throw new Error("trim requires --to <sec>.");
+    const result = trimLayer(readFileSync(file, "utf8"), values.layer, { edge: values.edge, to });
+    writeFileSync(file, result.html, "utf8");
+    if (values.json) {
+        console.log(JSON.stringify({ file, layerKey: result.layerKey, edge: values.edge, to, updates: result.updates }, null, 2));
+        return;
+    }
+    const parts = Object.entries(result.updates).map(([k, v]) => `${k}=${v}`).join(" ");
+    console.log(`Trimmed ${result.layerKey} ${values.edge} to ${to}s (${parts}).`);
+    console.log(`Wrote ${file}`);
+}
+// ── restack / zindex ─────────────────────────────────────────────────────────
+export async function runRestackCommand(argv) {
+    if (argv[0] === "help" || argv[0] === "--help" || argv[0] === "-h") {
+        console.log(RESTACK_HELP);
+        return;
+    }
+    const { values, positionals } = parseArgs({
+        args: argv,
+        allowPositionals: true,
+        options: { layer: { type: "string" }, order: { type: "string" }, track: { type: "string" }, json: { type: "boolean" } }
+    });
+    const file = resolveCompositionHtml(positionals[0]);
+    if (typeof values.layer !== "string" || !values.layer.trim())
+        throw new Error("restack requires --layer <layerKey|slug>.");
+    const order = values.order;
+    if (order && !["front", "back", "forward", "backward"].includes(order)) {
+        throw new Error(`--order must be front | back | forward | backward (got "${order}").`);
+    }
+    const result = restackLayer(readFileSync(file, "utf8"), values.layer, {
+        order: order,
+        track: num(values, "track")
+    });
+    writeFileSync(file, result.html, "utf8");
+    if (values.json) {
+        console.log(JSON.stringify({ file, layerKey: result.layerKey, track: result.track, order: result.order }, null, 2));
+        return;
+    }
+    console.log(`Restacked ${result.layerKey} to track ${result.track} (${result.order}; higher = on top).`);
+    console.log(`Wrote ${file}`);
+}
+//# sourceMappingURL=timeline-edit.js.map