vivid-editor-core 0.3.0 → 0.3.1

package/dist/ai-orchestrator.js

@@ -348,6 +348,10 @@ export function executeAiCommands(commands, snapshot, actions) {
                     for (let i = 0; i < beatsAbsolute.length; i += beatInterval) {
                         cutPoints.push(beatsAbsolute[i]);
                     }
+                    // Pictures from the first note: the first beat is often a few ms in
+                    // (60 ms on a MiniMax track), which left a black flash at the start.
+                    if (mode === 'redistribute')
+                        cutPoints[0] = audioStart;
                     // Always end at audio end so the last segment fills the music.
                     if (cutPoints[cutPoints.length - 1] < audioEnd - 50)
                         cutPoints.push(audioEnd);
@@ -366,69 +370,70 @@ export function executeAiCommands(commands, snapshot, actions) {
                         const newCanvasObjects = [];
                         const trackId = targetVisuals[0].trackId;
                         const now = Date.now();
-                        // Walk the tape with a moving cursor; for each cut interval,
-                        // peel off a segment of the tape equal to (next - current).
+                        // Every cut interval gets exactly one piece of its full length, so
+                        // nothing is left black between two cuts or before the end of the
+                        // music. Walking the tape with a cursor:
+                        //  - the rest of the current segment covers the interval → take it;
+                        //  - it covers at least MIN_RATE of it → take it slowed down a little
+                        //    (a still image just stays on screen longer);
+                        //  - it is shorter → drop that leftover and try the next segment;
+                        //  - the tape runs out → start again from the first segment.
+                        // If no segment can fill an interval even after a full loop, the
+                        // longest one is slowed down as far as the player allows.
+                        const MIN_RATE = 0.8;
+                        const EPS = 1;
                         let tapeIdx = 0;
-                        let tapeCursorInSegment = 0;
+                        let cursor = 0;
+                        const advance = () => { tapeIdx = (tapeIdx + 1) % tape.length; cursor = 0; };
+                        const pick = (segmentMs) => {
+                            for (let tries = 0; tries <= tape.length; tries++) {
+                                const seg = tape[tapeIdx];
+                                const avail = seg.durationMs - cursor;
+                                const still = seg.sourceClip.mediaType === 'image';
+                                if (avail >= segmentMs - EPS || (avail > EPS && (still || avail >= segmentMs * MIN_RATE))) {
+                                    const used = Math.min(avail, segmentMs);
+                                    const piece = {
+                                        seg,
+                                        offsetMs: seg.offsetMs + cursor,
+                                        rate: still || used >= segmentMs - EPS ? undefined : used / segmentMs,
+                                    };
+                                    cursor += used;
+                                    if (cursor >= seg.durationMs - EPS)
+                                        advance();
+                                    return piece;
+                                }
+                                advance();
+                            }
+                            const seg = tape.reduce((a, b) => (b.durationMs > a.durationMs ? b : a));
+                            tapeIdx = tape.indexOf(seg);
+                            advance();
+                            return { seg, offsetMs: seg.offsetMs, rate: Math.max(0.25, seg.durationMs / segmentMs) };
+                        };
                         for (let i = 0; i < cutPoints.length - 1; i++) {
                             const segmentMs = cutPoints[i + 1] - cutPoints[i];
                             if (segmentMs <= 0)
                                 continue;
-                            // The piece we lay down references the current tape segment,
-                            // possibly clipping its tail if the tape segment is shorter
-                            // than the beat interval (then we step to next tape segment).
-                            let remaining = segmentMs;
-                            let placed = false;
-                            while (remaining > 0 && tapeIdx < tape.length) {
-                                const seg = tape[tapeIdx];
-                                const available = seg.durationMs - tapeCursorInSegment;
-                                if (available <= 0) {
-                                    tapeIdx++;
-                                    tapeCursorInSegment = 0;
-                                    continue;
-                                }
-                                const take = Math.min(available, remaining);
-                                if (!placed) {
-                                    // First piece of this beat segment — emit a clip starting at cutPoints[i].
-                                    const newId = `clip-cb-${now}-${i}`;
-                                    newClips.push({
-                                        id: newId,
-                                        assetId: seg.sourceClip.assetId,
-                                        name: seg.sourceClip.name,
-                                        url: seg.sourceClip.url,
-                                        startMs: cutPoints[i],
-                                        durationMs: take,
-                                        originalDurationMs: seg.sourceClip.originalDurationMs,
-                                        sourceOffsetMs: seg.offsetMs + tapeCursorInSegment,
-                                        mediaType: seg.sourceClip.mediaType,
-                                        trackId,
-                                    });
-                                    newCanvasObjects.push({
-                                        id: `obj-${newId}`,
-                                        clipId: newId,
-                                        x: 0, y: 0, w: 1, h: 1,
-                                        rotation: 0,
-                                    });
-                                    placed = true;
-                                }
-                                else {
-                                    // Subsequent piece within the same beat — extend the
-                                    // previous clip's duration if and only if it's the same
-                                    // source asset; otherwise start a fresh clip nested in
-                                    // the same beat. For simplicity, we only support a
-                                    // single asset per beat segment (truncate trailing tape
-                                    // and snap to next beat).
-                                    break;
-                                }
-                                tapeCursorInSegment += take;
-                                remaining -= take;
-                                if (tapeCursorInSegment >= seg.durationMs) {
-                                    tapeIdx++;
-                                    tapeCursorInSegment = 0;
-                                }
-                            }
-                            if (tapeIdx >= tape.length)
-                                break; // tape exhausted, stop emitting
+                            const { seg, offsetMs, rate } = pick(segmentMs);
+                            const newId = `clip-cb-${now}-${i}`;
+                            newClips.push({
+                                id: newId,
+                                assetId: seg.sourceClip.assetId,
+                                name: seg.sourceClip.name,
+                                url: seg.sourceClip.url,
+                                startMs: cutPoints[i],
+                                durationMs: segmentMs,
+                                originalDurationMs: seg.sourceClip.originalDurationMs,
+                                sourceOffsetMs: offsetMs,
+                                mediaType: seg.sourceClip.mediaType,
+                                trackId,
+                                ...(rate !== undefined ? { playbackRate: rate } : {}),
+                            });
+                            newCanvasObjects.push({
+                                id: `obj-${newId}`,
+                                clipId: newId,
+                                x: 0, y: 0, w: 1, h: 1,
+                                rotation: 0,
+                            });
                         }
                         // Preserve audio + non-target clips intact.
                         const preservedClips = snapshot.timelineClips.filter((c) => c.mediaType === 'audio' || c.mediaType === 'color' ||

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vivid-editor-core",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "VIVID video editor core: project file schema, editor store and AI command orchestrator — shared by the vividai.tv editor and vivid-mcp.",
   "type": "module",
   "main": "dist/index.js",