@codingfactory/mediables-vue 2.8.0 → 2.9.1

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

@@ -0,0 +1,172 @@
+import type { VideoRecipe } from '@/types/video';
+type VideoRecipeOutput = VideoRecipe['output'];
+export declare const EXPORT_PRESET_IDS: readonly ["mobile-share", "hd-web", "original", "server-master"];
+export type ExportPresetId = typeof EXPORT_PRESET_IDS[number];
+export type ExportRoutePreference = 'client' | 'server' | 'auto';
+export type ExportResolvedRoute = 'client' | 'server';
+export type ExportPresetAdvancedVisibility = 'standard' | 'advanced' | 'hidden';
+export type ExportDeviceKind = 'mobile' | 'desktop';
+export interface ExportEndpointAvailability {
+    client: boolean;
+    server: boolean;
+}
+export interface ExportPresetRouteContext {
+    durationSeconds: number;
+    endpoints: ExportEndpointAvailability;
+}
+export interface ExportPresetRecommendationContext extends ExportPresetRouteContext {
+    device: ExportDeviceKind;
+    includeAdvanced?: boolean;
+}
+export interface ExportPresetSettings {
+    format: VideoRecipeOutput['format'];
+    codec: VideoRecipeOutput['codec'];
+    quality: VideoRecipeOutput['quality'];
+    fps: VideoRecipeOutput['fps'];
+    bitrate?: NonNullable<VideoRecipeOutput['bitrate']>;
+    routePreference: ExportRoutePreference;
+    maxClientDurationSeconds: number | null;
+    mobileSuitable: boolean;
+    advancedVisibility: ExportPresetAdvancedVisibility;
+}
+export interface ExportPreset {
+    id: ExportPresetId;
+    label: string;
+    description: string;
+    settings: ExportPresetSettings;
+}
+export type ExportPresetReference = ExportPresetId | ExportPreset;
+export declare const EXPORT_PRESETS: readonly [{
+    readonly id: "mobile-share";
+    readonly label: "Mobile share";
+    readonly description: "Fast H.264 MP4 export for short social clips and mobile uploads.";
+    readonly settings: {
+        readonly format: "mp4";
+        readonly codec: "h264";
+        readonly quality: "720p";
+        readonly fps: 30;
+        readonly bitrate: 4500000;
+        readonly routePreference: "client";
+        readonly maxClientDurationSeconds: 90;
+        readonly mobileSuitable: true;
+        readonly advancedVisibility: "standard";
+    };
+}, {
+    readonly id: "hd-web";
+    readonly label: "HD web";
+    readonly description: "Balanced 1080p H.264 MP4 export for web playback.";
+    readonly settings: {
+        readonly format: "mp4";
+        readonly codec: "h264";
+        readonly quality: "1080p";
+        readonly fps: 30;
+        readonly bitrate: 8000000;
+        readonly routePreference: "auto";
+        readonly maxClientDurationSeconds: 180;
+        readonly mobileSuitable: true;
+        readonly advancedVisibility: "standard";
+    };
+}, {
+    readonly id: "original";
+    readonly label: "Original";
+    readonly description: "Server-rendered MP4 export that preserves the editor output quality target.";
+    readonly settings: {
+        readonly format: "mp4";
+        readonly codec: "h264";
+        readonly quality: "1080p";
+        readonly fps: 30;
+        readonly routePreference: "server";
+        readonly maxClientDurationSeconds: null;
+        readonly mobileSuitable: false;
+        readonly advancedVisibility: "standard";
+    };
+}, {
+    readonly id: "server-master";
+    readonly label: "Server master";
+    readonly description: "High-bitrate master render for archival and downstream transcodes.";
+    readonly settings: {
+        readonly format: "mov";
+        readonly codec: "h265";
+        readonly quality: "2160p";
+        readonly fps: 60;
+        readonly bitrate: 32000000;
+        readonly routePreference: "server";
+        readonly maxClientDurationSeconds: null;
+        readonly mobileSuitable: false;
+        readonly advancedVisibility: "advanced";
+    };
+}];
+export declare const EXPORT_PRESETS_BY_ID: {
+    readonly 'mobile-share': {
+        readonly id: "mobile-share";
+        readonly label: "Mobile share";
+        readonly description: "Fast H.264 MP4 export for short social clips and mobile uploads.";
+        readonly settings: {
+            readonly format: "mp4";
+            readonly codec: "h264";
+            readonly quality: "720p";
+            readonly fps: 30;
+            readonly bitrate: 4500000;
+            readonly routePreference: "client";
+            readonly maxClientDurationSeconds: 90;
+            readonly mobileSuitable: true;
+            readonly advancedVisibility: "standard";
+        };
+    };
+    readonly 'hd-web': {
+        readonly id: "hd-web";
+        readonly label: "HD web";
+        readonly description: "Balanced 1080p H.264 MP4 export for web playback.";
+        readonly settings: {
+            readonly format: "mp4";
+            readonly codec: "h264";
+            readonly quality: "1080p";
+            readonly fps: 30;
+            readonly bitrate: 8000000;
+            readonly routePreference: "auto";
+            readonly maxClientDurationSeconds: 180;
+            readonly mobileSuitable: true;
+            readonly advancedVisibility: "standard";
+        };
+    };
+    readonly original: {
+        readonly id: "original";
+        readonly label: "Original";
+        readonly description: "Server-rendered MP4 export that preserves the editor output quality target.";
+        readonly settings: {
+            readonly format: "mp4";
+            readonly codec: "h264";
+            readonly quality: "1080p";
+            readonly fps: 30;
+            readonly routePreference: "server";
+            readonly maxClientDurationSeconds: null;
+            readonly mobileSuitable: false;
+            readonly advancedVisibility: "standard";
+        };
+    };
+    readonly 'server-master': {
+        readonly id: "server-master";
+        readonly label: "Server master";
+        readonly description: "High-bitrate master render for archival and downstream transcodes.";
+        readonly settings: {
+            readonly format: "mov";
+            readonly codec: "h265";
+            readonly quality: "2160p";
+            readonly fps: 60;
+            readonly bitrate: 32000000;
+            readonly routePreference: "server";
+            readonly maxClientDurationSeconds: null;
+            readonly mobileSuitable: false;
+            readonly advancedVisibility: "advanced";
+        };
+    };
+};
+export declare function resolveExportPreset(preset: ExportPresetReference): ExportPreset;
+export declare function exportPresetToVideoOutput(preset: ExportPresetReference): VideoRecipeOutput;
+export declare function isExportPresetMobileSafe(preset: ExportPresetReference): boolean;
+export declare function filterMobileSafeExportPresets(presets?: readonly ExportPreset[]): ExportPreset[];
+export declare function isExportPresetClientDurationSafe(preset: ExportPresetReference, durationSeconds: number): boolean;
+export declare function resolveExportRouteForPreset(preset: ExportPresetReference, context: ExportPresetRouteContext): ExportResolvedRoute | null;
+export declare function isExportPresetAvailable(preset: ExportPresetReference, context: ExportPresetRouteContext): boolean;
+export declare function chooseRecommendedExportPreset(context: ExportPresetRecommendationContext): ExportPreset | null;
+export {};

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

@@ -0,0 +1,22 @@
+export { DEFAULT_MEDIA_SOURCE_ID, DEFAULT_VIDEO_TRACK_ID, flattenProjectToVideoRecipe, migrateVideoRecipeToProject, } from './recipeMigration';
+export type { NormalizedVideoProject, } from './recipeMigration';
+export { beginTimelineTransaction, cancelTimelineTransaction, commitTimelineTransaction, createTimelineActionCoalesceKey, createTimelineActionRecord, createTimelineClipTimingMetadata, createTimelineInverseAction, createTimelineTransactionHistory, redoTimelineTransaction, recordTimelineTransactionAction, undoTimelineTransaction, } from './timelineTransactions';
+export type { BeginTimelineTransactionOptions, CancelTimelineTransactionResult, CommitTimelineTransactionOptions, CommitTimelineTransactionResult, RecordTimelineActionOptions, TimelineActionInverseMetadata, TimelineClipTimingChangeMetadata, TimelineClipTimingMetadata, TimelineDeleteInverseMetadata, TimelineDuplicateInverseMetadata, TimelineGeneratedInverseAction, TimelineHistoryEntry, TimelineMetadataRequiredAction, TimelineMoveInverseMetadata, TimelineSpeedInverseMetadata, TimelineSplitInverseMetadata, TimelineStackMoveResult, TimelineTransaction, TimelineTransactionActionRecord, TimelineTransactionHistory, TimelineTransactionalEditAction, TimelineTransactionOperation, TimelineTrimInverseMetadata, } from './timelineTransactions';
+export { clearTimelineSelection, createTimelineSelectionState, getPrimaryTimelineSelectedClipId, getTimelineClipSelectionStatus, getTimelineSelectedClipIds, getTimelineSelectionAnchorId, isTimelineClipPrimarySelected, isTimelineClipSelected, selectTimelineClip, } from './timelineSelection';
+export type { SelectTimelineClipOptions, TimelineClipSelectionStatus, TimelineSelectionMode, TimelineSelectionState, } from './timelineSelection';
+export { MEDIA_SOURCE_CACHE_SCHEMA_VERSION, createFilmstripCacheDescriptor, createMediaSourceCacheDescriptor, createProjectDraftCacheDescriptor, createWaveformCacheDescriptor, getMediaSourceCacheInputMissingFields, hasCompleteMediaSourceCacheInputs, hasMediaSourceCacheLocator, isMediaSourceCacheDescriptor, } from './mediaSourceCache';
+export type { MediaSourceCacheDescriptor, MediaSourceCacheDescriptorOptions, MediaSourceCacheInputField, MediaSourceCacheInvalidationInputs, MediaSourceCacheKind, MediaSourceCacheLocatorKind, MediaSourceRevisionMetadata, } from './mediaSourceCache';
+export { MEDIA_SOURCE_ANALYSIS_SCHEMA_VERSION, MediaSourceAnalysisValidationError, chooseBestWaveformResolution, createMediaSourceAnalysisCacheKey, normalizeFilmstripFrames, normalizeWaveformSamples, validateFilmstripFrames, validateWaveformSamples, } from './mediaSourceAnalysis';
+export type { BaseMediaSourceAnalysisDescriptor, ChooseWaveformResolutionOptions, CreateMediaSourceAnalysisCacheKeyInput, FilmstripAnalysisDescriptor, FilmstripFrameReference, FilmstripFrameReferenceInput, MediaSourceAnalysisCacheInvalidationInput, MediaSourceAnalysisCacheKey, MediaSourceAnalysisCacheMetadataInput, MediaSourceAnalysisCacheSourceInput, MediaSourceAnalysisCacheVariantInput, MediaSourceAnalysisDescriptor, MediaSourceAnalysisKind, MediaSourceAnalysisValidationCode, MediaSourceAnalysisValidationIssue, WaveformAnalysisDescriptor, WaveformChannel, WaveformPeakRmsSample, WaveformPeakRmsSampleInput, WaveformResolutionDescriptor, } from './mediaSourceAnalysis';
+export { DEFAULT_VIDEO_PROJECT_DRAFT_STORAGE_PREFIX, VIDEO_PROJECT_DRAFT_SNAPSHOT_SCHEMA_VERSION, chooseLatestRestorableVideoProjectDraftSnapshot, createVideoProjectDraftSnapshot, createVideoProjectDraftStorageKey, getRestorableVideoProjectDraftSnapshotRecords, isVideoProjectDraftSnapshotRestorable, loadVideoProjectDraftSnapshotRecords, parseStoredVideoProjectDraftSnapshot, parseStoredVideoProjectDraftSnapshotRecords, removeVideoProjectDraftSnapshotRecords, rotateStoredVideoProjectDraftSnapshots, rotateVideoProjectDraftSnapshots, saveVideoProjectDraftSnapshot, selectRestorableVideoProjectDraftsForSurface, serializeVideoProjectDraftSnapshot, } from './draftRecovery';
+export type { CreateVideoProjectDraftSnapshotOptions, StoredVideoProjectDraftSnapshotEntry, VideoProjectDraftDeviceKind, VideoProjectDraftPayload, VideoProjectDraftPayloadKind, VideoProjectDraftRecoveryOptions, VideoProjectDraftRecoverySurface, VideoProjectDraftSaveReason, VideoProjectDraftSnapshot, VideoProjectDraftSnapshotMetadata, VideoProjectDraftSnapshotRecord, VideoProjectDraftSnapshotRotationOptions, VideoProjectDraftSnapshotRotationResult, VideoProjectDraftSnapshotStorageAdapter, VideoProjectDraftStorageResult, VideoProjectDraftTimestampInput, } from './draftRecovery';
+export { AUDIO_MIXER_FADER_MAX_DB, AUDIO_MIXER_FADER_MIN_DB, AUDIO_MIXER_MASTER_BUS_ID, AUDIO_MIXER_MAX_EFFECT_SLOT_COUNT, AUDIO_MIXER_METER_CEILING_DB, AUDIO_MIXER_METER_FLOOR_DB, AUDIO_MIXER_SCHEMA_VERSION, AUDIO_MIXER_UNITY_DB, DEFAULT_AUDIO_MIXER_EFFECT_SLOT_COUNT, clampFaderDb, clampPanValue, computeEffectiveMuteSoloState, createAudioMixerFader, createAudioMixerMeter, createAudioMixerPan, createDefaultAudioMixerCapabilities, createEmptyAudioMixerEffectSlot, dbToLinearVolume, getAudioMixerCapabilitiesForDevice, linearVolumeToDb, normalizeMixerStateFromLegacyAudioTracks, } from './audioMixerSchema';
+export type { AudioMixerCapabilityFlags, AudioMixerCapabilityMatrix, AudioMixerDeviceClass, AudioMixerEffectKind, AudioMixerEffectParameterValue, AudioMixerEffectParameters, AudioMixerEffectSlot, AudioMixerFader, AudioMixerMasterBus, AudioMixerMeterMode, AudioMixerMeterSnapshot, AudioMixerPan, AudioMixerPanMode, AudioMixerSchemaVersion, AudioMixerState, AudioMixerTimelinePlacement, AudioMixerTrack, AudioMixerTrackControls, AudioMixerTrackKind, AudioMixerTrackSource, EffectiveAudioMixerTrackState, LegacyAudioTrackMixerInput, LegacyMasterAudioMixerInput, NormalizeAudioMixerStateOptions, } from './audioMixerSchema';
+export { EXPORT_PRESET_IDS, EXPORT_PRESETS, EXPORT_PRESETS_BY_ID, chooseRecommendedExportPreset, exportPresetToVideoOutput, filterMobileSafeExportPresets, isExportPresetAvailable, isExportPresetClientDurationSafe, isExportPresetMobileSafe, resolveExportPreset, resolveExportRouteForPreset, } from './exportPresets';
+export type { ExportDeviceKind, ExportEndpointAvailability, ExportPreset, ExportPresetAdvancedVisibility, ExportPresetId, ExportPresetRecommendationContext, ExportPresetReference, ExportPresetRouteContext, ExportPresetSettings, ExportResolvedRoute, ExportRoutePreference, } from './exportPresets';
+export { CaptionSrtError, exportCaptionSrt, formatSrtTimestamp, parseCaptionSrt, validateCaptionSrtCues, } from './captionSrt';
+export type { CaptionSrtCue, CaptionSrtErrorCode, CaptionSrtErrorContext, ParseCaptionSrtOptions, } from './captionSrt';
+export { KEYFRAME_AUTOMATION_TARGETS, KEYFRAME_EASINGS, KEYFRAME_PRESET_IDS, KEYFRAME_TARGET_VALUE_RANGES, KeyframeAutomationError, applyKeyframeEasing, createFadeInKeyframePreset, createFadeOutKeyframePreset, createKeyframePreset, createZoomInKeyframePreset, getKeyframeAutomationCapabilities, interpolateKeyframeValue, isKeyframeAutomationTarget, isKeyframeEasing, normalizeKeyframes, sampleKeyframeValue, sortKeyframes, validateKeyframes, } from './keyframeAutomation';
+export type { CreateKeyframePresetOptions, CreateOpacityKeyframePresetOptions, CreateScaleKeyframePresetOptions, KeyframeAutomationCapabilities, KeyframeAutomationEditingMode, KeyframeAutomationPlatform, KeyframeAutomationPoint, KeyframeAutomationPreset, KeyframeAutomationTarget, KeyframeEasing as KeyframeAutomationEasing, KeyframePresetId, KeyframePresetTimingOptions, KeyframeValidationCode, KeyframeValidationIssue, KeyframeValidationOptions, KeyframeValidationResult, KeyframeValueRange, SampleKeyframeValueOptions, } from './keyframeAutomation';
+export { DEFAULT_LAYER_TRANSFORM, DEFAULT_MOBILE_VISUAL_CAPABILITIES, DEFAULT_RICH_TEXT_STYLE, DEFAULT_VISUAL_FEATURE_CAPABILITIES, VisualLayerSchemaError, normalizeCaptionTrack, normalizeLayerKeyframes, normalizeTransitionWindow, normalizeVisualLayer, validateTransitionWindowsDoNotOverlap, } from './visualLayerSchema';
+export type { AdjustmentLayerInput, AdjustmentLayerRecipe, BaseVisualLayerRecipe, BlendMode, CaptionAnimationPreset, CaptionLayerInput, CaptionLayerRecipe, CaptionSegmentRecipe, CaptionSource, CaptionStylePreset, CaptionTrackInput, CaptionTrackRecipe, CaptionWordRecipe, EasingType, ImageLayerInput, ImageLayerRecipe, KeyframeEasing, KeyframeTargetProperty, LayerPoint, LayerTransform, MobileVisualCapabilityFlags, NormalizedTransitionWindow, RichTextStyle, SchemaValidationErrorCode, ShapeLayerInput, ShapeLayerRecipe, StickerLayerInput, StickerLayerRecipe, SvgLayerInput, SvgLayerRecipe, TextAlign, TextLayerInput, TextLayerRecipe, TextWrapMode, TransitionClipBoundary, TransitionParams, TransitionRecipe, TransitionType, VerticalAlign, VisualFeatureCapabilityMatrix, VisualLayerDefaultKey, VisualLayerInput, VisualLayerKeyframe, VisualLayerRecipe, VisualLayerType, } from './visualLayerSchema';

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

@@ -0,0 +1,91 @@
+export declare const KEYFRAME_AUTOMATION_TARGETS: readonly ["opacity", "scale", "x", "y", "rotation", "audioVolume"];
+export declare const KEYFRAME_EASINGS: readonly ["linear", "ease-in", "ease-out", "ease-in-out"];
+export declare const KEYFRAME_PRESET_IDS: readonly ["fade-in", "fade-out", "zoom-in"];
+export type KeyframeAutomationTarget = typeof KEYFRAME_AUTOMATION_TARGETS[number];
+export type KeyframeEasing = typeof KEYFRAME_EASINGS[number];
+export type KeyframePresetId = typeof KEYFRAME_PRESET_IDS[number];
+export type KeyframeAutomationPlatform = 'mobile' | 'desktop';
+export type KeyframeAutomationEditingMode = 'preset-only' | 'detailed';
+export interface KeyframeAutomationPoint<TTarget extends KeyframeAutomationTarget = KeyframeAutomationTarget> {
+    id: string;
+    target: TTarget;
+    time: number;
+    value: number;
+    easing: KeyframeEasing;
+}
+export interface KeyframeAutomationPreset<TTarget extends KeyframeAutomationTarget = KeyframeAutomationTarget> {
+    id: KeyframePresetId;
+    label: string;
+    target: TTarget;
+    editingMode: 'preset-only';
+    keyframes: readonly [
+        KeyframeAutomationPoint<TTarget>,
+        KeyframeAutomationPoint<TTarget>
+    ];
+}
+export interface KeyframeAutomationCapabilities {
+    platform: KeyframeAutomationPlatform;
+    editingMode: KeyframeAutomationEditingMode;
+    canApplyPresets: true;
+    canEditKeyframes: boolean;
+}
+export interface KeyframeValueRange {
+    min?: number;
+    max?: number;
+}
+export interface KeyframeValidationOptions {
+    target?: KeyframeAutomationTarget;
+    minTime?: number;
+    maxTime?: number;
+    ranges?: Partial<Record<KeyframeAutomationTarget, KeyframeValueRange>>;
+}
+export type KeyframeValidationCode = 'empty-id' | 'invalid-time' | 'invalid-value' | 'invalid-easing' | 'target-mismatch' | 'duplicate-time';
+export interface KeyframeValidationIssue {
+    code: KeyframeValidationCode;
+    message: string;
+    index?: number;
+    keyframeId?: string;
+    target?: KeyframeAutomationTarget;
+    time?: number;
+}
+export interface KeyframeValidationResult {
+    valid: boolean;
+    issues: readonly KeyframeValidationIssue[];
+}
+export interface SampleKeyframeValueOptions {
+    target?: KeyframeAutomationTarget;
+    fallbackValue?: number;
+}
+export interface KeyframePresetTimingOptions {
+    startTime?: number;
+    duration?: number;
+    easing?: KeyframeEasing;
+}
+export interface CreateOpacityKeyframePresetOptions extends KeyframePresetTimingOptions {
+    fromOpacity?: number;
+    toOpacity?: number;
+}
+export interface CreateScaleKeyframePresetOptions extends KeyframePresetTimingOptions {
+    fromScale?: number;
+    toScale?: number;
+}
+export interface CreateKeyframePresetOptions extends KeyframePresetTimingOptions, CreateOpacityKeyframePresetOptions, CreateScaleKeyframePresetOptions {
+}
+export declare class KeyframeAutomationError extends Error {
+    readonly issues: readonly KeyframeValidationIssue[];
+    constructor(issues: readonly KeyframeValidationIssue[], message?: string);
+}
+export declare const KEYFRAME_TARGET_VALUE_RANGES: Readonly<Record<KeyframeAutomationTarget, KeyframeValueRange>>;
+export declare function isKeyframeAutomationTarget(value: unknown): value is KeyframeAutomationTarget;
+export declare function isKeyframeEasing(value: unknown): value is KeyframeEasing;
+export declare function getKeyframeAutomationCapabilities(platform: KeyframeAutomationPlatform): KeyframeAutomationCapabilities;
+export declare function sortKeyframes<TPoint extends KeyframeAutomationPoint>(keyframes: readonly TPoint[]): readonly TPoint[];
+export declare function validateKeyframes(keyframes: readonly KeyframeAutomationPoint[], options?: KeyframeValidationOptions): KeyframeValidationResult;
+export declare function normalizeKeyframes<TPoint extends KeyframeAutomationPoint>(keyframes: readonly TPoint[], options?: KeyframeValidationOptions): readonly TPoint[];
+export declare function applyKeyframeEasing(progress: number, easing?: KeyframeEasing): number;
+export declare function interpolateKeyframeValue(fromValue: number, toValue: number, progress: number, easing?: KeyframeEasing): number;
+export declare function sampleKeyframeValue(keyframes: readonly KeyframeAutomationPoint[], time: number, options?: SampleKeyframeValueOptions): number;
+export declare function createFadeInKeyframePreset(options?: CreateOpacityKeyframePresetOptions): KeyframeAutomationPreset<'opacity'>;
+export declare function createFadeOutKeyframePreset(options?: CreateOpacityKeyframePresetOptions): KeyframeAutomationPreset<'opacity'>;
+export declare function createZoomInKeyframePreset(options?: CreateScaleKeyframePresetOptions): KeyframeAutomationPreset<'scale'>;
+export declare function createKeyframePreset(presetId: KeyframePresetId, options?: CreateKeyframePresetOptions): KeyframeAutomationPreset;

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

@@ -0,0 +1,127 @@
+export declare const MEDIA_SOURCE_ANALYSIS_SCHEMA_VERSION = "media-source-analysis:v1";
+export type MediaSourceAnalysisKind = 'waveform' | 'filmstrip';
+export type WaveformChannel = 'mono' | 'left' | 'right';
+export type MediaSourceAnalysisCacheKey = string;
+export type MediaSourceAnalysisValidationCode = 'invalid-amplitude' | 'invalid-cache-key' | 'invalid-dimension' | 'invalid-duration' | 'invalid-id' | 'invalid-resolution' | 'invalid-rms' | 'invalid-source' | 'invalid-time' | 'invalid-uri' | 'overlapping-sample' | 'duplicate-time' | 'rms-exceeds-peak';
+export interface MediaSourceAnalysisValidationIssue {
+    code: MediaSourceAnalysisValidationCode;
+    path: string;
+    message: string;
+}
+export declare class MediaSourceAnalysisValidationError extends Error {
+    readonly issues: readonly MediaSourceAnalysisValidationIssue[];
+    constructor(message: string, issues: readonly MediaSourceAnalysisValidationIssue[]);
+}
+export interface WaveformPeakRmsSampleInput {
+    time: number;
+    duration: number;
+    peak: number;
+    rms: number;
+    channel?: WaveformChannel;
+}
+export interface WaveformPeakRmsSample {
+    index: number;
+    time: number;
+    duration: number;
+    endTime: number;
+    peak: number;
+    rms: number;
+    channel: WaveformChannel;
+}
+export interface WaveformResolutionDescriptor {
+    id: string;
+    samplesPerSecond: number;
+    sampleCount?: number;
+    duration?: number;
+}
+export interface ChooseWaveformResolutionOptions {
+    pixelsPerSample?: number;
+    minimumSamplesPerSecond?: number;
+}
+export interface FilmstripFrameReferenceInput {
+    time: number;
+    uri: string;
+    width: number;
+    height: number;
+    id?: string;
+    duration?: number;
+    cacheKey?: string;
+}
+export interface FilmstripFrameReference {
+    id: string;
+    time: number;
+    duration: number | null;
+    uri: string;
+    width: number;
+    height: number;
+    aspectRatio: number;
+    cacheKey: string | null;
+}
+export interface BaseMediaSourceAnalysisDescriptor {
+    kind: MediaSourceAnalysisKind;
+    schemaVersion: typeof MEDIA_SOURCE_ANALYSIS_SCHEMA_VERSION;
+    sourceId: string;
+    cacheKey: MediaSourceAnalysisCacheKey;
+    duration: number;
+    generatedAt: string;
+}
+export interface WaveformAnalysisDescriptor extends BaseMediaSourceAnalysisDescriptor {
+    kind: 'waveform';
+    channels: readonly WaveformChannel[];
+    resolutions: readonly WaveformResolutionDescriptor[];
+}
+export interface FilmstripAnalysisDescriptor extends BaseMediaSourceAnalysisDescriptor {
+    kind: 'filmstrip';
+    frameCount: number;
+    frameWidth: number;
+    frameHeight: number;
+    intervalSeconds: number | null;
+}
+export type MediaSourceAnalysisDescriptor = WaveformAnalysisDescriptor | FilmstripAnalysisDescriptor;
+export interface MediaSourceAnalysisCacheSourceInput {
+    id: string;
+    mediaUuid?: string;
+    url?: string;
+    fingerprint?: string;
+    duration?: number | null;
+    width?: number | null;
+    height?: number | null;
+    frameRate?: number | null;
+    revision?: string | number | null;
+    contentHash?: string | null;
+}
+export interface MediaSourceAnalysisCacheInvalidationInput {
+    duration?: number | null;
+    width?: number | null;
+    height?: number | null;
+    frameRate?: number | null;
+    revisionFingerprint?: string | null;
+}
+export interface MediaSourceAnalysisCacheMetadataInput {
+    key?: string;
+    schemaVersion?: string;
+    sourceFingerprint?: string;
+    invalidation?: MediaSourceAnalysisCacheInvalidationInput;
+}
+export interface MediaSourceAnalysisCacheVariantInput {
+    id?: string;
+    resolutionId?: string;
+    samplesPerSecond?: number | null;
+    frameInterval?: number | null;
+    frameWidth?: number | null;
+    frameHeight?: number | null;
+    channels?: readonly WaveformChannel[];
+}
+export interface CreateMediaSourceAnalysisCacheKeyInput {
+    kind: MediaSourceAnalysisKind;
+    source: MediaSourceAnalysisCacheSourceInput;
+    cache?: MediaSourceAnalysisCacheMetadataInput;
+    variant?: MediaSourceAnalysisCacheVariantInput;
+    namespace?: string;
+}
+export declare const validateWaveformSamples: (samples: readonly WaveformPeakRmsSampleInput[]) => readonly MediaSourceAnalysisValidationIssue[];
+export declare const normalizeWaveformSamples: (samples: readonly WaveformPeakRmsSampleInput[]) => readonly WaveformPeakRmsSample[];
+export declare const validateFilmstripFrames: (frames: readonly FilmstripFrameReferenceInput[]) => readonly MediaSourceAnalysisValidationIssue[];
+export declare const normalizeFilmstripFrames: (frames: readonly FilmstripFrameReferenceInput[]) => readonly FilmstripFrameReference[];
+export declare const chooseBestWaveformResolution: <Resolution extends WaveformResolutionDescriptor>(resolutions: readonly Resolution[], zoomPixelsPerSecond: number, options?: ChooseWaveformResolutionOptions) => Resolution | null;
+export declare const createMediaSourceAnalysisCacheKey: (input: CreateMediaSourceAnalysisCacheKeyInput) => MediaSourceAnalysisCacheKey;

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

@@ -0,0 +1,47 @@
+import type { TimelineClipSource } from '@/types/video';
+export declare const MEDIA_SOURCE_CACHE_SCHEMA_VERSION = "media-source-cache:v1";
+export type MediaSourceCacheKind = 'filmstrip' | 'waveform' | 'project-draft';
+export type MediaSourceCacheInputField = 'sourceId' | 'sourceLocator' | 'duration' | 'width' | 'height' | 'frameRate';
+export type MediaSourceCacheLocatorKind = 'mediaUuid' | 'url';
+export interface MediaSourceRevisionMetadata {
+    revision?: string | number;
+    version?: string | number;
+    updatedAt?: string;
+    etag?: string;
+    contentHash?: string;
+    checksum?: string;
+    fingerprint?: string;
+}
+export interface MediaSourceCacheDescriptorOptions {
+    revision?: MediaSourceRevisionMetadata;
+    namespace?: string;
+}
+export interface MediaSourceCacheInvalidationInputs {
+    duration: number | null;
+    width: number | null;
+    height: number | null;
+    frameRate: number | null;
+    revisionFingerprint: string | null;
+}
+export interface MediaSourceCacheDescriptor {
+    kind: MediaSourceCacheKind;
+    key: string;
+    namespace: string;
+    schemaVersion: typeof MEDIA_SOURCE_CACHE_SCHEMA_VERSION;
+    sourceId: string;
+    sourceLocatorKind: MediaSourceCacheLocatorKind;
+    sourceFingerprint: string;
+    invalidation: MediaSourceCacheInvalidationInputs;
+    missingFields: MediaSourceCacheInputField[];
+    isPrivateSource: boolean;
+}
+export declare const getMediaSourceCacheInputMissingFields: (source: Partial<TimelineClipSource>) => MediaSourceCacheInputField[];
+export declare const hasMediaSourceCacheLocator: (source: Partial<TimelineClipSource>) => source is Partial<TimelineClipSource> & {
+    id: string;
+};
+export declare const hasCompleteMediaSourceCacheInputs: (source: Partial<TimelineClipSource>) => source is TimelineClipSource;
+export declare const createMediaSourceCacheDescriptor: (kind: MediaSourceCacheKind, source: Partial<TimelineClipSource>, options?: MediaSourceCacheDescriptorOptions) => MediaSourceCacheDescriptor | null;
+export declare const createFilmstripCacheDescriptor: (source: Partial<TimelineClipSource>, options?: MediaSourceCacheDescriptorOptions) => MediaSourceCacheDescriptor | null;
+export declare const createWaveformCacheDescriptor: (source: Partial<TimelineClipSource>, options?: MediaSourceCacheDescriptorOptions) => MediaSourceCacheDescriptor | null;
+export declare const createProjectDraftCacheDescriptor: (source: Partial<TimelineClipSource>, options?: MediaSourceCacheDescriptorOptions) => MediaSourceCacheDescriptor | null;
+export declare const isMediaSourceCacheDescriptor: (value: unknown) => value is MediaSourceCacheDescriptor;

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

@@ -0,0 +1,26 @@
+import type { AudioSettings, AudioTrackRecipe, AppliedFilter, OutputSettings, TextOverlayRecipe, TimelineClip, TimelineClipSource, TimelineMarker, TimelineSnapSettings, TimelineTrack, TimelineTransitionRecipe, VideoRecipe } from '../../types/video';
+import type { CaptionTrackRecipe, VisualLayerRecipe } from './visualLayerSchema';
+export declare const DEFAULT_VIDEO_TRACK_ID = "default-video-track";
+export declare const DEFAULT_MEDIA_SOURCE_ID = "default-media-source";
+export interface NormalizedVideoProject {
+    version: '1.0';
+    source: VideoRecipe['source'];
+    mediaSources: TimelineClipSource[];
+    tracks: TimelineTrack[];
+    clips: TimelineClip[];
+    markers: TimelineMarker[];
+    transitions: TimelineTransitionRecipe[];
+    filters: AppliedFilter[];
+    audio: AudioSettings;
+    output: OutputSettings;
+    duration?: number;
+    snapSettings?: TimelineSnapSettings;
+    textOverlays?: TextOverlayRecipe[];
+    captionTracks?: CaptionTrackRecipe[];
+    visualLayers?: VisualLayerRecipe[];
+    audioTracks?: AudioTrackRecipe[];
+    posterFrame?: string;
+    metadata?: VideoRecipe['metadata'];
+}
+export declare function migrateVideoRecipeToProject(recipe: VideoRecipe): NormalizedVideoProject;
+export declare function flattenProjectToVideoRecipe(project: NormalizedVideoProject): VideoRecipe;

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

@@ -0,0 +1,23 @@
+export type TimelineSelectionMode = 'replace' | 'toggle' | 'add' | 'range';
+export interface TimelineSelectionState {
+    selectedClipIds: readonly string[];
+    primarySelectedClipId: string | null;
+    anchorClipId: string | null;
+}
+export interface SelectTimelineClipOptions {
+    mode?: TimelineSelectionMode;
+    orderedClipIds?: readonly string[];
+}
+export interface TimelineClipSelectionStatus {
+    selected: boolean;
+    primary: boolean;
+}
+export declare function createTimelineSelectionState(selectedClipIds?: readonly string[], primarySelectedClipId?: string | null, anchorClipId?: string | null): TimelineSelectionState;
+export declare function selectTimelineClip(state: TimelineSelectionState, clipId: string, options?: SelectTimelineClipOptions): TimelineSelectionState;
+export declare function clearTimelineSelection(): TimelineSelectionState;
+export declare function getTimelineSelectedClipIds(state: TimelineSelectionState): readonly string[];
+export declare function getPrimaryTimelineSelectedClipId(state: TimelineSelectionState): string | null;
+export declare function getTimelineSelectionAnchorId(state: TimelineSelectionState): string | null;
+export declare function isTimelineClipSelected(state: TimelineSelectionState, clipId: string): boolean;
+export declare function isTimelineClipPrimarySelected(state: TimelineSelectionState, clipId: string): boolean;
+export declare function getTimelineClipSelectionStatus(state: TimelineSelectionState, clipId: string): TimelineClipSelectionStatus;

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

@@ -0,0 +1,129 @@
+import type { TimelineClip, TimelineEditAction } from '../../types/video';
+export type TimelineTransactionOperation = 'clip.split' | 'clip.delete' | 'clip.duplicate' | 'clip.move' | 'clip.trim' | 'clip.speed';
+export type TimelineTransactionalEditAction = Extract<TimelineEditAction, {
+    type: TimelineTransactionOperation;
+}>;
+export type TimelineGeneratedInverseAction = Extract<TimelineEditAction, {
+    type: 'clip.duplicate' | 'clip.move' | 'clip.trim' | 'clip.speed';
+}>;
+export type TimelineMetadataRequiredAction = Extract<TimelineEditAction, {
+    type: 'clip.split' | 'clip.delete';
+}>;
+export interface TimelineClipTimingMetadata {
+    clipId: string;
+    timelineStart: number;
+    timelineEnd: number;
+    sourceIn: number;
+    sourceOut: number;
+    speed: number;
+}
+export interface TimelineClipTimingChangeMetadata {
+    clipId: string;
+    before: TimelineClipTimingMetadata;
+    after: TimelineClipTimingMetadata;
+}
+export interface TimelineSplitInverseMetadata {
+    type: 'clip.split';
+    sourceClipBefore: TimelineClip;
+    sourceClipAfter: TimelineClip;
+    createdClip: TimelineClip;
+    sourceClipIndex: number;
+    createdClipIndex: number;
+}
+export interface TimelineDeleteInverseMetadata {
+    type: 'clip.delete';
+    deletedClip: TimelineClip;
+    deletedClipIndex: number;
+    ripple: boolean;
+    affectedClips: readonly TimelineClipTimingChangeMetadata[];
+}
+export interface TimelineDuplicateInverseMetadata {
+    type: 'clip.duplicate';
+    duplicatedClipId: string;
+    duplicatedClipIndex?: number;
+    duplicatedClip?: TimelineClip;
+}
+export interface TimelineMoveInverseMetadata {
+    type: 'clip.move';
+    clipId: string;
+    before: Pick<TimelineClipTimingMetadata, 'clipId' | 'timelineStart' | 'timelineEnd'>;
+    after: Pick<TimelineClipTimingMetadata, 'clipId' | 'timelineStart' | 'timelineEnd'>;
+    affectedClips: readonly TimelineClipTimingChangeMetadata[];
+}
+export interface TimelineTrimInverseMetadata {
+    type: 'clip.trim';
+    clipId: string;
+    edge: 'start' | 'end';
+    before: Pick<TimelineClipTimingMetadata, 'clipId' | 'timelineStart' | 'timelineEnd' | 'sourceIn' | 'sourceOut'>;
+    after: Pick<TimelineClipTimingMetadata, 'clipId' | 'timelineStart' | 'timelineEnd' | 'sourceIn' | 'sourceOut'>;
+    affectedClips: readonly TimelineClipTimingChangeMetadata[];
+}
+export interface TimelineSpeedInverseMetadata {
+    type: 'clip.speed';
+    clipId: string;
+    before: Pick<TimelineClipTimingMetadata, 'clipId' | 'timelineStart' | 'timelineEnd' | 'sourceIn' | 'sourceOut' | 'speed'>;
+    after: Pick<TimelineClipTimingMetadata, 'clipId' | 'timelineStart' | 'timelineEnd' | 'sourceIn' | 'sourceOut' | 'speed'>;
+    affectedClips: readonly TimelineClipTimingChangeMetadata[];
+}
+export type TimelineActionInverseMetadata = TimelineSplitInverseMetadata | TimelineDeleteInverseMetadata | TimelineDuplicateInverseMetadata | TimelineMoveInverseMetadata | TimelineTrimInverseMetadata | TimelineSpeedInverseMetadata;
+export interface TimelineTransactionActionRecord {
+    action: TimelineTransactionalEditAction;
+    inverseAction: TimelineTransactionalEditAction | null;
+    inverseMetadata: TimelineActionInverseMetadata;
+    coalesceKey: string;
+}
+export interface TimelineTransaction<Metadata> {
+    id: string;
+    label: string;
+    startedAt: number;
+    baselineMetadata: Metadata;
+    actions: readonly TimelineTransactionActionRecord[];
+}
+export interface TimelineHistoryEntry<Metadata> extends TimelineTransaction<Metadata> {
+    committedAt: number;
+    committedMetadata: Metadata;
+    inverseActions: readonly TimelineTransactionalEditAction[];
+}
+export interface TimelineTransactionHistory<Metadata> {
+    undoStack: readonly TimelineHistoryEntry<Metadata>[];
+    redoStack: readonly TimelineHistoryEntry<Metadata>[];
+    revision: number;
+    activeTransaction?: TimelineTransaction<Metadata>;
+}
+export interface BeginTimelineTransactionOptions<Metadata> {
+    baselineMetadata: Metadata;
+    id?: string;
+    label?: string;
+    startedAt?: number;
+}
+export interface CommitTimelineTransactionOptions<Metadata> {
+    committedMetadata: Metadata;
+    committedAt?: number;
+}
+export interface CommitTimelineTransactionResult<Metadata> {
+    history: TimelineTransactionHistory<Metadata>;
+    entry: TimelineHistoryEntry<Metadata> | null;
+}
+export interface CancelTimelineTransactionResult<Metadata> {
+    history: TimelineTransactionHistory<Metadata>;
+    restoreMetadata: Metadata | null;
+}
+export interface TimelineStackMoveResult<Metadata> {
+    history: TimelineTransactionHistory<Metadata>;
+    entry: TimelineHistoryEntry<Metadata> | null;
+}
+export interface RecordTimelineActionOptions {
+    coalesce?: boolean;
+}
+export declare function createTimelineTransactionHistory<Metadata>(): TimelineTransactionHistory<Metadata>;
+export declare function beginTimelineTransaction<Metadata>(history: TimelineTransactionHistory<Metadata>, options: BeginTimelineTransactionOptions<Metadata>): TimelineTransactionHistory<Metadata>;
+export declare function recordTimelineTransactionAction<Metadata>(history: TimelineTransactionHistory<Metadata>, actionRecord: TimelineTransactionActionRecord, options?: RecordTimelineActionOptions): TimelineTransactionHistory<Metadata>;
+export declare function commitTimelineTransaction<Metadata>(history: TimelineTransactionHistory<Metadata>, options: CommitTimelineTransactionOptions<Metadata>): CommitTimelineTransactionResult<Metadata>;
+export declare function cancelTimelineTransaction<Metadata>(history: TimelineTransactionHistory<Metadata>): CancelTimelineTransactionResult<Metadata>;
+export declare function undoTimelineTransaction<Metadata>(history: TimelineTransactionHistory<Metadata>): TimelineStackMoveResult<Metadata>;
+export declare function redoTimelineTransaction<Metadata>(history: TimelineTransactionHistory<Metadata>): TimelineStackMoveResult<Metadata>;
+export declare function createTimelineActionRecord(action: TimelineGeneratedInverseAction, metadata?: TimelineActionInverseMetadata): TimelineTransactionActionRecord;
+export declare function createTimelineActionRecord(action: TimelineMetadataRequiredAction, metadata: TimelineActionInverseMetadata): TimelineTransactionActionRecord;
+export declare function createTimelineClipTimingMetadata(clip: TimelineClip): TimelineClipTimingMetadata;
+export declare function createTimelineInverseAction(action: TimelineTransactionalEditAction, metadata: TimelineActionInverseMetadata): TimelineTransactionalEditAction | null;
+export declare function createTimelineActionCoalesceKey(action: TimelineTransactionalEditAction): string;