@codingfactory/mediables-vue 2.8.0 → 2.9.0

package/dist/types/api.d.ts

@@ -2,6 +2,15 @@
  * API Types for Video Processing
  */
 import type { VideoRecipe } from './video';
+export type VideoJobPhase = 'preparing' | 'rendering' | 'encoding-video' | 'encoding-audio' | 'muxing' | 'storing' | 'complete';
+export interface VideoJobProgressDetail {
+    raw_stage?: string;
+    raw_status?: string;
+    heartbeat?: number;
+    script_progress?: number;
+    updated_at?: string;
+    [key: string]: unknown;
+}
 export interface VideoProcessingJob {
     id: string;
     user_id: string;
@@ -15,11 +24,16 @@ export interface VideoProcessingJob {
         height?: number;
         fps?: number;
         fileSize?: number;
+        [key: string]: unknown;
     };
     progress: number;
+    phase?: VideoJobPhase;
+    progress_message?: string;
+    progress_detail?: VideoJobProgressDetail;
     error_message?: string;
     started_at?: string;
     completed_at?: string;
+    cancelled_at?: string;
     created_at: string;
     updated_at: string;
 }

package/dist/types/video.d.ts

@@ -2,6 +2,20 @@
  * Video Subsystem Type Definitions
  * Provides comprehensive typing for video editing, playback, and export
  */
+import type { KeyframeAutomationPoint } from '../video/project/keyframeAutomation';
+import type { FilmstripFrameReference, WaveformPeakRmsSample } from '../video/project/mediaSourceAnalysis';
+import type { CaptionTrackRecipe, VisualLayerRecipe } from '../video/project/visualLayerSchema';
+export type { KeyframeAutomationPoint } from '../video/project/keyframeAutomation';
+export type { CaptionTrackRecipe, VisualLayerRecipe } from '../video/project/visualLayerSchema';
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export type JsonObject = {
+    [key: string]: JsonValue;
+};
+export type FilterParamValue = JsonValue;
+export type FilterParamMap = Record<string, FilterParamValue>;
 /**
  * Core video media type extending base media
  */
@@ -38,9 +52,20 @@ export interface VideoMedia {
 /**
  * Timeline clip representation
  */
+export type TimelineClipKind = 'clip' | 'video' | 'audio' | 'image' | 'text' | 'graphics';
 export interface TimelineClip {
     id: string;
-    type: 'clip' | 'video';
+    type: TimelineClipKind;
+    /**
+     * Optional first-class track identifier. Existing flat recipes omit this and
+     * load into a default video track.
+     */
+    trackId?: string;
+    /**
+     * Optional media-source reference for multi-source projects. Existing recipes
+     * keep using recipe.source.
+     */
+    sourceRefId?: string;
     timelineStart: number;
     timelineEnd: number;
     startTime?: number;
@@ -60,6 +85,9 @@ export interface TimelineClip {
     filters?: AppliedFilter[];
     thumbnail?: string;
     label?: string;
+    waveformSamples?: readonly WaveformPeakRmsSample[];
+    filmstripFrames?: readonly FilmstripFrameReference[];
+    keyframes?: readonly KeyframeAutomationPoint[];
     url?: string;
     muted?: boolean;
     scale?: number;
@@ -72,6 +100,125 @@ export interface TimelineClip {
         scale?: number;
     };
 }
+export type TimelineTrackType = 'video' | 'audio' | 'image' | 'text' | 'graphics' | 'caption';
+export interface TimelineTrack {
+    id: string;
+    type: TimelineTrackType;
+    name: string;
+    order: number;
+    locked?: boolean;
+    hidden?: boolean;
+    muted?: boolean;
+    solo?: boolean;
+    height?: number;
+    clipIds?: string[];
+}
+export type TimelineClipSourceType = 'media' | 'url' | 'blob' | 'generated';
+export interface TimelineClipSource {
+    id: string;
+    type: TimelineClipSourceType;
+    mediaUuid?: string;
+    url?: string;
+    filename?: string;
+    mimeType?: string;
+    duration?: number;
+    width?: number;
+    height?: number;
+    frameRate?: number;
+    hasAudio?: boolean;
+    thumbnailUrl?: string;
+    isPrivate?: boolean;
+    metadata?: JsonObject;
+}
+export interface TimelineMarker {
+    id: string;
+    time: number;
+    label?: string;
+    color?: string;
+    kind?: 'chapter' | 'edit' | 'beat' | 'comment';
+}
+export type TimelineSelectionItem = {
+    type: 'clip';
+    id: string;
+} | {
+    type: 'track';
+    id: string;
+} | {
+    type: 'marker';
+    id: string;
+} | {
+    type: 'transition';
+    id: string;
+} | {
+    type: 'keyframe';
+    id: string;
+    property: string;
+};
+export interface TimelineSnapSettings {
+    enabled: boolean;
+    grid?: boolean;
+    frames?: boolean;
+    clips?: boolean;
+    playhead?: boolean;
+    markers?: boolean;
+    beats?: boolean;
+    thresholdPixels?: number;
+}
+export type TimelineTransitionType = 'cut' | 'fade' | 'crossfade' | 'dip-to-black' | 'wipe-left' | 'wipe-right' | 'slide-left' | 'slide-right' | 'zoom';
+export type TimelineTransitionEasing = 'linear' | 'ease-in' | 'ease-out' | 'ease-in-out';
+export interface TimelineTransitionParams {
+    direction?: 'left' | 'right' | 'up' | 'down';
+    color?: string;
+    softness?: number;
+}
+export interface TimelineTransitionRecipe {
+    id: string;
+    type: TimelineTransitionType;
+    fromClipId: string;
+    toClipId: string;
+    duration: number;
+    easing: TimelineTransitionEasing;
+    cutTime?: number;
+    params?: TimelineTransitionParams;
+}
+export type TimelineEditAction = {
+    type: 'clip.split';
+    clipId: string;
+    time: number;
+} | {
+    type: 'clip.delete';
+    clipId: string;
+    ripple: boolean;
+} | {
+    type: 'clip.duplicate';
+    clipId: string;
+    newClipId: string;
+} | {
+    type: 'clip.move';
+    clipId: string;
+    from: number;
+    to: number;
+} | {
+    type: 'clip.trim';
+    clipId: string;
+    edge: 'start' | 'end';
+    from: number;
+    to: number;
+} | {
+    type: 'clip.speed';
+    clipId: string;
+    from: number;
+    to: number;
+} | {
+    type: 'selection.set';
+    items: TimelineSelectionItem[];
+} | {
+    type: 'marker.add';
+    marker: TimelineMarker;
+} | {
+    type: 'marker.remove';
+    markerId: string;
+};
 /**
  * Filter definition for video processing
  */
@@ -81,7 +228,7 @@ export interface VideoFilterDefinition {
     category: 'color' | 'blur' | 'stylize' | 'effects' | 'transform';
     ffmpeg?: string;
     pixiFilter?: string;
-    defaultParams?: Record<string, any>;
+    defaultParams?: FilterParamMap;
     paramRanges?: Record<string, {
         min: number;
         max: number;
@@ -94,7 +241,7 @@ export interface VideoFilterDefinition {
 export interface AppliedFilter {
     id: string;
     filterId: string;
-    params: Record<string, any>;
+    params: FilterParamMap;
     intensity: number;
     ffmpegCommand?: string;
 }
@@ -201,9 +348,16 @@ export interface VideoRecipe {
         original_height: number;
     };
     timeline: TimelineClip[];
+    mediaSources?: TimelineClipSource[];
+    tracks?: TimelineTrack[];
+    markers?: TimelineMarker[];
+    transitions?: TimelineTransitionRecipe[];
+    snapSettings?: TimelineSnapSettings;
     filters: AppliedFilter[];
     audio: AudioSettings;
     textOverlays?: TextOverlayRecipe[];
+    captionTracks?: CaptionTrackRecipe[];
+    visualLayers?: VisualLayerRecipe[];
     audioTracks?: AudioTrackRecipe[];
     output: OutputSettings;
     /** PIXI-rendered poster frame as a data URL (transient — not persisted to backend) */
@@ -224,12 +378,17 @@ export interface VideoEditorState {
     mediaUuid: string;
     media?: VideoMedia;
     clips: TimelineClip[];
+    tracks?: TimelineTrack[];
+    mediaSources?: TimelineClipSource[];
+    transitions?: TimelineTransitionRecipe[];
     playheadPosition: number;
     totalDuration: number;
     originalDuration: number;
     filters: AppliedFilter[];
     activeFilterId?: string;
     textOverlays?: TextOverlayRecipe[];
+    captionTracks?: CaptionTrackRecipe[];
+    visualLayers?: VisualLayerRecipe[];
     audioTracks?: AudioTrackRecipe[];
     audioVolume: number;
     audioFadeIn: number;
@@ -286,7 +445,7 @@ export interface LiveStream {
     auto_record: boolean;
     low_latency: boolean;
     vod_media_uuid?: string;
-    metadata?: Record<string, any>;
+    metadata?: Record<string, unknown>;
 }
 /**
  * Live stream creation options
@@ -296,7 +455,7 @@ export interface LiveStreamOptions {
     low_latency?: boolean;
     auto_record?: boolean;
     reconnect_window?: number;
-    metadata?: Record<string, any>;
+    metadata?: Record<string, unknown>;
 }
 /**
  * Live stream statistics

package/dist/video/project/audioMixerSchema.d.ts

@@ -0,0 +1,152 @@
+import type { AudioSettings, AudioTrackRecipe } from '../../types/video';
+export declare const AUDIO_MIXER_SCHEMA_VERSION: 1;
+export declare const AUDIO_MIXER_MASTER_BUS_ID = "master";
+export declare const AUDIO_MIXER_FADER_MIN_DB = -60;
+export declare const AUDIO_MIXER_FADER_MAX_DB = 12;
+export declare const AUDIO_MIXER_UNITY_DB = 0;
+export declare const AUDIO_MIXER_METER_FLOOR_DB = -90;
+export declare const AUDIO_MIXER_METER_CEILING_DB = 6;
+export declare const DEFAULT_AUDIO_MIXER_EFFECT_SLOT_COUNT = 4;
+export declare const AUDIO_MIXER_MAX_EFFECT_SLOT_COUNT = 8;
+export type AudioMixerSchemaVersion = typeof AUDIO_MIXER_SCHEMA_VERSION;
+export type AudioMixerDeviceClass = 'mobile' | 'desktop';
+export type AudioMixerTrackKind = 'legacy-url' | 'media' | 'music' | 'voiceover' | 'ambience' | 'generated';
+export type AudioMixerPanMode = 'constant-power' | 'linear';
+export type AudioMixerMeterMode = 'off' | 'basic' | 'full';
+export type AudioMixerEffectKind = 'empty' | 'gain' | 'eq' | 'compressor' | 'limiter' | 'noise-gate' | 'reverb' | 'delay' | 'custom';
+export type AudioMixerEffectParameterValue = string | number | boolean;
+export type AudioMixerEffectParameters = Record<string, AudioMixerEffectParameterValue>;
+export interface AudioMixerCapabilityFlags {
+    canAdjustTrackFaders: boolean;
+    canAdjustMasterFader: boolean;
+    canMuteTracks: boolean;
+    canSoloTracks: boolean;
+    canAdjustPan: boolean;
+    canViewMeters: boolean;
+    canEditEffectSlots: boolean;
+    canEditRouting: boolean;
+    canEditAutomation: boolean;
+    meterMode: AudioMixerMeterMode;
+    maxEffectSlots: number;
+}
+export interface AudioMixerCapabilityMatrix {
+    mobile: AudioMixerCapabilityFlags;
+    desktop: AudioMixerCapabilityFlags;
+}
+export interface AudioMixerFader {
+    valueDb: number;
+    minDb: number;
+    maxDb: number;
+    unityDb: number;
+    linearGain: number;
+}
+export interface AudioMixerPan {
+    value: number;
+    mode: AudioMixerPanMode;
+}
+export interface AudioMixerMeterSnapshot {
+    peakDb: number;
+    rmsDb: number;
+    peakHoldDb: number;
+    clipping: boolean;
+}
+export interface AudioMixerEffectSlot {
+    id: string;
+    index: number;
+    kind: AudioMixerEffectKind;
+    label: string;
+    enabled: boolean;
+    bypassed: boolean;
+    wetMix: number;
+    parameters: AudioMixerEffectParameters;
+}
+export interface AudioMixerTrackControls {
+    fader: AudioMixerFader;
+    pan: AudioMixerPan;
+    muted: boolean;
+    solo: boolean;
+    meter: AudioMixerMeterSnapshot;
+}
+export type AudioMixerTrackSource = {
+    type: 'url';
+    url: string;
+} | {
+    type: 'missing';
+};
+export interface AudioMixerTimelinePlacement {
+    startTime: number;
+    loop: boolean;
+    duration?: number;
+    fadeIn?: number;
+    fadeOut?: number;
+}
+export interface AudioMixerTrack {
+    id: string;
+    kind: AudioMixerTrackKind;
+    name: string;
+    order: number;
+    source: AudioMixerTrackSource;
+    controls: AudioMixerTrackControls;
+    timeline: AudioMixerTimelinePlacement;
+    effectSlots: AudioMixerEffectSlot[];
+    legacyTrackId?: string;
+}
+export interface AudioMixerMasterBus {
+    id: typeof AUDIO_MIXER_MASTER_BUS_ID;
+    name: string;
+    fader: AudioMixerFader;
+    muted: boolean;
+    meter: AudioMixerMeterSnapshot;
+    effectSlots: AudioMixerEffectSlot[];
+}
+export interface AudioMixerState {
+    schemaVersion: AudioMixerSchemaVersion;
+    capabilities: AudioMixerCapabilityMatrix;
+    tracks: AudioMixerTrack[];
+    master: AudioMixerMasterBus;
+}
+export interface EffectiveAudioMixerTrackState {
+    trackId: string;
+    soloed: boolean;
+    mutedByTrack: boolean;
+    mutedBySolo: boolean;
+    mutedByMaster: boolean;
+    effectivelyMuted: boolean;
+    audible: boolean;
+    effectiveGainLinear: number;
+}
+export interface LegacyAudioTrackMixerInput extends AudioTrackRecipe {
+    muted?: boolean;
+    solo?: boolean;
+    pan?: number;
+    faderDb?: number;
+    peakDb?: number;
+    rmsDb?: number;
+    peakHoldDb?: number;
+    effectSlots?: AudioMixerEffectSlot[];
+}
+export interface LegacyMasterAudioMixerInput extends Partial<AudioSettings> {
+    name?: string;
+    faderDb?: number;
+    peakDb?: number;
+    rmsDb?: number;
+    peakHoldDb?: number;
+    effectSlots?: AudioMixerEffectSlot[];
+}
+export interface NormalizeAudioMixerStateOptions {
+    master?: LegacyMasterAudioMixerInput;
+    capabilities?: AudioMixerCapabilityMatrix;
+    effectSlotCount?: number;
+}
+export declare function createDefaultAudioMixerCapabilities(): AudioMixerCapabilityMatrix;
+export declare function getAudioMixerCapabilitiesForDevice(deviceClass: AudioMixerDeviceClass, capabilities?: AudioMixerCapabilityMatrix): AudioMixerCapabilityFlags;
+export declare function linearVolumeToDb(linearVolume: number): number;
+export declare function dbToLinearVolume(faderDb: number): number;
+export declare function clampFaderDb(faderDb: number): number;
+export declare function clampPanValue(pan: number): number;
+export declare function computeEffectiveMuteSoloState(tracks: readonly AudioMixerTrack[], masterMuted?: boolean): EffectiveAudioMixerTrackState[];
+export declare function normalizeMixerStateFromLegacyAudioTracks(legacyTracks: readonly LegacyAudioTrackMixerInput[], options?: NormalizeAudioMixerStateOptions): AudioMixerState;
+export declare function createAudioMixerFader(valueDb: number): AudioMixerFader;
+export declare function createAudioMixerPan(value: number, mode?: AudioMixerPanMode): AudioMixerPan;
+export declare function createAudioMixerMeter(peakDb?: number, rmsDb?: number, peakHoldDb?: number): AudioMixerMeterSnapshot;
+export declare function createEmptyAudioMixerEffectSlot(index: number): AudioMixerEffectSlot;

package/dist/video/project/captionSrt.d.ts

@@ -0,0 +1,23 @@
+import type { CaptionSegmentRecipe } from './visualLayerSchema';
+export type CaptionSrtErrorCode = 'invalid-cue-number' | 'missing-timing' | 'invalid-timing' | 'invalid-time' | 'invalid-duration' | 'overlapping-cues';
+export interface CaptionSrtErrorContext {
+    cueIndex?: number;
+    cueNumber?: number;
+    lineNumber?: number;
+    segmentId?: string;
+}
+export declare class CaptionSrtError extends Error {
+    readonly code: CaptionSrtErrorCode;
+    readonly context: CaptionSrtErrorContext;
+    constructor(code: CaptionSrtErrorCode, message: string, context?: CaptionSrtErrorContext);
+}
+export interface CaptionSrtCue extends CaptionSegmentRecipe {
+    cueNumber: number;
+}
+export interface ParseCaptionSrtOptions {
+    idPrefix?: string;
+}
+export declare function parseCaptionSrt(source: string, options?: ParseCaptionSrtOptions): CaptionSrtCue[];
+export declare function exportCaptionSrt(cues: readonly CaptionSegmentRecipe[]): string;
+export declare function validateCaptionSrtCues(cues: readonly CaptionSegmentRecipe[]): void;
+export declare function formatSrtTimestamp(seconds: number): string;

package/dist/video/project/draftRecovery.d.ts

@@ -0,0 +1,86 @@
+import type { VideoRecipe } from '../../types/video';
+import type { NormalizedVideoProject } from './recipeMigration';
+export declare const VIDEO_PROJECT_DRAFT_SNAPSHOT_SCHEMA_VERSION = "video-project-draft-snapshot:v1";
+export declare const DEFAULT_VIDEO_PROJECT_DRAFT_STORAGE_PREFIX = "mediables:video-project-drafts";
+export type VideoProjectDraftPayloadKind = 'recipe' | 'project';
+export type VideoProjectDraftPayload = VideoRecipe | NormalizedVideoProject;
+export type VideoProjectDraftDeviceKind = 'desktop' | 'mobile' | 'tablet' | 'unknown';
+export type VideoProjectDraftSaveReason = 'autosave' | 'manual' | 'before-export' | 'before-close';
+export type VideoProjectDraftRecoverySurface = 'desktop' | 'mobile';
+export type VideoProjectDraftTimestampInput = string | number | Date;
+export type VideoProjectDraftStorageResult<T> = T | Promise<T>;
+export interface VideoProjectDraftSnapshotMetadata {
+    id: string;
+    payloadKind: VideoProjectDraftPayloadKind;
+    createdAt: string;
+    updatedAt: string;
+    deviceKind: VideoProjectDraftDeviceKind;
+    projectId?: string;
+    sourceMediaUuid?: string;
+    durationSeconds?: number;
+    editorVersion?: string;
+    title?: string;
+    saveReason?: VideoProjectDraftSaveReason;
+}
+export interface VideoProjectDraftSnapshot<Payload extends VideoProjectDraftPayload = VideoProjectDraftPayload> {
+    schemaVersion: typeof VIDEO_PROJECT_DRAFT_SNAPSHOT_SCHEMA_VERSION;
+    metadata: VideoProjectDraftSnapshotMetadata;
+    payload: Payload;
+}
+export interface CreateVideoProjectDraftSnapshotOptions {
+    id?: string;
+    projectId?: string;
+    now?: VideoProjectDraftTimestampInput;
+    createdAt?: VideoProjectDraftTimestampInput;
+    updatedAt?: VideoProjectDraftTimestampInput;
+    deviceKind?: VideoProjectDraftDeviceKind;
+    sourceMediaUuid?: string;
+    durationSeconds?: number;
+    editorVersion?: string;
+    title?: string;
+    saveReason?: VideoProjectDraftSaveReason;
+}
+export interface StoredVideoProjectDraftSnapshotEntry {
+    key: string;
+    value: string | null;
+}
+export interface VideoProjectDraftSnapshotRecord<Payload extends VideoProjectDraftPayload = VideoProjectDraftPayload> {
+    key: string;
+    snapshot: VideoProjectDraftSnapshot<Payload>;
+}
+export interface VideoProjectDraftSnapshotStorageAdapter {
+    getItem: (key: string) => VideoProjectDraftStorageResult<string | null>;
+    setItem: (key: string, value: string) => VideoProjectDraftStorageResult<void>;
+    removeItem: (key: string) => VideoProjectDraftStorageResult<void>;
+    listKeys: (prefix: string) => VideoProjectDraftStorageResult<readonly string[]>;
+}
+export interface VideoProjectDraftSnapshotRotationOptions {
+    maxCount: number;
+    maxAgeMs?: number;
+    now?: VideoProjectDraftTimestampInput;
+    projectId?: string;
+}
+export interface VideoProjectDraftSnapshotRotationResult {
+    retained: readonly VideoProjectDraftSnapshotRecord[];
+    removed: readonly VideoProjectDraftSnapshotRecord[];
+}
+export interface VideoProjectDraftRecoveryOptions {
+    projectId?: string;
+    savedAt?: VideoProjectDraftTimestampInput | null;
+    maxAgeMs?: number;
+    now?: VideoProjectDraftTimestampInput;
+}
+export declare const createVideoProjectDraftSnapshot: <Payload extends VideoProjectDraftPayload>(payload: Payload, options?: CreateVideoProjectDraftSnapshotOptions) => VideoProjectDraftSnapshot<Payload>;
+export declare const createVideoProjectDraftStorageKey: (snapshot: VideoProjectDraftSnapshot, prefix?: string) => string;
+export declare const serializeVideoProjectDraftSnapshot: (snapshot: VideoProjectDraftSnapshot) => string;
+export declare const parseStoredVideoProjectDraftSnapshot: (value: string | null | undefined) => VideoProjectDraftSnapshot | null;
+export declare const parseStoredVideoProjectDraftSnapshotRecords: (entries: readonly StoredVideoProjectDraftSnapshotEntry[]) => VideoProjectDraftSnapshotRecord[];
+export declare const rotateVideoProjectDraftSnapshots: (records: readonly VideoProjectDraftSnapshotRecord[], options: VideoProjectDraftSnapshotRotationOptions) => VideoProjectDraftSnapshotRotationResult;
+export declare const rotateStoredVideoProjectDraftSnapshots: (entries: readonly StoredVideoProjectDraftSnapshotEntry[], options: VideoProjectDraftSnapshotRotationOptions) => VideoProjectDraftSnapshotRotationResult;
+export declare const isVideoProjectDraftSnapshotRestorable: (snapshot: VideoProjectDraftSnapshot, options?: VideoProjectDraftRecoveryOptions) => boolean;
+export declare const getRestorableVideoProjectDraftSnapshotRecords: (records: readonly VideoProjectDraftSnapshotRecord[], options?: VideoProjectDraftRecoveryOptions) => VideoProjectDraftSnapshotRecord[];
+export declare const chooseLatestRestorableVideoProjectDraftSnapshot: (records: readonly VideoProjectDraftSnapshotRecord[], options?: VideoProjectDraftRecoveryOptions) => VideoProjectDraftSnapshotRecord | null;
+export declare const selectRestorableVideoProjectDraftsForSurface: (records: readonly VideoProjectDraftSnapshotRecord[], surface: VideoProjectDraftRecoverySurface, options?: VideoProjectDraftRecoveryOptions) => VideoProjectDraftSnapshotRecord[];
+export declare const saveVideoProjectDraftSnapshot: (adapter: VideoProjectDraftSnapshotStorageAdapter, snapshot: VideoProjectDraftSnapshot, key?: string) => Promise<VideoProjectDraftSnapshotRecord>;
+export declare const loadVideoProjectDraftSnapshotRecords: (adapter: VideoProjectDraftSnapshotStorageAdapter, prefix?: string) => Promise<VideoProjectDraftSnapshotRecord[]>;
+export declare const removeVideoProjectDraftSnapshotRecords: (adapter: VideoProjectDraftSnapshotStorageAdapter, records: readonly VideoProjectDraftSnapshotRecord[]) => Promise<void>;