vivid-editor-core 0.2.0 → 0.3.0

package/dist/ai-orchestrator.d.ts

@@ -156,7 +156,11 @@ export interface DetachAudioCommand {
  * `audioClipId` — id of an audio clip already in timeline. Must have a
  * cached BeatAnalysis (otherwise the orchestrator returns an error).
  *
- * `beatInterval` — how many beats between cuts. 4 = 1 cut per measure.
+ * `beatInterval` — how many beats (or peaks, with grid 'peaks') between
+ *  cuts. 4 = 1 cut per measure.
+ *
+ * `grid` — 'beats' (default, constant BPM grid) or 'peaks' (detected
+ *  transients from the server analysis; `minStrength` filters weak ones).
  *
  * `mode`:
  *  - "redistribute" (default): take all visual clips, slice them up so
@@ -177,6 +181,15 @@ export interface CutToBeatCommand {
         beatInterval: number;
         mode?: 'redistribute' | 'snap';
         syncClips?: 'all' | string[];
+        /**
+         * Which grid to cut on. 'beats' (default) = the constant BPM grid.
+         * 'peaks' = detected transients (hits, accents) — cuts land on what the
+         * ear actually hears, also on music without a steady tempo or on voice.
+         * Needs `peaks` in the BeatAnalysis (server-side analysis).
+         */
+        grid?: 'beats' | 'peaks';
+        /** grid 'peaks' only: ignore peaks weaker than this (0–1, default 0). */
+        minStrength?: number;
     };
 }
 /** Set keyframe animations on one property of a canvas object or text overlay. */

package/dist/ai-orchestrator.js

@@ -309,9 +309,19 @@ export function executeAiCommands(commands, snapshot, actions) {
                     }
                     const analysis = snapshot.audioBeatsByAssetId?.[audioClip.assetId];
                     if (!analysis || analysis === 'analyzing' || analysis === 'failed') {
-                        errors.push(`CUT_TO_BEAT: audio "${audioClip.name}" has no beat analysis (status: ${analysis ?? 'unknown'}). Wait a moment after dropping audio for analysis to complete.`);
+                        errors.push(`CUT_TO_BEAT: audio "${audioClip.name}" has no beat analysis (status: ${analysis ?? 'unknown'}). In the browser wait a moment after dropping the audio; via the API run POST /api/ai/audio-analysis on the asset first.`);
                         break;
                     }
+                    const grid = cmd.payload.grid ?? 'beats';
+                    let gridMs = analysis.beats;
+                    if (grid === 'peaks') {
+                        if (!analysis.peaks || analysis.peaks.length === 0) {
+                            errors.push(`CUT_TO_BEAT: audio "${audioClip.name}" has no peak analysis — peaks come from the server analysis (POST /api/ai/audio-analysis, mode 'peaks' or 'both'); use grid 'beats' or analyse the asset first.`);
+                            break;
+                        }
+                        const minStrength = Math.max(0, Math.min(1, cmd.payload.minStrength ?? 0));
+                        gridMs = analysis.peaks.filter((p) => p.strength >= minStrength).map((p) => p.ms).sort((a, b) => a - b);
+                    }
                     // Filter visual clips: those participating in the cut.
                     const allVisualClips = snapshot.timelineClips.filter((c) => c.mediaType === 'video' || c.mediaType === 'image');
                     const targetVisuals = syncClipsArg === 'all'
@@ -326,11 +336,11 @@ export function executeAiCommands(commands, snapshot, actions) {
                     const audioEnd = audioClip.startMs + audioClip.durationMs;
                     // Beats from analysis are offsets from start of source audio.
                     // sourceOffsetMs accounts for trims at audio's head.
-                    const beatsAbsolute = analysis.beats
+                    const beatsAbsolute = gridMs
                         .map((bMs) => audioStart + (bMs - audioClip.sourceOffsetMs))
                         .filter((t) => t >= audioStart && t <= audioEnd);
                     if (beatsAbsolute.length < beatInterval + 1) {
-                        errors.push(`CUT_TO_BEAT: not enough beats (${beatsAbsolute.length}) for beatInterval ${beatInterval}`);
+                        errors.push(`CUT_TO_BEAT: not enough ${grid} (${beatsAbsolute.length}) for beatInterval ${beatInterval}`);
                         break;
                     }
                     // Cut points: every Nth beat, including audio start (first beat) and end.

package/dist/store.d.ts

@@ -262,4 +262,5 @@ export interface EditorState {
     reset: () => void;
 }
 export type EditorStore = StoreApi<EditorState>;
+export declare function uniqueId(prefix: string): string;
 export declare function createEditorStore(deps?: EditorStoreDeps): EditorStore;

package/dist/store.js

@@ -99,6 +99,17 @@ function timelineContentMs(clips) {
 function clamp(v, min, max) {
     return Math.max(min, Math.min(max, v));
 }
+/**
+ * Timestamp-based ids collide when several clips are created in the same
+ * millisecond — which never happens from the UI but always does in a
+ * headless batch (vivid-mcp: ADD_CLIP × 3 in one call). The sequence suffix
+ * keeps them unique; the `clip-`/`obj-` prefixes stay as before.
+ */
+let idSeq = 0;
+export function uniqueId(prefix) {
+    idSeq = (idSeq + 1) % 1_000_000;
+    return `${prefix}-${Date.now()}-${idSeq.toString(36)}`;
+}
 export function createEditorStore(deps = {}) {
     return createStore()((set, get) => ({
         // ── Initial state ──
@@ -247,7 +258,7 @@ export function createEditorStore(deps = {}) {
             const availableMs = MAX_TIMELINE_MS - startMs;
             if (availableMs <= 0)
                 return;
-            const clipId = `clip-${Date.now()}`;
+            const clipId = uniqueId('clip');
             const clip = {
                 id: clipId,
                 assetId: asset.id,
@@ -465,7 +476,7 @@ export function createEditorStore(deps = {}) {
             if (!clip)
                 return;
             state.pushUndo();
-            const newId = `clip-${Date.now()}`;
+            const newId = uniqueId('clip');
             const newStart = clip.startMs + clip.durationMs; // place right after original
             const newClip = {
                 ...clip,
@@ -475,7 +486,7 @@ export function createEditorStore(deps = {}) {
             // Also duplicate canvas object if it's a visual clip
             const canvasObj = state.canvasObjects.find((o) => o.clipId === id);
             const newObjs = canvasObj
-                ? [...state.canvasObjects, { ...canvasObj, id: `obj-${Date.now()}`, clipId: newId }]
+                ? [...state.canvasObjects, { ...canvasObj, id: uniqueId('obj'), clipId: newId }]
                 : state.canvasObjects;
             set({
                 timelineClips: [...state.timelineClips, newClip],
@@ -541,7 +552,7 @@ export function createEditorStore(deps = {}) {
             }
             if (startMs === null || targetTrackId === null)
                 return;
-            const clipId = `clip-color-${Date.now()}`;
+            const clipId = uniqueId('clip-color');
             const clip = {
                 id: clipId,
                 assetId: `color-${color.replace('#', '')}`,
@@ -598,7 +609,7 @@ export function createEditorStore(deps = {}) {
             // Ensure an audio track exists for this video's track
             const audioTrackId = clip.trackId.replace('V', 'A');
             state.ensureAudioTrack(clip.trackId);
-            const audioClipId = `audio-detach-${Date.now()}`;
+            const audioClipId = uniqueId('audio-detach');
             const audioClip = {
                 id: audioClipId,
                 assetId: clip.assetId,

package/dist/types/beat.d.ts

@@ -10,7 +10,20 @@ export interface BeatAnalysis {
     /** Downbeats — every 4th beat (1, 5, 9, ...) — in ms */
     downbeats: number[];
     /** Source of the BPM value */
-    source: 'detected' | 'filename-hint' | 'detected+hint-validated' | 'envelope-fallback';
+    source: 'detected' | 'filename-hint' | 'detected+hint-validated' | 'envelope-fallback' | 'server';
     /** Duration of the analyzed audio, in ms */
     analyzedDurationMs: number;
+    /**
+     * Transient peaks (drum hits, accents, word starts) from the server-side
+     * analysis (POST /api/ai/audio-analysis), ms from the start of the source
+     * audio. Strength is 0–1 relative to the loudest onset. Optional: the
+     * browser-only analyzer does not compute them.
+     */
+    peaks?: AudioPeak[];
+    /** 0–1 peakedness of the tempo autocorrelation (server analysis only). */
+    bpmConfidence?: number;
+}
+export interface AudioPeak {
+    ms: number;
+    strength: number;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vivid-editor-core",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "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",