@vibeframe/cli 0.105.1 → 0.106.0

package/dist/commands/timeline.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const timelineCommand: Command;

package/dist/commands/timeline.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/validate.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @module validate
+ * @description Input validation layer for CLI commands.
+ * Guards against path traversal, control characters, and invalid resource IDs.
+ */
+/**
+ * Validate and resolve an output path.
+ * Prevents path traversal attacks (e.g., --output ../../etc/passwd).
+ * Absolute paths are allowed (explicit user intent), but relative paths
+ * containing ".." that escape the working directory are blocked.
+ */
+export declare function validateOutputPath(path: string, cwd?: string): string;
+/**
+ * Validate a resource ID (source-*, clip-*, track-*, effect-*).
+ * Only allows alphanumeric characters, hyphens, and underscores.
+ */
+export declare function validateResourceId(id: string): string;
+/**
+ * Reject strings containing control characters (U+0000–U+001F, U+007F–U+009F).
+ * Prevents terminal injection and other control-char exploits.
+ */
+export declare function rejectControlChars(input: string): string;
+/**
+ * Validate a media file path and check its extension against an allowlist.
+ */
+export declare function validateMediaFile(path: string, allowedExts: string[]): string;
+/** Common media file extensions */
+export declare const MEDIA_EXTS: {
+    video: string[];
+    audio: string[];
+    image: string[];
+    subtitle: string[];
+};

package/dist/commands/walkthrough.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @module commands/walkthrough
+ *
+ * `vibe guide [topic]` — universal CLI equivalent of Claude Code's
+ * `/vibe-scene` and `/vibe-pipeline` slash commands. Any host agent
+ * (Claude Code, Codex, Cursor, Aider, Gemini CLI, OpenCode) can invoke
+ * this to load the same step-by-step authoring guide the slash commands
+ * deliver in Claude Code — closes the last Claude-Code-only gap on top
+ * of Plan H's universal skill / compose primitives.
+ *
+ * Without arguments, lists available topics. With a topic, emits the
+ * full markdown body + structured metadata. `--json` returns the
+ * structured shape from `loadWalkthrough()` directly.
+ *
+ * The old `vibe walkthrough` spelling is registered as a hidden deprecated
+ * compatibility command from `index.ts`, but all public help/docs should point
+ * users at `vibe guide`.
+ */
+import { Command } from "commander";
+export declare const guideCommand: Command;
+export declare const legacyGuideAliasCommand: Command;

package/dist/config/config.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/config/index.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Configuration loader/saver for VibeFrame CLI.
+ *
+ * Two scopes:
+ *   - user    ~/.vibeframe/config.yaml         (shared across projects)
+ *   - project <cwd>/.vibeframe/config.yaml     (gitignored, per-project)
+ *
+ * Precedence at runtime: process.env > project > user.
+ *
+ * Default `loadConfig()` behavior is "auto" — if a project config exists in
+ * the current working directory or one of its parents, it is used and the user
+ * config is ignored.
+ * Pass `{scope:"user"}` or `{scope:"project"}` to force one side.
+ *
+ * Pass `{merge:true}` to overlay project on user (project wins). Used by
+ * doctor to render "where did this key come from" diagnostics.
+ */
+import { type VibeConfig } from "./schema.js";
+export type Scope = "user" | "project";
+/** User-scope config directory (~/.vibeframe by default). */
+export declare const USER_CONFIG_DIR: string;
+/** User-scope config file (~/.vibeframe/config.yaml by default). */
+export declare const USER_CONFIG_PATH: string;
+/** User data directory (~/.local/share/vibeframe by default). */
+export declare const USER_DATA_DIR: string;
+/** User cache directory (~/.vibeframe/cache by default). */
+export declare const USER_CACHE_DIR: string;
+/** Legacy user-scope config directory used by pre-XDG installs. */
+export declare const LEGACY_USER_CONFIG_DIR: string;
+/** Legacy user-scope config file used by pre-XDG installs. */
+export declare const LEGACY_USER_CONFIG_PATH: string;
+/**
+ * Back-compat aliases. New code should use `USER_CONFIG_PATH` /
+ * `USER_CONFIG_DIR` or `getConfigPath(scope)` to be scope-explicit.
+ */
+export declare const CONFIG_DIR: string;
+export declare const CONFIG_PATH: string;
+export declare class ConfigFileError extends Error {
+    readonly path: string;
+    constructor(path: string, cause: unknown);
+}
+/** Project-scope config directory (`<cwd>/.vibeframe`). */
+export declare function getProjectConfigDir(cwd?: string): string;
+/** Project-scope config file (`<cwd>/.vibeframe/config.yaml`). */
+export declare function getProjectConfigPath(cwd?: string): string;
+/** Resolve config file path for a given scope. */
+export declare function getConfigPath(scope: Scope, cwd?: string): string;
+/** Resolve config directory for a given scope. */
+export declare function getConfigDir(scope: Scope, cwd?: string): string;
+export interface UserConfigStatus {
+    /** True when either the primary config file or legacy ~/.vibeframe/config.yaml exists. */
+    configured: boolean;
+    /** Path loadConfig({scope:"user"}) will read from, or the write path when absent. */
+    configPath: string;
+    /** Write target for new user-scope saves. */
+    writePath: string;
+    /** Legacy fallback path. */
+    legacyConfigPath: string;
+    /** True when the primary write target exists. */
+    primaryConfigured: boolean;
+    /** True when the legacy fallback exists. */
+    legacyConfigured: boolean;
+    /** Source currently used for user-scope reads. */
+    source: "user" | "legacy" | null;
+}
+export declare function getUserConfigStatus(): Promise<UserConfigStatus>;
+export declare function findProjectConfigPath(cwd?: string): Promise<string | null>;
+/**
+ * The scope that `loadConfig()` will read from when called without an
+ * explicit scope. Returns `"project"` if a project config exists at cwd or an
+ * ancestor directory, else `"user"` (regardless of whether the user file exists).
+ */
+export declare function getActiveScope(cwd?: string): Promise<Scope>;
+export interface LoadConfigOptions {
+    /** Force a specific scope. Default: auto (project if exists, else user). */
+    scope?: Scope;
+    /** Working directory for resolving the project scope. Default: process.cwd(). */
+    cwd?: string;
+    /** Overlay project on user (project wins). Useful for doctor diagnostics. */
+    merge?: boolean;
+}
+/**
+ * Load configuration. Returns null if no config exists at the resolved scope.
+ */
+export declare function loadConfig(options?: LoadConfigOptions): Promise<VibeConfig | null>;
+export interface SaveConfigOptions {
+    /** Target scope. Default: "user" (back-compat with prior behavior). */
+    scope?: Scope;
+    /** Working directory for resolving the project scope. Default: process.cwd(). */
+    cwd?: string;
+}
+/** Save configuration to the chosen scope. Default scope is "user". */
+export declare function saveConfig(config: VibeConfig, options?: SaveConfigOptions): Promise<void>;
+/**
+ * Check if any configuration is present and the primary LLM provider has a
+ * key (in the active scope or the environment).
+ */
+export declare function isConfigured(options?: Pick<LoadConfigOptions, "cwd">): Promise<boolean>;
+/**
+ * Get an API key. Auto-detects scope (project > user) and falls through to
+ * the provider's environment variable if neither config has it.
+ */
+export declare function getApiKeyFromConfig(providerKey: string, options?: Pick<LoadConfigOptions, "cwd">): Promise<string | undefined>;
+/**
+ * Update a provider key in the active scope (project if present, else user).
+ * Pass `{scope}` to force a specific destination.
+ */
+export declare function updateProviderKey(providerKey: string, apiKey: string, options?: SaveConfigOptions): Promise<void>;
+export type { VibeConfig, LLMProvider } from "./schema.js";
+export { createDefaultConfig, PROVIDER_NAMES, PROVIDER_ENV_ALIASES, PROVIDER_ENV_VARS, } from "./schema.js";

package/dist/config/schema.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Configuration schema for VibeFrame CLI
+ * Stored at ~/.vibeframe/config.yaml by default.
+ */
+export type LLMProvider = "claude" | "openai" | "gemini" | "ollama" | "xai" | "openrouter";
+export interface VibeConfig {
+    /** Config file version */
+    version: string;
+    /** LLM provider settings */
+    llm: {
+        /** Primary LLM provider for AI commands */
+        provider: LLMProvider;
+    };
+    /** API keys for various providers */
+    providers: {
+        anthropic?: string;
+        openai?: string;
+        google?: string;
+        elevenlabs?: string;
+        runway?: string;
+        kling?: string;
+        fal?: string;
+        imgbb?: string;
+        replicate?: string;
+        xai?: string;
+        openrouter?: string;
+    };
+    /** Default settings for new projects */
+    defaults: {
+        aspectRatio: "16:9" | "9:16" | "1:1" | "4:5";
+        exportQuality: "draft" | "standard" | "high" | "ultra";
+        /** Default provider for image generation */
+        imageProvider?: "gemini" | "openai" | "grok";
+        /** Default provider for video generation. `fal` is a deprecated v0.x alias for `seedance` and will be removed at 1.0. */
+        videoProvider?: "seedance" | "fal" | "grok" | "kling" | "runway" | "veo";
+        /** Default provider for storyboard analysis */
+        storyboardProvider?: "claude" | "openai" | "gemini";
+        /** Default voice for TTS */
+        voice?: string;
+    };
+    /** Temporary upload host for providers that require HTTPS image URLs */
+    upload: {
+        provider: "imgbb" | "s3";
+        ttlSeconds: number;
+        s3?: {
+            bucket?: string;
+            region?: string;
+            prefix?: string;
+            endpoint?: string;
+            publicBaseUrl?: string;
+        };
+    };
+    /** REPL settings */
+    repl: {
+        /** Auto-save project after each command */
+        autoSave: boolean;
+    };
+}
+/** Provider display names */
+export declare const PROVIDER_NAMES: Record<LLMProvider, string>;
+export declare const PROVIDER_ENV_VARS: Record<string, string>;
+export declare const PROVIDER_ENV_ALIASES: Record<string, readonly string[]>;
+/** Default configuration */
+export declare function createDefaultConfig(): VibeConfig;

package/dist/config/scope.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/engine/index.d.ts

@@ -0,0 +1,2 @@
+export { Project, generateId } from "./project.js";
+export type { ProjectFile } from "./project.js";

package/dist/engine/index.js

@@ -0,0 +1,345 @@
+import { createRequire as __vfCreateRequire } from 'node:module';
+const require = __vfCreateRequire(import.meta.url);
+
+// src/engine/project.ts
+var generateId = () => {
+  return `${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;
+};
+function createDefaultState(name = "Untitled Project") {
+  return {
+    project: {
+      id: generateId(),
+      name,
+      createdAt: /* @__PURE__ */ new Date(),
+      updatedAt: /* @__PURE__ */ new Date(),
+      aspectRatio: "16:9",
+      frameRate: 30,
+      duration: 0
+    },
+    tracks: [
+      {
+        id: "video-track-1",
+        name: "Video 1",
+        type: "video",
+        order: 1,
+        isMuted: false,
+        isLocked: false,
+        isVisible: true
+      },
+      {
+        id: "audio-track-1",
+        name: "Audio 1",
+        type: "audio",
+        order: 0,
+        isMuted: false,
+        isLocked: false,
+        isVisible: true
+      }
+    ],
+    clips: [],
+    sources: [],
+    transitions: [],
+    currentTime: 0,
+    isPlaying: false,
+    zoom: 50,
+    scrollX: 0,
+    selectedClipIds: [],
+    selectedTrackId: null
+  };
+}
+var Project = class _Project {
+  state;
+  filePath = null;
+  constructor(name) {
+    this.state = createDefaultState(name);
+  }
+  /** Get current state (immutable copy) */
+  getState() {
+    return structuredClone(this.state);
+  }
+  /** Get project metadata */
+  getMeta() {
+    return { ...this.state.project };
+  }
+  /** Get file path */
+  getFilePath() {
+    return this.filePath;
+  }
+  // ============ Project Operations ============
+  setName(name) {
+    this.state.project.name = name;
+    this.state.project.updatedAt = /* @__PURE__ */ new Date();
+  }
+  setAspectRatio(ratio) {
+    this.state.project.aspectRatio = ratio;
+    this.state.project.updatedAt = /* @__PURE__ */ new Date();
+  }
+  setFrameRate(fps) {
+    this.state.project.frameRate = fps;
+    this.state.project.updatedAt = /* @__PURE__ */ new Date();
+  }
+  // ============ Media Source Operations ============
+  addSource(source) {
+    const newSource = { ...source, id: generateId() };
+    this.state.sources.push(newSource);
+    return newSource;
+  }
+  removeSource(id) {
+    const index = this.state.sources.findIndex((s) => s.id === id);
+    if (index === -1) return false;
+    this.state.sources.splice(index, 1);
+    this.state.clips = this.state.clips.filter((c) => c.sourceId !== id);
+    this.calculateDuration();
+    return true;
+  }
+  getSource(id) {
+    return this.state.sources.find((s) => s.id === id);
+  }
+  getSources() {
+    return [...this.state.sources];
+  }
+  // ============ Track Operations ============
+  addTrack(track) {
+    const newTrack = { ...track, id: generateId() };
+    this.state.tracks.push(newTrack);
+    return newTrack;
+  }
+  removeTrack(id) {
+    const index = this.state.tracks.findIndex((t) => t.id === id);
+    if (index === -1) return false;
+    this.state.tracks.splice(index, 1);
+    this.state.clips = this.state.clips.filter((c) => c.trackId !== id);
+    this.calculateDuration();
+    return true;
+  }
+  updateTrack(id, updates) {
+    const track = this.state.tracks.find((t) => t.id === id);
+    if (!track) return false;
+    Object.assign(track, updates);
+    return true;
+  }
+  getTrack(id) {
+    return this.state.tracks.find((t) => t.id === id);
+  }
+  getTracks() {
+    return [...this.state.tracks];
+  }
+  getTracksByType(type) {
+    return this.state.tracks.filter((t) => t.type === type);
+  }
+  // ============ Clip Operations ============
+  addClip(clip) {
+    const newClip = {
+      ...clip,
+      id: generateId(),
+      effects: []
+    };
+    this.state.clips.push(newClip);
+    this.calculateDuration();
+    return newClip;
+  }
+  removeClip(id) {
+    const index = this.state.clips.findIndex((c) => c.id === id);
+    if (index === -1) return false;
+    this.state.clips.splice(index, 1);
+    this.state.selectedClipIds = this.state.selectedClipIds.filter((cid) => cid !== id);
+    this.calculateDuration();
+    return true;
+  }
+  updateClip(id, updates) {
+    const clip = this.state.clips.find((c) => c.id === id);
+    if (!clip) return false;
+    Object.assign(clip, updates);
+    this.calculateDuration();
+    return true;
+  }
+  moveClip(id, trackId, startTime) {
+    const clip = this.state.clips.find((c) => c.id === id);
+    if (!clip) return false;
+    clip.trackId = trackId;
+    clip.startTime = Math.max(0, startTime);
+    this.calculateDuration();
+    return true;
+  }
+  trimClipStart(id, newStartTime) {
+    const clip = this.state.clips.find((c) => c.id === id);
+    if (!clip) return false;
+    const delta = newStartTime - clip.startTime;
+    clip.startTime = newStartTime;
+    clip.sourceStartOffset += delta;
+    clip.duration -= delta;
+    this.calculateDuration();
+    return true;
+  }
+  trimClipEnd(id, newDuration) {
+    const clip = this.state.clips.find((c) => c.id === id);
+    if (!clip) return false;
+    clip.duration = Math.max(0.1, newDuration);
+    clip.sourceEndOffset = clip.sourceStartOffset + clip.duration;
+    this.calculateDuration();
+    return true;
+  }
+  getClip(id) {
+    return this.state.clips.find((c) => c.id === id);
+  }
+  getClips() {
+    return [...this.state.clips];
+  }
+  getClipsByTrack(trackId) {
+    return this.state.clips.filter((c) => c.trackId === trackId);
+  }
+  /**
+   * Split a clip at a specific time, creating two clips
+   * @param id Clip ID to split
+   * @param splitTime Time relative to clip start (not timeline time)
+   * @returns [firstClip, secondClip] or null if failed
+   */
+  splitClip(id, splitTime) {
+    const clip = this.state.clips.find((c) => c.id === id);
+    if (!clip) return null;
+    if (splitTime <= 0 || splitTime >= clip.duration) {
+      return null;
+    }
+    const secondClip = {
+      id: generateId(),
+      sourceId: clip.sourceId,
+      trackId: clip.trackId,
+      startTime: clip.startTime + splitTime,
+      duration: clip.duration - splitTime,
+      sourceStartOffset: clip.sourceStartOffset + splitTime,
+      sourceEndOffset: clip.sourceEndOffset,
+      effects: []
+      // Effects don't transfer to split clips
+    };
+    clip.duration = splitTime;
+    clip.sourceEndOffset = clip.sourceStartOffset + splitTime;
+    this.state.clips.push(secondClip);
+    this.calculateDuration();
+    return [clip, secondClip];
+  }
+  /**
+   * Duplicate a clip
+   * @param id Clip ID to duplicate
+   * @param offsetTime Optional time offset for the duplicate (default: place after original)
+   * @returns The duplicated clip or null if failed
+   */
+  duplicateClip(id, offsetTime) {
+    const clip = this.state.clips.find((c) => c.id === id);
+    if (!clip) return null;
+    const newStartTime = offsetTime ?? clip.startTime + clip.duration;
+    const duplicatedClip = {
+      id: generateId(),
+      sourceId: clip.sourceId,
+      trackId: clip.trackId,
+      startTime: newStartTime,
+      duration: clip.duration,
+      sourceStartOffset: clip.sourceStartOffset,
+      sourceEndOffset: clip.sourceEndOffset,
+      effects: clip.effects.map((e) => ({
+        ...e,
+        id: generateId()
+      }))
+    };
+    this.state.clips.push(duplicatedClip);
+    this.calculateDuration();
+    return duplicatedClip;
+  }
+  // ============ Effect Operations ============
+  addEffect(clipId, effect) {
+    const clip = this.state.clips.find((c) => c.id === clipId);
+    if (!clip) return null;
+    const newEffect = { ...effect, id: generateId() };
+    clip.effects.push(newEffect);
+    return newEffect;
+  }
+  removeEffect(clipId, effectId) {
+    const clip = this.state.clips.find((c) => c.id === clipId);
+    if (!clip) return false;
+    const index = clip.effects.findIndex((e) => e.id === effectId);
+    if (index === -1) return false;
+    clip.effects.splice(index, 1);
+    return true;
+  }
+  updateEffect(clipId, effectId, updates) {
+    const clip = this.state.clips.find((c) => c.id === clipId);
+    if (!clip) return false;
+    const effect = clip.effects.find((e) => e.id === effectId);
+    if (!effect) return false;
+    Object.assign(effect, updates);
+    return true;
+  }
+  // ============ Transition Operations ============
+  addTransition(transition) {
+    const newTransition = { ...transition, id: generateId() };
+    this.state.transitions.push(newTransition);
+    return newTransition;
+  }
+  removeTransition(id) {
+    const index = this.state.transitions.findIndex((t) => t.id === id);
+    if (index === -1) return false;
+    this.state.transitions.splice(index, 1);
+    return true;
+  }
+  getTransitions() {
+    return [...this.state.transitions];
+  }
+  // ============ Duration Calculation ============
+  calculateDuration() {
+    const maxEndTime = this.state.clips.reduce((max, clip) => {
+      const endTime = clip.startTime + clip.duration;
+      return Math.max(max, endTime);
+    }, 0);
+    this.state.project.duration = maxEndTime;
+  }
+  getDuration() {
+    return this.state.project.duration;
+  }
+  // ============ Serialization ============
+  toJSON() {
+    const state = this.getState();
+    return {
+      version: "1.0.0",
+      state: {
+        project: state.project,
+        tracks: state.tracks,
+        clips: state.clips,
+        sources: state.sources,
+        transitions: state.transitions
+      }
+    };
+  }
+  static fromJSON(data) {
+    const project = new _Project();
+    data.state.project.createdAt = new Date(data.state.project.createdAt);
+    data.state.project.updatedAt = new Date(data.state.project.updatedAt);
+    project.state = {
+      ...data.state,
+      currentTime: 0,
+      isPlaying: false,
+      zoom: 50,
+      scrollX: 0,
+      selectedClipIds: [],
+      selectedTrackId: null
+    };
+    return project;
+  }
+  setFilePath(path) {
+    this.filePath = path;
+  }
+  // ============ Summary ============
+  getSummary() {
+    return {
+      name: this.state.project.name,
+      duration: this.state.project.duration,
+      aspectRatio: this.state.project.aspectRatio,
+      frameRate: this.state.project.frameRate,
+      trackCount: this.state.tracks.length,
+      clipCount: this.state.clips.length,
+      sourceCount: this.state.sources.length
+    };
+  }
+};
+export {
+  Project,
+  generateId
+};

package/dist/engine/project.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Headless Project Engine for CLI operations
+ * No React/Zustand dependency - pure TypeScript
+ */
+import type { TimelineState, ProjectMeta, Track, Clip, MediaSource, Effect, Transition, Id, TimeSeconds, AspectRatio, MediaType } from "@vibeframe/core/timeline";
+/** Generate unique ID */
+export declare const generateId: () => Id;
+/**
+ * Persisted timeline shape — what gets written to disk.
+ *
+ * UI runtime fields (currentTime, isPlaying, zoom, scrollX, selectedClipIds,
+ * selectedTrackId) are stripped on save and re-injected with defaults on
+ * load. They have no business in a CLI-generated project file: every CLI
+ * command starts a fresh process, so playhead / zoom / selection have no
+ * continuity to preserve.
+ */
+export type PersistedTimelineState = Omit<TimelineState, "currentTime" | "isPlaying" | "zoom" | "scrollX" | "selectedClipIds" | "selectedTrackId">;
+/** Project file format */
+export interface ProjectFile {
+    version: string;
+    state: PersistedTimelineState;
+}
+/**
+ * Headless Project Engine
+ * Manages timeline state without React/Zustand
+ */
+export declare class Project {
+    private state;
+    private filePath;
+    constructor(name?: string);
+    /** Get current state (immutable copy) */
+    getState(): TimelineState;
+    /** Get project metadata */
+    getMeta(): ProjectMeta;
+    /** Get file path */
+    getFilePath(): string | null;
+    setName(name: string): void;
+    setAspectRatio(ratio: AspectRatio): void;
+    setFrameRate(fps: number): void;
+    addSource(source: Omit<MediaSource, "id">): MediaSource;
+    removeSource(id: Id): boolean;
+    getSource(id: Id): MediaSource | undefined;
+    getSources(): MediaSource[];
+    addTrack(track: Omit<Track, "id">): Track;
+    removeTrack(id: Id): boolean;
+    updateTrack(id: Id, updates: Partial<Omit<Track, "id">>): boolean;
+    getTrack(id: Id): Track | undefined;
+    getTracks(): Track[];
+    getTracksByType(type: MediaType): Track[];
+    addClip(clip: Omit<Clip, "id" | "effects">): Clip;
+    removeClip(id: Id): boolean;
+    updateClip(id: Id, updates: Partial<Omit<Clip, "id">>): boolean;
+    moveClip(id: Id, trackId: Id, startTime: TimeSeconds): boolean;
+    trimClipStart(id: Id, newStartTime: TimeSeconds): boolean;
+    trimClipEnd(id: Id, newDuration: TimeSeconds): boolean;
+    getClip(id: Id): Clip | undefined;
+    getClips(): Clip[];
+    getClipsByTrack(trackId: Id): Clip[];
+    /**
+     * Split a clip at a specific time, creating two clips
+     * @param id Clip ID to split
+     * @param splitTime Time relative to clip start (not timeline time)
+     * @returns [firstClip, secondClip] or null if failed
+     */
+    splitClip(id: Id, splitTime: TimeSeconds): [Clip, Clip] | null;
+    /**
+     * Duplicate a clip
+     * @param id Clip ID to duplicate
+     * @param offsetTime Optional time offset for the duplicate (default: place after original)
+     * @returns The duplicated clip or null if failed
+     */
+    duplicateClip(id: Id, offsetTime?: TimeSeconds): Clip | null;
+    addEffect(clipId: Id, effect: Omit<Effect, "id">): Effect | null;
+    removeEffect(clipId: Id, effectId: Id): boolean;
+    updateEffect(clipId: Id, effectId: Id, updates: Partial<Omit<Effect, "id">>): boolean;
+    addTransition(transition: Omit<Transition, "id">): Transition;
+    removeTransition(id: Id): boolean;
+    getTransitions(): Transition[];
+    private calculateDuration;
+    getDuration(): TimeSeconds;
+    toJSON(): ProjectFile;
+    static fromJSON(data: ProjectFile): Project;
+    setFilePath(path: string): void;
+    getSummary(): {
+        name: string;
+        duration: TimeSeconds;
+        aspectRatio: AspectRatio;
+        frameRate: number;
+        trackCount: number;
+        clipCount: number;
+        sourceCount: number;
+    };
+}

package/dist/engine/project.test.d.ts

@@ -0,0 +1 @@
+export {};