vivid-editor-core 0.1.0

package/dist/schemas.d.ts

@@ -0,0 +1,266 @@
+/**
+ * Zod schema for ProjectFile v2 (load/save path).
+ *
+ * Scope (spec M0 task 9): validate ProjectFile when loading from R2 after
+ * migration. The schema is permissive on unknown fields (passthrough) to
+ * avoid breaking on forward-compat additions, but strict on the v2 schema
+ * markers and type shapes.
+ *
+ * NOTE: this is NOT the LLM-output validator. That one is
+ * `validateGeneratedTimeline` in src/lib/editor/prompt-builder.ts and will
+ * be replaced by a separate Zod schema in M6.
+ */
+import { z } from 'zod';
+export declare const projectSchemaV2: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<2>;
+    version: z.ZodOptional<z.ZodNumber>;
+    projectName: z.ZodOptional<z.ZodString>;
+    videoDurationMs: z.ZodOptional<z.ZodNumber>;
+    canvasPreset: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+    }, z.core.$loose>>;
+    tracks: z.ZodOptional<z.ZodArray<z.ZodObject<{}, z.core.$loose>>>;
+    timelineClips: z.ZodOptional<z.ZodArray<z.ZodObject<{}, z.core.$loose>>>;
+    canvasObjects: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        clipId: z.ZodString;
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        w: z.ZodNumber;
+        h: z.ZodNumber;
+        rotation: z.ZodNumber;
+        animations: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
+            x: "x";
+            y: "y";
+            scale: "scale";
+            rotation: "rotation";
+            opacity: "opacity";
+            blur: "blur";
+            brightness: "brightness";
+            contrast: "contrast";
+            saturation: "saturation";
+            maskProgress: "maskProgress";
+        }>, z.ZodObject<{
+            keyframes: z.ZodArray<z.ZodObject<{
+                t: z.ZodNumber;
+                v: z.ZodNumber;
+                easing: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+                    linear: "linear";
+                    easeInQuad: "easeInQuad";
+                    easeOutQuad: "easeOutQuad";
+                    easeInOutQuad: "easeInOutQuad";
+                    easeInCubic: "easeInCubic";
+                    easeOutCubic: "easeOutCubic";
+                    easeInOutCubic: "easeInOutCubic";
+                    easeInBack: "easeInBack";
+                    easeOutBack: "easeOutBack";
+                    easeInOutBack: "easeInOutBack";
+                    easeInQuart: "easeInQuart";
+                    easeOutQuart: "easeOutQuart";
+                    easeInOutQuart: "easeInOutQuart";
+                    easeInExpo: "easeInExpo";
+                    easeOutExpo: "easeOutExpo";
+                    easeInOutExpo: "easeInOutExpo";
+                }>, z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodObject<{
+                    type: z.ZodLiteral<"spring">;
+                    stiffness: z.ZodNumber;
+                    damping: z.ZodNumber;
+                    mass: z.ZodNumber;
+                }, z.core.$strip>]>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
+        effects: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"blur">;
+            amount: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"vignette">;
+            intensity: z.ZodNumber;
+            size: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"colorGrade">;
+            brightness: z.ZodOptional<z.ZodNumber>;
+            contrast: z.ZodOptional<z.ZodNumber>;
+            saturation: z.ZodOptional<z.ZodNumber>;
+            hue: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"grain">;
+            intensity: z.ZodNumber;
+            size: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"glitch">;
+            intensity: z.ZodNumber;
+            blockSize: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"chromaticAberration">;
+            offset: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"pixelate">;
+            blockSize: z.ZodNumber;
+        }, z.core.$strip>], "type">>>;
+        maskV2: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"none">;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"rect">;
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            w: z.ZodNumber;
+            h: z.ZodNumber;
+            feather: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"circle">;
+            cx: z.ZodNumber;
+            cy: z.ZodNumber;
+            r: z.ZodNumber;
+            feather: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"reveal">;
+            direction: z.ZodEnum<{
+                ltr: "ltr";
+                rtl: "rtl";
+                ttb: "ttb";
+                btt: "btt";
+            }>;
+            progress: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"clipPath">;
+            svgPath: z.ZodString;
+        }, z.core.$strip>], "type">>;
+        audioReactive: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            property: z.ZodEnum<{
+                x: "x";
+                y: "y";
+                scale: "scale";
+                rotation: "rotation";
+                opacity: "opacity";
+                blur: "blur";
+                brightness: "brightness";
+                contrast: "contrast";
+                saturation: "saturation";
+                maskProgress: "maskProgress";
+            }>;
+            feature: z.ZodEnum<{
+                rms: "rms";
+                low: "low";
+                mid: "mid";
+                high: "high";
+                beat: "beat";
+            }>;
+            assetId: z.ZodString;
+            factor: z.ZodNumber;
+            mode: z.ZodEnum<{
+                add: "add";
+                multiply: "multiply";
+            }>;
+            smoothing: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>>;
+    }, z.core.$loose>>>;
+    textOverlays: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        text: z.ZodString;
+        startMs: z.ZodNumber;
+        endMs: z.ZodNumber;
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        animations: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
+            x: "x";
+            y: "y";
+            scale: "scale";
+            rotation: "rotation";
+            opacity: "opacity";
+            blur: "blur";
+            brightness: "brightness";
+            contrast: "contrast";
+            saturation: "saturation";
+            maskProgress: "maskProgress";
+        }>, z.ZodObject<{
+            keyframes: z.ZodArray<z.ZodObject<{
+                t: z.ZodNumber;
+                v: z.ZodNumber;
+                easing: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+                    linear: "linear";
+                    easeInQuad: "easeInQuad";
+                    easeOutQuad: "easeOutQuad";
+                    easeInOutQuad: "easeInOutQuad";
+                    easeInCubic: "easeInCubic";
+                    easeOutCubic: "easeOutCubic";
+                    easeInOutCubic: "easeInOutCubic";
+                    easeInBack: "easeInBack";
+                    easeOutBack: "easeOutBack";
+                    easeInOutBack: "easeInOutBack";
+                    easeInQuart: "easeInQuart";
+                    easeOutQuart: "easeOutQuart";
+                    easeInOutQuart: "easeInOutQuart";
+                    easeInExpo: "easeInExpo";
+                    easeOutExpo: "easeOutExpo";
+                    easeInOutExpo: "easeInOutExpo";
+                }>, z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodObject<{
+                    type: z.ZodLiteral<"spring">;
+                    stiffness: z.ZodNumber;
+                    damping: z.ZodNumber;
+                    mass: z.ZodNumber;
+                }, z.core.$strip>]>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
+        effects: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"blur">;
+            amount: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"vignette">;
+            intensity: z.ZodNumber;
+            size: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"colorGrade">;
+            brightness: z.ZodOptional<z.ZodNumber>;
+            contrast: z.ZodOptional<z.ZodNumber>;
+            saturation: z.ZodOptional<z.ZodNumber>;
+            hue: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"grain">;
+            intensity: z.ZodNumber;
+            size: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"glitch">;
+            intensity: z.ZodNumber;
+            blockSize: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"chromaticAberration">;
+            offset: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"pixelate">;
+            blockSize: z.ZodNumber;
+        }, z.core.$strip>], "type">>>;
+        audioReactive: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            property: z.ZodEnum<{
+                x: "x";
+                y: "y";
+                scale: "scale";
+                rotation: "rotation";
+                opacity: "opacity";
+                blur: "blur";
+                brightness: "brightness";
+                contrast: "contrast";
+                saturation: "saturation";
+                maskProgress: "maskProgress";
+            }>;
+            feature: z.ZodEnum<{
+                rms: "rms";
+                low: "low";
+                mid: "mid";
+                high: "high";
+                beat: "beat";
+            }>;
+            assetId: z.ZodString;
+            factor: z.ZodNumber;
+            mode: z.ZodEnum<{
+                add: "add";
+                multiply: "multiply";
+            }>;
+            smoothing: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>>;
+    }, z.core.$loose>>>;
+    assets: z.ZodOptional<z.ZodArray<z.ZodObject<{}, z.core.$loose>>>;
+}, z.core.$loose>;
+export type ProjectSchemaV2 = z.infer<typeof projectSchemaV2>;

package/dist/schemas.js

@@ -0,0 +1,143 @@
+/**
+ * Zod schema for ProjectFile v2 (load/save path).
+ *
+ * Scope (spec M0 task 9): validate ProjectFile when loading from R2 after
+ * migration. The schema is permissive on unknown fields (passthrough) to
+ * avoid breaking on forward-compat additions, but strict on the v2 schema
+ * markers and type shapes.
+ *
+ * NOTE: this is NOT the LLM-output validator. That one is
+ * `validateGeneratedTimeline` in src/lib/editor/prompt-builder.ts and will
+ * be replaced by a separate Zod schema in M6.
+ */
+import { z } from 'zod';
+// ─── Easing ───────────────────────────────────────────────────
+const EASING_PRESET = z.enum([
+    'linear',
+    'easeInQuad', 'easeOutQuad', 'easeInOutQuad',
+    'easeInCubic', 'easeOutCubic', 'easeInOutCubic',
+    'easeInQuart', 'easeOutQuart', 'easeInOutQuart',
+    'easeInExpo', 'easeOutExpo', 'easeInOutExpo',
+    'easeInBack', 'easeOutBack', 'easeInOutBack',
+]);
+const BEZIER_EASING = z.tuple([z.number(), z.number(), z.number(), z.number()]);
+const SPRING_CONFIG = z.object({
+    type: z.literal('spring'),
+    stiffness: z.number().positive(),
+    damping: z.number().min(0),
+    mass: z.number().positive(),
+});
+const EASING = z.union([EASING_PRESET, BEZIER_EASING, SPRING_CONFIG]);
+// ─── Animation ────────────────────────────────────────────────
+const KEYFRAME = z.object({
+    t: z.number(),
+    v: z.number(),
+    easing: EASING.optional(),
+});
+const ANIMATION = z.object({
+    keyframes: z.array(KEYFRAME).min(1),
+});
+const ANIMATABLE_PROP = z.enum([
+    'x', 'y', 'scale', 'rotation', 'opacity',
+    'blur', 'brightness', 'contrast', 'saturation', 'maskProgress',
+]);
+const ANIMATIONS = z.record(ANIMATABLE_PROP, ANIMATION);
+// ─── Effects ──────────────────────────────────────────────────
+const EFFECT = z.discriminatedUnion('type', [
+    z.object({ type: z.literal('blur'), amount: z.number() }),
+    z.object({ type: z.literal('vignette'), intensity: z.number(), size: z.number() }),
+    z.object({
+        type: z.literal('colorGrade'),
+        brightness: z.number().optional(),
+        contrast: z.number().optional(),
+        saturation: z.number().optional(),
+        hue: z.number().optional(),
+    }),
+    z.object({ type: z.literal('grain'), intensity: z.number(), size: z.number() }),
+    z.object({ type: z.literal('glitch'), intensity: z.number(), blockSize: z.number() }),
+    z.object({ type: z.literal('chromaticAberration'), offset: z.number() }),
+    z.object({ type: z.literal('pixelate'), blockSize: z.number() }),
+]);
+// ─── Mask (v2) ────────────────────────────────────────────────
+const MASK_V2 = z.discriminatedUnion('type', [
+    z.object({ type: z.literal('none') }),
+    z.object({
+        type: z.literal('rect'),
+        x: z.number(), y: z.number(), w: z.number(), h: z.number(),
+        feather: z.number().optional(),
+    }),
+    z.object({
+        type: z.literal('circle'),
+        cx: z.number(), cy: z.number(), r: z.number(),
+        feather: z.number().optional(),
+    }),
+    z.object({
+        type: z.literal('reveal'),
+        direction: z.enum(['ltr', 'rtl', 'ttb', 'btt']),
+        progress: z.number(),
+    }),
+    z.object({ type: z.literal('clipPath'), svgPath: z.string() }),
+]);
+// ─── Audio reactivity ─────────────────────────────────────────
+const AUDIO_REACTIVE = z.object({
+    property: ANIMATABLE_PROP,
+    feature: z.enum(['rms', 'low', 'mid', 'high', 'beat']),
+    assetId: z.string(),
+    factor: z.number(),
+    mode: z.enum(['add', 'multiply']),
+    smoothing: z.number().optional(),
+});
+// ─── Visual objects ───────────────────────────────────────────
+/**
+ * Permissive CanvasObject schema — V1 objects have many legacy fields
+ * (blendMode enum, mask v1 config, constrainProportions, etc.). We validate
+ * only the v2-additions and pass the rest via passthrough.
+ */
+const CANVAS_OBJECT = z.object({
+    id: z.string(),
+    clipId: z.string(),
+    x: z.number(),
+    y: z.number(),
+    w: z.number(),
+    h: z.number(),
+    rotation: z.number(),
+    animations: ANIMATIONS.optional(),
+    effects: z.array(EFFECT).optional(),
+    maskV2: MASK_V2.optional(),
+    audioReactive: z.array(AUDIO_REACTIVE).optional(),
+}).passthrough();
+/**
+ * Permissive TextOverlay schema — the V1 type has 20+ style fields. We
+ * validate only the v2-relevant additions and the handful of base fields
+ * the loader/renderer relies on; rest passes through.
+ */
+const TEXT_OVERLAY = z.object({
+    id: z.string(),
+    text: z.string(),
+    startMs: z.number(),
+    endMs: z.number(),
+    x: z.number(),
+    y: z.number(),
+    animations: ANIMATIONS.optional(),
+    effects: z.array(EFFECT).optional(),
+    audioReactive: z.array(AUDIO_REACTIVE).optional(),
+}).passthrough();
+// ─── ProjectFile v2 ───────────────────────────────────────────
+export const projectSchemaV2 = z.object({
+    schemaVersion: z.literal(2),
+    // Legacy field from V1 files — coexists with schemaVersion.
+    version: z.number().optional(),
+    projectName: z.string().optional(),
+    videoDurationMs: z.number().optional(),
+    canvasPreset: z.object({
+        id: z.string(),
+        label: z.string().optional(),
+        width: z.number(),
+        height: z.number(),
+    }).passthrough().optional(),
+    tracks: z.array(z.object({}).passthrough()).optional(),
+    timelineClips: z.array(z.object({}).passthrough()).optional(),
+    canvasObjects: z.array(CANVAS_OBJECT).optional(),
+    textOverlays: z.array(TEXT_OVERLAY).optional(),
+    assets: z.array(z.object({}).passthrough()).optional(),
+}).passthrough();

package/dist/store.d.ts

@@ -0,0 +1,256 @@
+/**
+ * Editor store — the single source of truth for timeline / canvas / text
+ * state and every editing operation (add, split, trim, transitions,
+ * canvas presets, undo…). Runs anywhere: the browser wraps it in a React
+ * hook (vivid-app `src/store/editor.ts`), vivid-mcp drives it headless in
+ * Node. Everything that touches the browser (audio engine, asset manager,
+ * localStorage, rAF, vision analysis) is injected through `EditorStoreDeps`
+ * and defaults to a no-op.
+ */
+import { type StoreApi } from 'zustand/vanilla';
+import type { TextOverlay } from './types/editor.js';
+import type { Animations } from './types/animation.js';
+import type { Effect } from './types/effect.js';
+import type { Mask as MaskV2 } from './types/mask.js';
+import type { AudioReactiveModifier } from './types/audioReactive.js';
+import type { BeatAnalysis } from './types/beat.js';
+/** Browser-side hooks. Every member is optional — headless use passes `{}`. */
+export interface EditorStoreDeps {
+    /** Playhead moved by a seek (already clamped). */
+    onSeek?: (ms: number) => void;
+    /** Play / pause toggled. */
+    onPlayingChange?: (playing: boolean) => void;
+    /** Asset library changes (browser: AssetManager, beat analysis). */
+    onAssetAdded?: (clip: AssetClip) => void;
+    onAssetRemoved?: (id: string) => void;
+    onAssetUpdated?: (id: string, patch: Partial<AssetClip>) => void;
+    /** Fire-and-forget vision description for a visual asset. */
+    analyzeAsset?: (clip: AssetClip) => Promise<{
+        description?: string | null;
+    } | undefined>;
+    /** Tiny key/value persistence (browser: localStorage). */
+    storage?: {
+        get: (key: string) => string | null;
+        set: (key: string, value: string) => void;
+    };
+    /** Schedule a callback on the next frame (browser: requestAnimationFrame). */
+    nextFrame?: (cb: () => void) => void;
+}
+export type MediaType = 'video' | 'audio' | 'image' | 'color';
+export type TrackType = 'visual' | 'audio';
+export interface TrackDefinition {
+    id: string;
+    label: string;
+    type: TrackType;
+    color: string;
+}
+/** @deprecated Use store `tracks` state instead. Kept for backward compatibility. */
+export declare const TIMELINE_TRACKS: TrackDefinition[];
+export interface AssetClip {
+    id: string;
+    name: string;
+    url: string;
+    durationMs: number;
+    file: File | null;
+    mediaType: MediaType;
+    /** Intrinsic pixel width of the media (video.videoWidth / img.naturalWidth) */
+    intrinsicWidth?: number;
+    /** Intrinsic pixel height of the media (video.videoHeight / img.naturalHeight) */
+    intrinsicHeight?: number;
+    /** Server-side asset ID (set after uploading to R2 or when imported from library) */
+    serverAssetId?: string;
+    /** Origin of this asset — used to filter gallery and prevent duplicate uploads */
+    source?: 'upload' | 'library' | 'pexels' | 'stock';
+    /** Beats per minute — set for audio tracks to enable beat-synced editing */
+    bpm?: number;
+    /** AI-generated description of visual content (from vision analysis) */
+    aiDescription?: string;
+}
+export type TransitionType = 'dissolve' | 'fade-black';
+export type AudioTransitionType = 'crossfade' | 'fade-in' | 'fade-out';
+export interface TransitionConfig {
+    type: TransitionType | AudioTransitionType;
+    durationMs: number;
+}
+/** Clip-level animation types for entrance/exit */
+export type ClipAnimationType = 'none' | 'fade' | 'slide-up' | 'slide-down' | 'zoom-in' | 'zoom-out' | 'zoom-pan' | 'spin' | 'blur-reveal';
+export interface ClipAnimationConfig {
+    type: ClipAnimationType;
+    durationMs: number;
+}
+export interface TimelineClip {
+    id: string;
+    assetId: string;
+    name: string;
+    url: string;
+    startMs: number;
+    durationMs: number;
+    originalDurationMs: number;
+    sourceOffsetMs: number;
+    mediaType: MediaType;
+    trackId: string;
+    /** When true, audio is detached from this video clip (video plays muted, separate audio clip exists) */
+    isAudioDetached?: boolean;
+    /** Transition applied at the start of this clip */
+    transitionIn?: TransitionConfig;
+    /** Transition applied at the end of this clip */
+    transitionOut?: TransitionConfig;
+    /** Entrance animation */
+    animationIn?: ClipAnimationConfig;
+    /** Exit animation */
+    animationOut?: ClipAnimationConfig;
+    /** Fill color for 'color' type clips */
+    color?: string;
+    /** Clip volume 0-1 (default 1) */
+    volume?: number;
+    /** Clip opacity 0-1 (default 1, fully opaque) */
+    opacity?: number;
+    /** Playback speed multiplier (default 1.0). Changes visual duration on timeline. */
+    playbackRate?: number;
+}
+export type MaskType = 'none' | 'rounded' | 'circle' | 'star' | 'hexagon';
+export type MaskAspectPreset = 'free' | '1:1' | '4:3' | '3:4' | '16:9' | '9:16';
+export interface MaskConfig {
+    type: MaskType;
+    borderRadius?: number;
+    /** Relative mask crop region (0-1 fractions of the media element). Set via MaskEditorModal. */
+    cropX?: number;
+    cropY?: number;
+    cropW?: number;
+    cropH?: number;
+    /** Aspect lock used by the MaskEditorModal resize handles. 'free' (default)
+     *  resizes width/height independently; a ratio preset keeps the crop locked
+     *  to it. Circle masks ignore this — they always render as a true circle. */
+    aspectPreset?: MaskAspectPreset;
+}
+export type BlendMode = 'normal' | 'multiply' | 'screen' | 'overlay' | 'darken' | 'lighten' | 'color-dodge' | 'color-burn' | 'hard-light' | 'soft-light' | 'difference' | 'exclusion';
+export interface CanvasObject {
+    id: string;
+    clipId: string;
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    rotation: number;
+    mask?: MaskConfig;
+    blendMode?: BlendMode;
+    constrainProportions?: boolean;
+    animations?: Animations;
+    effects?: Effect[];
+    maskV2?: MaskV2;
+    audioReactive?: AudioReactiveModifier[];
+}
+export interface CanvasPreset {
+    id: string;
+    label: string;
+    width: number;
+    height: number;
+}
+export interface SnapGuide {
+    axis: 'x' | 'y';
+    position: number;
+}
+export declare const CANVAS_PRESETS: CanvasPreset[];
+export type CinematicLook = 'none' | 'kodak-portra' | 'noir' | 'cyberpunk' | 'kodak-portra-400' | 'fuji-provia' | 'ilford-hp5' | 'cinestill-800t' | 'bleach-bypass' | 'polaroid-vintage' | 'technicolor' | 'cross-process' | 'muted-cinematic' | 'cyberpunk-neon';
+export declare const CINEMATIC_LOOKS: {
+    value: CinematicLook;
+    label: string;
+}[];
+/** CSS filter string for live DOM preview */
+export declare function getCinematicFilter(look: CinematicLook): string;
+export declare const MAX_TIMELINE_MS = 300000;
+export declare const MAX_CROSSFADE_MS = 3000;
+export declare const ZOOM_MIN_PX_PER_SEC = 10;
+export declare const ZOOM_MAX_PX_PER_SEC = 3000;
+export declare const ZOOM_DEFAULT_PX_PER_SEC = 100;
+export declare function maxPxPerSecForDuration(durationMs: number): number;
+export interface UndoableState {
+    timelineClips: TimelineClip[];
+    canvasObjects: CanvasObject[];
+    tracks: TrackDefinition[];
+    textOverlays: TextOverlay[];
+}
+export interface EditorState {
+    playheadMs: number;
+    isPlaying: boolean;
+    loopPlayback: boolean;
+    assetLibrary: AssetClip[];
+    selectedAssetIds: Set<string>;
+    timelineClips: TimelineClip[];
+    selectedClipId: string | null;
+    tracks: TrackDefinition[];
+    nextVisualNum: number;
+    nextAudioNum: number;
+    canvasPreset: CanvasPreset;
+    canvasObjects: CanvasObject[];
+    selectedObjectId: string | null;
+    snapGuides: SnapGuide[];
+    textOverlays: TextOverlay[];
+    selectedTextId: string | null;
+    cinematicLook: CinematicLook;
+    projectName: string;
+    pendingReframe: CanvasPreset | null;
+    maskEditorClipId: string | null;
+    pxPerSec: number;
+    audioBeatsByAssetId: Record<string, BeatAnalysis | 'analyzing' | 'failed'>;
+    undoStack: UndoableState[];
+    redoStack: UndoableState[];
+    setProjectName: (name: string) => void;
+    setPlayheadMs: (ms: number) => void;
+    setIsPlaying: (playing: boolean) => void;
+    toggleLoopPlayback: () => void;
+    addAsset: (clip: AssetClip) => void;
+    removeAsset: (id: string) => void;
+    updateAsset: (id: string, patch: Partial<AssetClip>) => void;
+    toggleAssetSelected: (id: string) => void;
+    clearAssetSelection: () => void;
+    addClipToTimeline: (asset: AssetClip) => void;
+    updateClipBounds: (id: string, updates: Partial<Pick<TimelineClip, 'startMs' | 'durationMs' | 'sourceOffsetMs'>>) => void;
+    moveClip: (id: string, newStartMs: number, newTrackId?: string, allowOverlap?: boolean) => void;
+    trimClipStart: (id: string, deltaMs: number) => void;
+    trimClipEnd: (id: string, deltaMs: number) => void;
+    splitClip: (splitAtMs: number) => void;
+    duplicateClip: (id: string) => void;
+    deleteSelectedClip: () => void;
+    deleteClipById: (id: string) => void;
+    setSelectedClipId: (id: string | null) => void;
+    addColorClip: (color: string, durationMs: number) => void;
+    setClipTransition: (clipId: string, edge: 'in' | 'out', config: TransitionConfig | undefined) => void;
+    setClipVolume: (clipId: string, volume: number) => void;
+    detachAudio: (clipId: string) => void;
+    setClipOpacity: (clipId: string, opacity: number) => void;
+    setClipSpeed: (clipId: string, rate: number) => void;
+    setClipAnimation: (clipId: string, phase: 'in' | 'out', config: ClipAnimationConfig | undefined) => void;
+    addTrack: (type: TrackType) => TrackDefinition;
+    removeEmptyTracks: () => void;
+    ensureAudioTrack: (visualTrackId: string) => void;
+    addTextOverlay: (overlay: TextOverlay) => void;
+    updateTextOverlay: (id: string, patch: Partial<TextOverlay>) => void;
+    removeTextOverlay: (id: string) => void;
+    setSelectedTextId: (id: string | null) => void;
+    setCanvasPreset: (preset: CanvasPreset) => void;
+    updateCanvasObject: (id: string, patch: Partial<CanvasObject>) => void;
+    setSelectedObjectId: (id: string | null) => void;
+    setSnapGuides: (guides: SnapGuide[]) => void;
+    setCinematicLook: (look: CinematicLook) => void;
+    dismissReframe: () => void;
+    openMaskEditor: (clipId: string) => void;
+    closeMaskEditor: () => void;
+    setPxPerSec: (pxPerSec: number) => void;
+    zoomIn: () => void;
+    zoomOut: () => void;
+    undo: () => void;
+    redo: () => void;
+    pushUndo: () => void;
+    setAudioBeatsStatus: (assetId: string, value: BeatAnalysis | 'analyzing' | 'failed') => void;
+    replaceTimelineClips: (clips: TimelineClip[], canvasObjects?: CanvasObject[]) => void;
+    hydrateTimeline: (data: {
+        tracks: TrackDefinition[];
+        timelineClips: TimelineClip[];
+        canvasObjects: CanvasObject[];
+        textOverlays: import('./types/editor.js').TextOverlay[];
+    }) => void;
+    reset: () => void;
+}
+export type EditorStore = StoreApi<EditorState>;
+export declare function createEditorStore(deps?: EditorStoreDeps): EditorStore;