@webpacked-timeline/core 1.0.0-beta.1

package/dist/chunk-FBOYSUYV.js

@@ -0,0 +1,1280 @@
+// src/types/clip.ts
+function createClip(params) {
+  const clip = {
+    id: params.id,
+    assetId: params.assetId,
+    trackId: params.trackId,
+    timelineStart: params.timelineStart,
+    timelineEnd: params.timelineEnd,
+    mediaIn: params.mediaIn,
+    mediaOut: params.mediaOut
+  };
+  if (params.label !== void 0) {
+    clip.label = params.label;
+  }
+  if (params.metadata !== void 0) {
+    clip.metadata = params.metadata;
+  }
+  return clip;
+}
+function getClipDuration(clip) {
+  return clip.timelineEnd - clip.timelineStart;
+}
+function getClipMediaDuration(clip) {
+  return clip.mediaOut - clip.mediaIn;
+}
+function clipContainsFrame(clip, frame2) {
+  return frame2 >= clip.timelineStart && frame2 < clip.timelineEnd;
+}
+function clipsOverlap(clip1, clip2) {
+  return clip1.timelineStart < clip2.timelineEnd && clip2.timelineStart < clip1.timelineEnd;
+}
+
+// src/types/validation.ts
+function validResult() {
+  return {
+    valid: true,
+    errors: []
+  };
+}
+function invalidResult(code, message, context) {
+  const error = { code, message };
+  if (context !== void 0) {
+    error.context = context;
+  }
+  return {
+    valid: false,
+    errors: [error]
+  };
+}
+function invalidResults(errors) {
+  return {
+    valid: false,
+    errors
+  };
+}
+function combineResults(...results) {
+  const allErrors = [];
+  for (const result of results) {
+    if (!result.valid) {
+      allErrors.push(...result.errors);
+    }
+  }
+  if (allErrors.length > 0) {
+    return invalidResults(allErrors);
+  }
+  return validResult();
+}
+
+// src/systems/asset-registry.ts
+function registerAsset(state, asset) {
+  const newAssets = new Map(state.assets);
+  newAssets.set(asset.id, asset);
+  return {
+    ...state,
+    assets: newAssets
+  };
+}
+function getAsset(state, assetId) {
+  return state.assets.get(assetId);
+}
+function hasAsset(state, assetId) {
+  return state.assets.has(assetId);
+}
+function getAllAssets(state) {
+  return Array.from(state.assets.values());
+}
+function unregisterAsset(state, assetId) {
+  const newAssets = new Map(state.assets);
+  newAssets.delete(assetId);
+  return {
+    ...state,
+    assets: newAssets
+  };
+}
+
+// src/systems/validation.ts
+function validateClip(state, clip) {
+  const errors = [];
+  const asset = getAsset(state, clip.assetId);
+  if (!asset) {
+    errors.push(invalidResult(
+      "ASSET_NOT_FOUND",
+      `Asset '${clip.assetId}' not found in registry`,
+      { clipId: clip.id, assetId: clip.assetId }
+    ));
+    return combineResults(...errors);
+  }
+  if (clip.timelineEnd <= clip.timelineStart) {
+    errors.push(invalidResult(
+      "INVALID_TIMELINE_BOUNDS",
+      `Clip timeline end (${clip.timelineEnd}) must be greater than start (${clip.timelineStart})`,
+      { clipId: clip.id, timelineStart: clip.timelineStart, timelineEnd: clip.timelineEnd }
+    ));
+  }
+  if (clip.mediaIn < 0) {
+    errors.push(invalidResult(
+      "INVALID_MEDIA_IN",
+      `Clip media in (${clip.mediaIn}) must be >= 0`,
+      { clipId: clip.id, mediaIn: clip.mediaIn }
+    ));
+  }
+  if (clip.mediaOut <= clip.mediaIn) {
+    errors.push(invalidResult(
+      "INVALID_MEDIA_BOUNDS",
+      `Clip media out (${clip.mediaOut}) must be greater than media in (${clip.mediaIn})`,
+      { clipId: clip.id, mediaIn: clip.mediaIn, mediaOut: clip.mediaOut }
+    ));
+  }
+  if (clip.mediaOut > asset.duration) {
+    errors.push(invalidResult(
+      "MEDIA_EXCEEDS_ASSET",
+      `Clip media out (${clip.mediaOut}) exceeds asset duration (${asset.duration})`,
+      { clipId: clip.id, mediaOut: clip.mediaOut, assetDuration: asset.duration }
+    ));
+  }
+  const timelineDuration = getClipDuration(clip);
+  const mediaDuration = getClipMediaDuration(clip);
+  if (timelineDuration !== mediaDuration) {
+    errors.push(invalidResult(
+      "DURATION_MISMATCH",
+      `Clip timeline duration (${timelineDuration}) must match media duration (${mediaDuration}) in Phase 1`,
+      { clipId: clip.id, timelineDuration, mediaDuration }
+    ));
+  }
+  return combineResults(...errors);
+}
+function validateTrack(state, track) {
+  const errors = [];
+  for (const clip of track.clips) {
+    const clipResult = validateClip(state, clip);
+    if (!clipResult.valid) {
+      errors.push(clipResult);
+    }
+  }
+  for (let i = 0; i < track.clips.length; i++) {
+    for (let j = i + 1; j < track.clips.length; j++) {
+      const clip1 = track.clips[i];
+      const clip2 = track.clips[j];
+      if (!clip1 || !clip2) {
+        continue;
+      }
+      if (clipsOverlap(clip1, clip2)) {
+        errors.push(invalidResult(
+          "CLIPS_OVERLAP",
+          `Clips '${clip1.id}' and '${clip2.id}' overlap on track '${track.id}'`,
+          {
+            trackId: track.id,
+            clip1Id: clip1.id,
+            clip2Id: clip2.id,
+            clip1Start: clip1.timelineStart,
+            clip1End: clip1.timelineEnd,
+            clip2Start: clip2.timelineStart,
+            clip2End: clip2.timelineEnd
+          }
+        ));
+      }
+    }
+  }
+  return combineResults(...errors);
+}
+function validateTimeline(state) {
+  const errors = [];
+  if (state.timeline.fps <= 0) {
+    errors.push(invalidResult(
+      "INVALID_FPS",
+      `Timeline FPS must be positive, got ${state.timeline.fps}`,
+      { fps: state.timeline.fps }
+    ));
+  }
+  if (state.timeline.duration <= 0) {
+    errors.push(invalidResult(
+      "INVALID_DURATION",
+      `Timeline duration must be positive, got ${state.timeline.duration}`,
+      { duration: state.timeline.duration }
+    ));
+  }
+  for (const track of state.timeline.tracks) {
+    const trackResult = validateTrack(state, track);
+    if (!trackResult.valid) {
+      errors.push(trackResult);
+    }
+  }
+  return combineResults(...errors);
+}
+function validateNoOverlap(track, clip) {
+  for (const existingClip of track.clips) {
+    if (existingClip.id === clip.id) {
+      continue;
+    }
+    if (clipsOverlap(existingClip, clip)) {
+      return invalidResult(
+        "CLIPS_OVERLAP",
+        `Clip '${clip.id}' would overlap with existing clip '${existingClip.id}' on track '${track.id}'`,
+        {
+          trackId: track.id,
+          newClipId: clip.id,
+          existingClipId: existingClip.id,
+          newClipStart: clip.timelineStart,
+          newClipEnd: clip.timelineEnd,
+          existingClipStart: existingClip.timelineStart,
+          existingClipEnd: existingClip.timelineEnd
+        }
+      );
+    }
+  }
+  return validResult();
+}
+function validateTrackTypeMatch(state, clip, targetTrack) {
+  const asset = getAsset(state, clip.assetId);
+  if (!asset) {
+    return invalidResult(
+      "ASSET_NOT_FOUND",
+      `Asset '${clip.assetId}' not found in registry`,
+      { clipId: clip.id, assetId: clip.assetId }
+    );
+  }
+  if (asset.type === "video" && targetTrack.type !== "video") {
+    return invalidResult(
+      "TRACK_TYPE_MISMATCH",
+      `Cannot place video clip '${clip.id}' on ${targetTrack.type} track '${targetTrack.id}'`,
+      {
+        clipId: clip.id,
+        assetType: asset.type,
+        trackType: targetTrack.type,
+        trackId: targetTrack.id
+      }
+    );
+  }
+  if (asset.type === "audio" && targetTrack.type !== "audio") {
+    return invalidResult(
+      "TRACK_TYPE_MISMATCH",
+      `Cannot place audio clip '${clip.id}' on ${targetTrack.type} track '${targetTrack.id}'`,
+      {
+        clipId: clip.id,
+        assetType: asset.type,
+        trackType: targetTrack.type,
+        trackId: targetTrack.id
+      }
+    );
+  }
+  if (asset.type === "image" && targetTrack.type !== "video") {
+    return invalidResult(
+      "TRACK_TYPE_MISMATCH",
+      `Cannot place image clip '${clip.id}' on ${targetTrack.type} track '${targetTrack.id}'`,
+      {
+        clipId: clip.id,
+        assetType: asset.type,
+        trackType: targetTrack.type,
+        trackId: targetTrack.id
+      }
+    );
+  }
+  return validResult();
+}
+
+// src/systems/queries.ts
+function findClipById(state, clipId) {
+  for (const track of state.timeline.tracks) {
+    const clip = track.clips.find((c) => c.id === clipId);
+    if (clip) {
+      return clip;
+    }
+  }
+  return void 0;
+}
+function findTrackById(state, trackId) {
+  return state.timeline.tracks.find((t) => t.id === trackId);
+}
+function getClipsOnTrack(state, trackId) {
+  const track = findTrackById(state, trackId);
+  return track ? track.clips : [];
+}
+function getClipsAtFrame(state, frame2) {
+  const clips = [];
+  for (const track of state.timeline.tracks) {
+    for (const clip of track.clips) {
+      if (clipContainsFrame(clip, frame2)) {
+        clips.push(clip);
+      }
+    }
+  }
+  return clips;
+}
+function getClipsInRange(state, start, end) {
+  const clips = [];
+  for (const track of state.timeline.tracks) {
+    for (const clip of track.clips) {
+      if (clip.timelineStart < end && clip.timelineEnd > start) {
+        clips.push(clip);
+      }
+    }
+  }
+  return clips;
+}
+function getAllClips(state) {
+  const clips = [];
+  for (const track of state.timeline.tracks) {
+    clips.push(...track.clips);
+  }
+  return clips;
+}
+function getAllTracks(state) {
+  return state.timeline.tracks;
+}
+function findTrackIndex(state, trackId) {
+  return state.timeline.tracks.findIndex((t) => t.id === trackId);
+}
+
+// src/types/track.ts
+function createTrack(params) {
+  const track = {
+    id: params.id,
+    name: params.name,
+    type: params.type,
+    clips: params.clips ?? [],
+    locked: params.locked ?? false,
+    muted: params.muted ?? false
+  };
+  if (params.metadata !== void 0) {
+    track.metadata = params.metadata;
+  }
+  return track;
+}
+function sortTrackClips(track) {
+  return {
+    ...track,
+    clips: [...track.clips].sort((a, b) => a.timelineStart - b.timelineStart)
+  };
+}
+
+// src/operations/clip-operations.ts
+function addClip(state, trackId, clip) {
+  const trackIndex = state.timeline.tracks.findIndex((t) => t.id === trackId);
+  if (trackIndex === -1) {
+    return state;
+  }
+  const track = state.timeline.tracks[trackIndex];
+  if (!track) {
+    return state;
+  }
+  const newTrack = sortTrackClips({
+    ...track,
+    clips: [...track.clips, clip]
+  });
+  const newTracks = [...state.timeline.tracks];
+  newTracks[trackIndex] = newTrack;
+  return {
+    ...state,
+    timeline: {
+      ...state.timeline,
+      tracks: newTracks
+    }
+  };
+}
+function removeClip(state, clipId) {
+  const newTracks = state.timeline.tracks.map((track) => ({
+    ...track,
+    clips: track.clips.filter((c) => c.id !== clipId)
+  }));
+  return {
+    ...state,
+    timeline: {
+      ...state.timeline,
+      tracks: newTracks
+    }
+  };
+}
+function moveClip(state, clipId, newStart) {
+  const clip = findClipById(state, clipId);
+  if (!clip) {
+    return state;
+  }
+  const duration = clip.timelineEnd - clip.timelineStart;
+  const newEnd = newStart + duration;
+  return updateClip(state, clipId, {
+    timelineStart: newStart,
+    timelineEnd: newEnd
+  });
+}
+function resizeClip(state, clipId, newStart, newEnd) {
+  const clip = findClipById(state, clipId);
+  if (!clip) {
+    return state;
+  }
+  const startDelta = newStart - clip.timelineStart;
+  const endDelta = newEnd - clip.timelineEnd;
+  let newMediaIn = clip.mediaIn;
+  let newMediaOut = clip.mediaOut;
+  if (startDelta !== 0) {
+    newMediaIn = clip.mediaIn + startDelta;
+  }
+  if (endDelta !== 0) {
+    newMediaOut = clip.mediaOut + endDelta;
+  }
+  return updateClip(state, clipId, {
+    timelineStart: newStart,
+    timelineEnd: newEnd,
+    mediaIn: newMediaIn,
+    mediaOut: newMediaOut
+  });
+}
+function trimClip(state, clipId, newMediaIn, newMediaOut) {
+  return updateClip(state, clipId, {
+    mediaIn: newMediaIn,
+    mediaOut: newMediaOut
+  });
+}
+function updateClip(state, clipId, updates) {
+  const newTracks = state.timeline.tracks.map((track) => {
+    const clipIndex = track.clips.findIndex((c) => c.id === clipId);
+    if (clipIndex === -1) {
+      return track;
+    }
+    const newClips = [...track.clips];
+    const existingClip = newClips[clipIndex];
+    if (!existingClip) {
+      return track;
+    }
+    newClips[clipIndex] = {
+      ...existingClip,
+      ...updates
+    };
+    return sortTrackClips({
+      ...track,
+      clips: newClips
+    });
+  });
+  return {
+    ...state,
+    timeline: {
+      ...state.timeline,
+      tracks: newTracks
+    }
+  };
+}
+function moveClipToTrack(state, clipId, targetTrackId) {
+  const clip = findClipById(state, clipId);
+  if (!clip) {
+    return state;
+  }
+  const targetTrack = findTrackById(state, targetTrackId);
+  if (!targetTrack) {
+    return state;
+  }
+  const validationResult = validateTrackTypeMatch(state, clip, targetTrack);
+  if (!validationResult.valid) {
+    return state;
+  }
+  if (clip.trackId === targetTrackId) {
+    return state;
+  }
+  let newState = removeClip(state, clipId);
+  const updatedClip = { ...clip, trackId: targetTrackId };
+  newState = addClip(newState, targetTrackId, updatedClip);
+  return newState;
+}
+
+// src/operations/track-operations.ts
+function addTrack(state, track) {
+  return {
+    ...state,
+    timeline: {
+      ...state.timeline,
+      tracks: [...state.timeline.tracks, track]
+    }
+  };
+}
+function removeTrack(state, trackId) {
+  return {
+    ...state,
+    timeline: {
+      ...state.timeline,
+      tracks: state.timeline.tracks.filter((t) => t.id !== trackId)
+    }
+  };
+}
+function moveTrack(state, trackId, newIndex) {
+  const currentIndex = findTrackIndex(state, trackId);
+  if (currentIndex === -1) {
+    return state;
+  }
+  const newTracks = [...state.timeline.tracks];
+  const [track] = newTracks.splice(currentIndex, 1);
+  if (!track) {
+    return state;
+  }
+  newTracks.splice(newIndex, 0, track);
+  return {
+    ...state,
+    timeline: {
+      ...state.timeline,
+      tracks: newTracks
+    }
+  };
+}
+function updateTrack(state, trackId, updates) {
+  const trackIndex = findTrackIndex(state, trackId);
+  if (trackIndex === -1) {
+    return state;
+  }
+  const newTracks = [...state.timeline.tracks];
+  const existingTrack = newTracks[trackIndex];
+  if (!existingTrack) {
+    return state;
+  }
+  newTracks[trackIndex] = {
+    ...existingTrack,
+    ...updates
+  };
+  return {
+    ...state,
+    timeline: {
+      ...state.timeline,
+      tracks: newTracks
+    }
+  };
+}
+function toggleTrackMute(state, trackId) {
+  const trackIndex = findTrackIndex(state, trackId);
+  if (trackIndex === -1) {
+    return state;
+  }
+  const track = state.timeline.tracks[trackIndex];
+  if (!track) {
+    return state;
+  }
+  return updateTrack(state, trackId, { muted: !track.muted });
+}
+function toggleTrackLock(state, trackId) {
+  const trackIndex = findTrackIndex(state, trackId);
+  if (trackIndex === -1) {
+    return state;
+  }
+  const track = state.timeline.tracks[trackIndex];
+  if (!track) {
+    return state;
+  }
+  return updateTrack(state, trackId, { locked: !track.locked });
+}
+
+// src/operations/timeline-operations.ts
+function setTimelineDuration(state, duration) {
+  return {
+    ...state,
+    timeline: {
+      ...state.timeline,
+      duration
+    }
+  };
+}
+function setTimelineName(state, name) {
+  return {
+    ...state,
+    timeline: {
+      ...state.timeline,
+      name
+    }
+  };
+}
+function updateTimelineMetadata(state, metadata) {
+  return {
+    ...state,
+    timeline: {
+      ...state.timeline,
+      metadata: {
+        ...state.timeline.metadata,
+        ...metadata
+      }
+    }
+  };
+}
+
+// src/engine/history.ts
+function createHistory(initialState, limit = 50) {
+  return {
+    past: [],
+    present: initialState,
+    future: [],
+    limit
+  };
+}
+function pushHistory(history, newState) {
+  const newPast = [...history.past, history.present];
+  if (newPast.length > history.limit) {
+    newPast.shift();
+  }
+  return {
+    ...history,
+    past: newPast,
+    present: newState,
+    future: []
+    // Clear future on new action
+  };
+}
+function undo(history) {
+  if (history.past.length === 0) {
+    return history;
+  }
+  const newPast = [...history.past];
+  const previous = newPast.pop();
+  return {
+    ...history,
+    past: newPast,
+    present: previous,
+    future: [history.present, ...history.future]
+  };
+}
+function redo(history) {
+  if (history.future.length === 0) {
+    return history;
+  }
+  const newFuture = [...history.future];
+  const next = newFuture.shift();
+  return {
+    ...history,
+    past: [...history.past, history.present],
+    present: next,
+    future: newFuture
+  };
+}
+function canUndo(history) {
+  return history.past.length > 0;
+}
+function canRedo(history) {
+  return history.future.length > 0;
+}
+function getCurrentState(history) {
+  return history.present;
+}
+
+// src/engine/dispatcher.ts
+function dispatch(history, operation) {
+  const currentState = getCurrentState(history);
+  let newState;
+  try {
+    newState = operation(currentState);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      history,
+      // Return unchanged history
+      errors: [{
+        code: "OPERATION_ERROR",
+        message: errorMessage
+      }]
+    };
+  }
+  const validationResult = validateTimeline(newState);
+  if (!validationResult.valid) {
+    return {
+      success: false,
+      history,
+      // Return unchanged history
+      errors: validationResult.errors
+    };
+  }
+  const newHistory = pushHistory(history, newState);
+  return {
+    success: true,
+    history: newHistory
+  };
+}
+
+// src/engine/timeline-engine.ts
+var TimelineEngine = class {
+  history;
+  listeners = /* @__PURE__ */ new Set();
+  /**
+   * Create a new timeline engine
+   * 
+   * @param initialState - Initial timeline state
+   * @param historyLimit - Maximum number of undo steps (default: 50)
+   */
+  constructor(initialState, historyLimit = 50) {
+    this.history = createHistory(initialState, historyLimit);
+  }
+  // ===== SUBSCRIPTION =====
+  /**
+   * Subscribe to state changes
+   * 
+   * The listener will be called whenever the timeline state changes,
+   * with the new state passed as an argument.
+   * This is used by framework adapters (e.g., React) to trigger re-renders.
+   * 
+   * @param listener - Function to call on state changes, receives new state
+   * @returns Unsubscribe function
+   * 
+   * @example
+   * ```typescript
+   * const unsubscribe = engine.subscribe((state) => {
+   *   console.log('State changed:', state);
+   * });
+   * 
+   * // Later...
+   * unsubscribe();
+   * ```
+   */
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  /**
+   * Notify all subscribers of a state change
+   * 
+   * This is called internally after any operation that modifies state.
+   * Framework adapters use this to trigger re-renders.
+   */
+  notify() {
+    const state = this.getState();
+    this.listeners.forEach((listener) => listener(state));
+  }
+  // ===== STATE ACCESS =====
+  /**
+   * Get the current timeline state
+   * 
+   * @returns Current timeline state
+   */
+  getState() {
+    return getCurrentState(this.history);
+  }
+  // ===== ASSET OPERATIONS =====
+  /**
+   * Register an asset
+   * 
+   * @param asset - Asset to register
+   * @returns Dispatch result
+   */
+  registerAsset(asset) {
+    const result = dispatch(
+      this.history,
+      (state) => registerAsset(state, asset)
+    );
+    if (result.success) {
+      this.history = result.history;
+      this.notify();
+    }
+    return result;
+  }
+  /**
+   * Get an asset by ID
+   * 
+   * @param assetId - Asset ID
+   * @returns The asset, or undefined if not found
+   */
+  getAsset(assetId) {
+    return getAsset(this.getState(), assetId);
+  }
+  // ===== CLIP OPERATIONS =====
+  /**
+   * Add a clip to a track
+   * 
+   * @param trackId - ID of the track to add to
+   * @param clip - Clip to add
+   * @returns Dispatch result
+   */
+  addClip(trackId, clip) {
+    const result = dispatch(
+      this.history,
+      (state) => addClip(state, trackId, clip)
+    );
+    if (result.success) {
+      this.history = result.history;
+      this.notify();
+    }
+    return result;
+  }
+  /**
+   * Remove a clip
+   * 
+   * @param clipId - ID of the clip to remove
+   * @returns Dispatch result
+   */
+  removeClip(clipId) {
+    const result = dispatch(
+      this.history,
+      (state) => removeClip(state, clipId)
+    );
+    if (result.success) {
+      this.history = result.history;
+      this.notify();
+    }
+    return result;
+  }
+  /**
+   * Move a clip to a new timeline position
+   * 
+   * @param clipId - ID of the clip to move
+   * @param newStart - New timeline start frame
+   * @returns Dispatch result
+   */
+  moveClip(clipId, newStart) {
+    const result = dispatch(
+      this.history,
+      (state) => moveClip(state, clipId, newStart)
+    );
+    if (result.success) {
+      this.history = result.history;
+      this.notify();
+    }
+    return result;
+  }
+  /**
+   * Resize a clip
+   * 
+   * @param clipId - ID of the clip to resize
+   * @param newStart - New timeline start frame
+   * @param newEnd - New timeline end frame
+   * @returns Dispatch result
+   */
+  resizeClip(clipId, newStart, newEnd) {
+    const result = dispatch(
+      this.history,
+      (state) => resizeClip(state, clipId, newStart, newEnd)
+    );
+    if (result.success) {
+      this.history = result.history;
+      this.notify();
+    }
+    return result;
+  }
+  /**
+   * Trim a clip (change media bounds)
+   * 
+   * @param clipId - ID of the clip to trim
+   * @param newMediaIn - New media in frame
+   * @param newMediaOut - New media out frame
+   * @returns Dispatch result
+   */
+  trimClip(clipId, newMediaIn, newMediaOut) {
+    const result = dispatch(
+      this.history,
+      (state) => trimClip(state, clipId, newMediaIn, newMediaOut)
+    );
+    if (result.success) {
+      this.history = result.history;
+      this.notify();
+    }
+    return result;
+  }
+  /**
+   * Move a clip to a different track
+   * 
+   * @param clipId - ID of the clip to move
+   * @param targetTrackId - ID of the target track
+   * @returns Dispatch result
+   */
+  moveClipToTrack(clipId, targetTrackId) {
+    const result = dispatch(
+      this.history,
+      (state) => moveClipToTrack(state, clipId, targetTrackId)
+    );
+    if (result.success) {
+      this.history = result.history;
+      this.notify();
+    }
+    return result;
+  }
+  // ===== TRACK OPERATIONS =====
+  /**
+   * Add a track
+   * 
+   * @param track - Track to add
+   * @returns Dispatch result
+   */
+  addTrack(track) {
+    const result = dispatch(
+      this.history,
+      (state) => addTrack(state, track)
+    );
+    if (result.success) {
+      this.history = result.history;
+      this.notify();
+    }
+    return result;
+  }
+  /**
+   * Remove a track
+   * 
+   * @param trackId - ID of the track to remove
+   * @returns Dispatch result
+   */
+  removeTrack(trackId) {
+    const result = dispatch(
+      this.history,
+      (state) => removeTrack(state, trackId)
+    );
+    if (result.success) {
+      this.history = result.history;
+      this.notify();
+    }
+    return result;
+  }
+  /**
+   * Move a track to a new position
+   * 
+   * @param trackId - ID of the track to move
+   * @param newIndex - New index position
+   * @returns Dispatch result
+   */
+  moveTrack(trackId, newIndex) {
+    const result = dispatch(
+      this.history,
+      (state) => moveTrack(state, trackId, newIndex)
+    );
+    if (result.success) {
+      this.history = result.history;
+      this.notify();
+    }
+    return result;
+  }
+  /**
+   * Toggle track mute
+   * 
+   * @param trackId - ID of the track
+   * @returns Dispatch result
+   */
+  toggleTrackMute(trackId) {
+    const result = dispatch(
+      this.history,
+      (state) => toggleTrackMute(state, trackId)
+    );
+    if (result.success) {
+      this.history = result.history;
+      this.notify();
+    }
+    return result;
+  }
+  /**
+   * Toggle track lock
+   * 
+   * @param trackId - ID of the track
+   * @returns Dispatch result
+   */
+  toggleTrackLock(trackId) {
+    const result = dispatch(
+      this.history,
+      (state) => toggleTrackLock(state, trackId)
+    );
+    if (result.success) {
+      this.history = result.history;
+      this.notify();
+    }
+    return result;
+  }
+  // ===== TIMELINE OPERATIONS =====
+  /**
+   * Set timeline duration
+   * 
+   * @param duration - New duration in frames
+   * @returns Dispatch result
+   */
+  setTimelineDuration(duration) {
+    const result = dispatch(
+      this.history,
+      (state) => setTimelineDuration(state, duration)
+    );
+    if (result.success) {
+      this.history = result.history;
+      this.notify();
+    }
+    return result;
+  }
+  /**
+   * Set timeline name
+   * 
+   * @param name - New timeline name
+   * @returns Dispatch result
+   */
+  setTimelineName(name) {
+    const result = dispatch(
+      this.history,
+      (state) => setTimelineName(state, name)
+    );
+    if (result.success) {
+      this.history = result.history;
+      this.notify();
+    }
+    return result;
+  }
+  // ===== HISTORY OPERATIONS =====
+  /**
+   * Undo the last action
+   * 
+   * @returns true if undo was performed
+   */
+  undo() {
+    if (!this.canUndo()) {
+      return false;
+    }
+    this.history = undo(this.history);
+    this.notify();
+    return true;
+  }
+  /**
+   * Redo the last undone action
+   * 
+   * @returns true if redo was performed
+   */
+  redo() {
+    if (!this.canRedo()) {
+      return false;
+    }
+    this.history = redo(this.history);
+    this.notify();
+    return true;
+  }
+  /**
+   * Check if undo is available
+   * 
+   * @returns true if undo is available
+   */
+  canUndo() {
+    return canUndo(this.history);
+  }
+  /**
+   * Check if redo is available
+   * 
+   * @returns true if redo is available
+   */
+  canRedo() {
+    return canRedo(this.history);
+  }
+  // ===== QUERY OPERATIONS =====
+  /**
+   * Find a clip by ID
+   * 
+   * @param clipId - Clip ID
+   * @returns The clip, or undefined if not found
+   */
+  findClipById(clipId) {
+    return findClipById(this.getState(), clipId);
+  }
+  /**
+   * Find a track by ID
+   * 
+   * @param trackId - Track ID
+   * @returns The track, or undefined if not found
+   */
+  findTrackById(trackId) {
+    return findTrackById(this.getState(), trackId);
+  }
+  /**
+   * Get all clips on a track
+   * 
+   * @param trackId - Track ID
+   * @returns Array of clips on the track
+   */
+  getClipsOnTrack(trackId) {
+    return getClipsOnTrack(this.getState(), trackId);
+  }
+  /**
+   * Get all clips at a specific frame
+   * 
+   * @param frame - Frame to check
+   * @returns Array of clips at that frame
+   */
+  getClipsAtFrame(frame2) {
+    return getClipsAtFrame(this.getState(), frame2);
+  }
+  /**
+   * Get all clips in a frame range
+   * 
+   * @param start - Start frame
+   * @param end - End frame
+   * @returns Array of clips in the range
+   */
+  getClipsInRange(start, end) {
+    return getClipsInRange(this.getState(), start, end);
+  }
+  /**
+   * Get all clips in the timeline
+   * 
+   * @returns Array of all clips
+   */
+  getAllClips() {
+    return getAllClips(this.getState());
+  }
+  /**
+   * Get all tracks in the timeline
+   * 
+   * @returns Array of all tracks
+   */
+  getAllTracks() {
+    return getAllTracks(this.getState());
+  }
+};
+
+// src/types/timeline.ts
+function createTimeline(params) {
+  const timeline = {
+    id: params.id,
+    name: params.name,
+    fps: params.fps,
+    duration: params.duration,
+    tracks: params.tracks ?? []
+  };
+  if (params.metadata !== void 0) {
+    timeline.metadata = params.metadata;
+  }
+  return timeline;
+}
+
+// src/types/asset.ts
+function createAsset(params) {
+  const asset = {
+    id: params.id,
+    type: params.type,
+    duration: params.duration,
+    sourceUrl: params.sourceUrl
+  };
+  if (params.metadata !== void 0) {
+    asset.metadata = params.metadata;
+  }
+  return asset;
+}
+
+// src/types/state.ts
+function createTimelineState(params) {
+  const state = {
+    timeline: params.timeline,
+    assets: params.assets ?? /* @__PURE__ */ new Map(),
+    linkGroups: params.linkGroups ?? /* @__PURE__ */ new Map(),
+    groups: params.groups ?? /* @__PURE__ */ new Map(),
+    markers: params.markers ?? {
+      timeline: [],
+      clips: [],
+      regions: []
+    }
+  };
+  if (params.workArea !== void 0) {
+    state.workArea = params.workArea;
+  }
+  return state;
+}
+
+// src/types/frame.ts
+function frame(value) {
+  const rounded = Math.round(value);
+  if (rounded < 0) {
+    throw new Error(`Frame value must be non-negative, got: ${value}`);
+  }
+  return rounded;
+}
+function frameRate(value) {
+  if (value <= 0) {
+    throw new Error(`FrameRate must be positive, got: ${value}`);
+  }
+  return value;
+}
+function isValidFrame(value) {
+  return Number.isInteger(value) && value >= 0;
+}
+function isValidFrameRate(value) {
+  return value > 0;
+}
+
+// src/utils/frame.ts
+function framesToSeconds(frames, fps) {
+  return frames / fps;
+}
+function secondsToFrames(seconds, fps) {
+  return frame(seconds * fps);
+}
+function framesToTimecode(frames, fps) {
+  const totalFrames = frames;
+  const framesPart = totalFrames % fps;
+  const totalSeconds = Math.floor(totalFrames / fps);
+  const secondsPart = totalSeconds % 60;
+  const totalMinutes = Math.floor(totalSeconds / 60);
+  const minutesPart = totalMinutes % 60;
+  const hoursPart = Math.floor(totalMinutes / 60);
+  return `${pad(hoursPart)}:${pad(minutesPart)}:${pad(secondsPart)}:${pad(framesPart)}`;
+}
+function framesToMinutesSeconds(frames, fps) {
+  const totalSeconds = Math.floor(frames / fps);
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  return `${minutes}:${pad(seconds)}`;
+}
+function clampFrame(value, min, max) {
+  return frame(Math.max(min, Math.min(max, value)));
+}
+function addFrames(a, b) {
+  return frame(a + b);
+}
+function subtractFrames(a, b) {
+  return frame(Math.max(0, a - b));
+}
+function frameDuration(start, end) {
+  return frame(end - start);
+}
+function pad(num, width = 2) {
+  return num.toString().padStart(width, "0");
+}
+
+export {
+  createClip,
+  getClipDuration,
+  getClipMediaDuration,
+  clipContainsFrame,
+  clipsOverlap,
+  validResult,
+  invalidResult,
+  invalidResults,
+  combineResults,
+  registerAsset,
+  getAsset,
+  hasAsset,
+  getAllAssets,
+  unregisterAsset,
+  validateClip,
+  validateTrack,
+  validateTimeline,
+  validateNoOverlap,
+  findClipById,
+  findTrackById,
+  getClipsOnTrack,
+  getClipsAtFrame,
+  getClipsInRange,
+  getAllClips,
+  getAllTracks,
+  findTrackIndex,
+  createTrack,
+  sortTrackClips,
+  addClip,
+  removeClip,
+  moveClip,
+  resizeClip,
+  trimClip,
+  updateClip,
+  moveClipToTrack,
+  addTrack,
+  removeTrack,
+  moveTrack,
+  updateTrack,
+  toggleTrackMute,
+  toggleTrackLock,
+  setTimelineDuration,
+  setTimelineName,
+  updateTimelineMetadata,
+  TimelineEngine,
+  createTimeline,
+  createAsset,
+  createTimelineState,
+  frame,
+  frameRate,
+  isValidFrame,
+  isValidFrameRate,
+  framesToSeconds,
+  secondsToFrames,
+  framesToTimecode,
+  framesToMinutesSeconds,
+  clampFrame,
+  addFrames,
+  subtractFrames,
+  frameDuration
+};