@webpacked-timeline/core 1.0.0-beta.1

package/dist/chunk-I2GZXRH4.js

@@ -0,0 +1,4790 @@
+// src/types/timeline.ts
+var DEFAULT_SEQUENCE_SETTINGS = {
+  pixelAspectRatio: 1,
+  fieldOrder: "progressive",
+  colorSpace: "sRGB",
+  audioSampleRate: 48e3,
+  audioChannelCount: 2
+};
+function createTimeline(params) {
+  return {
+    id: params.id,
+    name: params.name,
+    fps: params.fps,
+    duration: params.duration,
+    startTimecode: params.startTimecode ?? "00:00:00:00",
+    tracks: params.tracks ?? [],
+    sequenceSettings: { ...DEFAULT_SEQUENCE_SETTINGS, ...params.sequenceSettings },
+    version: 0,
+    markers: params.markers ?? [],
+    beatGrid: params.beatGrid ?? null,
+    inPoint: params.inPoint ?? null,
+    outPoint: params.outPoint ?? null,
+    ...params.trackGroups !== void 0 && { trackGroups: params.trackGroups },
+    ...params.linkGroups !== void 0 && { linkGroups: params.linkGroups }
+  };
+}
+
+// src/types/track.ts
+var toTrackId = (s) => s;
+function createTrack(params) {
+  return {
+    id: params.id,
+    name: params.name,
+    type: params.type,
+    clips: params.clips ?? [],
+    captions: params.captions ?? [],
+    locked: params.locked ?? false,
+    muted: params.muted ?? false,
+    solo: params.solo ?? false,
+    height: params.height ?? 56,
+    ...params.blendMode !== void 0 && { blendMode: params.blendMode },
+    ...params.opacity !== void 0 && { opacity: params.opacity },
+    ...params.groupId !== void 0 && { groupId: params.groupId }
+  };
+}
+function sortTrackClips(track) {
+  return {
+    ...track,
+    clips: [...track.clips].sort((a, b) => a.timelineStart - b.timelineStart)
+  };
+}
+
+// src/types/clip.ts
+var toClipId = (s) => s;
+function createClip(params) {
+  return {
+    id: params.id,
+    assetId: params.assetId,
+    trackId: params.trackId,
+    timelineStart: params.timelineStart,
+    timelineEnd: params.timelineEnd,
+    mediaIn: params.mediaIn,
+    mediaOut: params.mediaOut,
+    speed: params.speed ?? 1,
+    enabled: params.enabled ?? true,
+    reversed: params.reversed ?? false,
+    name: params.name ?? null,
+    color: params.color ?? null,
+    metadata: params.metadata ?? {},
+    ...params.effects !== void 0 && { effects: params.effects },
+    ...params.transform !== void 0 && { transform: params.transform },
+    ...params.audio !== void 0 && { audio: params.audio },
+    ...params.transition !== void 0 && { transition: params.transition }
+  };
+}
+function getClipDuration(clip) {
+  return clip.timelineEnd - clip.timelineStart;
+}
+function getClipMediaDuration(clip) {
+  return clip.mediaOut - clip.mediaIn;
+}
+function clipContainsFrame(clip, f) {
+  return f >= clip.timelineStart && f < clip.timelineEnd;
+}
+function clipsOverlap(a, b) {
+  return a.timelineStart < b.timelineEnd && b.timelineStart < a.timelineEnd;
+}
+
+// src/types/asset.ts
+var toAssetId = (s) => s;
+function createAsset(params) {
+  return {
+    kind: "file",
+    id: params.id,
+    name: params.name,
+    mediaType: params.mediaType,
+    filePath: params.filePath,
+    intrinsicDuration: params.intrinsicDuration,
+    nativeFps: params.nativeFps,
+    sourceTimecodeOffset: params.sourceTimecodeOffset,
+    status: params.status ?? "online"
+  };
+}
+function createGeneratorAsset(params) {
+  return {
+    kind: "generator",
+    id: params.id,
+    name: params.name,
+    mediaType: params.mediaType,
+    intrinsicDuration: params.generatorDef.duration,
+    nativeFps: params.nativeFps,
+    sourceTimecodeOffset: 0,
+    status: params.status ?? "online",
+    generatorDef: params.generatorDef
+  };
+}
+
+// src/types/state.ts
+var CURRENT_SCHEMA_VERSION = 2;
+function createTimelineState(params) {
+  const registry = params.assetRegistry ?? (params.assets ? params.assets : /* @__PURE__ */ new Map());
+  return {
+    schemaVersion: CURRENT_SCHEMA_VERSION,
+    timeline: params.timeline,
+    assetRegistry: registry
+  };
+}
+
+// src/types/frame.ts
+var toFrame = (n) => n;
+function frame(value) {
+  const rounded = Math.round(value);
+  if (rounded < 0) {
+    throw new Error(`TimelineFrame must be non-negative, got: ${value}`);
+  }
+  return rounded;
+}
+var FrameRates = {
+  CINEMA: 24,
+  PAL: 25,
+  NTSC_DF: 29.97,
+  NTSC: 30,
+  PAL_HFR: 50,
+  NTSC_HFR: 59.94,
+  HFR: 60
+};
+function frameRate(value) {
+  const valid = [23.976, 24, 25, 29.97, 30, 50, 59.94, 60];
+  if (!valid.includes(value)) {
+    throw new Error(
+      `FrameRate must be one of ${valid.join(", ")}, got: ${value}`
+    );
+  }
+  return value;
+}
+var toTimecode = (s) => s;
+function isValidFrame(value) {
+  return Number.isInteger(value) && value >= 0;
+}
+function isDropFrame(fps) {
+  return fps === 29.97 || fps === 59.94;
+}
+
+// src/utils/frame.ts
+function framesToSeconds(frames, fps) {
+  return frames / fps;
+}
+function secondsToFrames(seconds, fps) {
+  return toFrame(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 toFrame(Math.max(min, Math.min(max, value)));
+}
+function addFrames(a, b) {
+  return toFrame(a + b);
+}
+function subtractFrames(a, b) {
+  return toFrame(Math.max(0, a - b));
+}
+function frameDuration(start, end) {
+  return toFrame(end - start);
+}
+function pad(num, width = 2) {
+  return num.toString().padStart(width, "0");
+}
+
+// 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/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 ? Array.from(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/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 next = new Map(state.assetRegistry);
+  next.set(asset.id, asset);
+  return { ...state, assetRegistry: next };
+}
+function getAsset(state, assetId) {
+  return state.assetRegistry.get(toAssetId(assetId));
+}
+function hasAsset(state, assetId) {
+  return state.assetRegistry.has(toAssetId(assetId));
+}
+function getAllAssets(state) {
+  return Array.from(state.assetRegistry.values());
+}
+function unregisterAsset(state, assetId) {
+  const next = new Map(state.assetRegistry);
+  next.delete(toAssetId(assetId));
+  return { ...state, assetRegistry: next };
+}
+
+// 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.intrinsicDuration) {
+    errors.push(invalidResult(
+      "MEDIA_EXCEEDS_ASSET",
+      `Clip media out (${clip.mediaOut}) exceeds asset duration (${asset.intrinsicDuration})`,
+      { clipId: clip.id, mediaOut: clip.mediaOut, assetDuration: asset.intrinsicDuration }
+    ));
+  }
+  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.mediaType === "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.mediaType,
+        trackType: targetTrack.type,
+        trackId: targetTrack.id
+      }
+    );
+  }
+  if (asset.mediaType === "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.mediaType,
+        trackType: targetTrack.type,
+        trackId: targetTrack.id
+      }
+    );
+  }
+  return validResult();
+}
+
+// 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 });
+}
+function toggleTrackSolo(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, { solo: !track.solo });
+}
+function setTrackHeight(state, trackId, height) {
+  return updateTrack(state, trackId, { height: Math.max(40, Math.min(200, height)) });
+}
+
+// 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
+    }
+  };
+}
+
+// src/engine/transactions.ts
+function beginTransaction(state) {
+  return {
+    initialState: state,
+    currentState: state,
+    operations: [],
+    finalized: false
+  };
+}
+function applyOperation(tx, operation) {
+  if (tx.finalized) {
+    throw new Error("Cannot apply operation to finalized transaction");
+  }
+  const newState = operation(tx.currentState);
+  return {
+    ...tx,
+    currentState: newState,
+    operations: [...tx.operations, operation]
+  };
+}
+function commitTransaction(tx) {
+  if (tx.finalized) {
+    throw new Error("Transaction already finalized");
+  }
+  tx.finalized = true;
+  return tx.currentState;
+}
+
+// src/operations/ripple.ts
+function rippleDelete(state, clipId) {
+  const clip = findClipById(state, clipId);
+  if (!clip) {
+    throw new Error(`Clip not found: ${clipId}`);
+  }
+  const track = findTrackById(state, clip.trackId);
+  if (!track) {
+    throw new Error(`Track not found: ${clip.trackId}`);
+  }
+  const clipDuration = getClipDuration(clip);
+  const deleteEnd = clip.timelineEnd;
+  const clipsToShift = track.clips.filter(
+    (c) => c.id !== clipId && c.timelineStart >= deleteEnd
+  );
+  let tx = beginTransaction(state);
+  tx = applyOperation(tx, (s) => removeClip(s, clipId));
+  for (const clipToShift of clipsToShift) {
+    const newStart = clipToShift.timelineStart - clipDuration;
+    tx = applyOperation(tx, (s) => moveClip(s, clipToShift.id, newStart));
+  }
+  return commitTransaction(tx);
+}
+function rippleTrim(state, clipId, newEnd) {
+  const clip = findClipById(state, clipId);
+  if (!clip) {
+    throw new Error(`Clip not found: ${clipId}`);
+  }
+  const track = findTrackById(state, clip.trackId);
+  if (!track) {
+    throw new Error(`Track not found: ${clip.trackId}`);
+  }
+  if (newEnd <= clip.timelineStart) {
+    throw new Error("New end must be after clip start");
+  }
+  const delta = newEnd - clip.timelineEnd;
+  const clipsToShift = track.clips.filter(
+    (c) => c.id !== clipId && c.timelineStart >= clip.timelineEnd
+  );
+  let tx = beginTransaction(state);
+  tx = applyOperation(tx, (s) => resizeClip(s, clipId, clip.timelineStart, newEnd));
+  for (const clipToShift of clipsToShift) {
+    const newStart = clipToShift.timelineStart + delta;
+    tx = applyOperation(tx, (s) => moveClip(s, clipToShift.id, newStart));
+  }
+  return commitTransaction(tx);
+}
+function insertEdit(state, trackId, clip, atFrame) {
+  const track = findTrackById(state, trackId);
+  if (!track) {
+    throw new Error(`Track not found: ${trackId}`);
+  }
+  const clipDuration = getClipDuration(clip);
+  const clipsToShift = track.clips.filter((c) => c.timelineStart >= atFrame);
+  const adjustedClip = {
+    ...clip,
+    timelineStart: atFrame,
+    timelineEnd: atFrame + clipDuration
+  };
+  let tx = beginTransaction(state);
+  for (const clipToShift of clipsToShift) {
+    const newStart = clipToShift.timelineStart + clipDuration;
+    tx = applyOperation(tx, (s) => moveClip(s, clipToShift.id, newStart));
+  }
+  tx = applyOperation(tx, (s) => addClip(s, trackId, adjustedClip));
+  return commitTransaction(tx);
+}
+function rippleMove(state, clipId, newStart) {
+  const clip = findClipById(state, clipId);
+  if (!clip) {
+    throw new Error(`Clip not found: ${clipId}`);
+  }
+  const track = findTrackById(state, clip.trackId);
+  if (!track) {
+    throw new Error(`Track not found: ${clip.trackId}`);
+  }
+  const clipDuration = getClipDuration(clip);
+  const newEnd = newStart + clipDuration;
+  if (newStart < 0) {
+    throw new Error("Cannot move clip before timeline start (frame 0)");
+  }
+  if (newEnd > state.timeline.duration) {
+    throw new Error(`Cannot move clip beyond timeline duration (${state.timeline.duration} frames)`);
+  }
+  const originalStart = clip.timelineStart;
+  const originalEnd = clip.timelineEnd;
+  if (newStart === originalStart) {
+    return state;
+  }
+  let tx = beginTransaction(state);
+  if (newStart > originalStart) {
+    const afterSource = track.clips.filter((c) => c.id !== clipId && c.timelineStart >= originalEnd).sort((a, b) => a.timelineStart - b.timelineStart);
+    for (const other of afterSource) {
+      const s = other.timelineStart - clipDuration;
+      tx = applyOperation(tx, (st) => moveClip(st, other.id, s));
+    }
+    const anyClipBetween = afterSource.some((c) => c.timelineStart < newStart);
+    const collapsedDest = anyClipBetween ? newStart - clipDuration : newStart;
+    const currentTrack = tx.currentState.timeline.tracks.find((t) => t.id === track.id);
+    const atDest = currentTrack.clips.filter((c) => c.id !== clipId && c.timelineStart >= collapsedDest).sort((a, b) => b.timelineStart - a.timelineStart);
+    for (const other of atDest) {
+      const s = other.timelineStart + clipDuration;
+      tx = applyOperation(tx, (st) => moveClip(st, other.id, s));
+    }
+    tx = applyOperation(tx, (st) => moveClip(st, clipId, collapsedDest));
+  } else {
+    const afterSource = track.clips.filter((c) => c.id !== clipId && c.timelineStart >= originalEnd).sort((a, b) => a.timelineStart - b.timelineStart);
+    for (const other of afterSource) {
+      const s = other.timelineStart - clipDuration;
+      tx = applyOperation(tx, (st) => moveClip(st, other.id, s));
+    }
+    tx = applyOperation(tx, (st) => moveClip(st, clipId, newStart));
+  }
+  return commitTransaction(tx);
+}
+function insertMove(state, clipId, newStart) {
+  const clip = findClipById(state, clipId);
+  if (!clip) {
+    throw new Error(`Clip not found: ${clipId}`);
+  }
+  const track = findTrackById(state, clip.trackId);
+  if (!track) {
+    throw new Error(`Track not found: ${clip.trackId}`);
+  }
+  const clipDuration = getClipDuration(clip);
+  const newEnd = newStart + clipDuration;
+  if (newStart < 0) {
+    throw new Error("Cannot move clip before timeline start (frame 0)");
+  }
+  if (newEnd > state.timeline.duration) {
+    throw new Error(`Cannot move clip beyond timeline duration (${state.timeline.duration} frames)`);
+  }
+  if (newStart === clip.timelineStart) {
+    return state;
+  }
+  let tx = beginTransaction(state);
+  const clipsToShift = track.clips.filter(
+    (c) => c.id !== clipId && c.timelineStart >= newStart
+  );
+  for (const clipToShift of clipsToShift) {
+    const shiftedStart = clipToShift.timelineStart + clipDuration;
+    tx = applyOperation(tx, (s) => moveClip(s, clipToShift.id, shiftedStart));
+  }
+  tx = applyOperation(tx, (s) => moveClip(s, clipId, newStart));
+  return commitTransaction(tx);
+}
+
+// src/engine/timeline-engine.ts
+function legacyDispatch(history, operation) {
+  const currentState = getCurrentState(history);
+  let newState;
+  try {
+    newState = operation(currentState);
+  } catch (err) {
+    return { accepted: false, errors: [{ code: "OPERATION_ERROR", message: String(err) }] };
+  }
+  const newHistory = pushHistory(history, newState);
+  return { accepted: true, history: newHistory };
+}
+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 = legacyDispatch(
+      this.history,
+      (state) => registerAsset(state, asset)
+    );
+    if (result.accepted && result.history) {
+      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 = legacyDispatch(
+      this.history,
+      (state) => addClip(state, trackId, clip)
+    );
+    if (result.accepted && result.history) {
+      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 = legacyDispatch(
+      this.history,
+      (state) => removeClip(state, clipId)
+    );
+    if (result.accepted && result.history) {
+      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 = legacyDispatch(
+      this.history,
+      (state) => moveClip(state, clipId, newStart)
+    );
+    if (result.accepted && result.history) {
+      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 = legacyDispatch(
+      this.history,
+      (state) => resizeClip(state, clipId, newStart, newEnd)
+    );
+    if (result.accepted && result.history) {
+      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 = legacyDispatch(
+      this.history,
+      (state) => trimClip(state, clipId, newMediaIn, newMediaOut)
+    );
+    if (result.accepted && result.history) {
+      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 = legacyDispatch(
+      this.history,
+      (state) => moveClipToTrack(state, clipId, targetTrackId)
+    );
+    if (result.accepted && result.history) {
+      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 = legacyDispatch(
+      this.history,
+      (state) => addTrack(state, track)
+    );
+    if (result.accepted && result.history) {
+      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 = legacyDispatch(
+      this.history,
+      (state) => removeTrack(state, trackId)
+    );
+    if (result.accepted && result.history) {
+      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 = legacyDispatch(
+      this.history,
+      (state) => moveTrack(state, trackId, newIndex)
+    );
+    if (result.accepted && result.history) {
+      this.history = result.history;
+      this.notify();
+    }
+    return result;
+  }
+  /**
+   * Toggle track mute
+   * 
+   * @param trackId - ID of the track
+   * @returns Dispatch result
+   */
+  toggleTrackMute(trackId) {
+    const result = legacyDispatch(
+      this.history,
+      (state) => toggleTrackMute(state, trackId)
+    );
+    if (result.accepted && result.history) {
+      this.history = result.history;
+      this.notify();
+    }
+    return result;
+  }
+  /**
+   * Toggle track lock
+   * 
+   * @param trackId - ID of the track
+   * @returns Dispatch result
+   */
+  toggleTrackLock(trackId) {
+    const result = legacyDispatch(
+      this.history,
+      (state) => toggleTrackLock(state, trackId)
+    );
+    if (result.accepted && result.history) {
+      this.history = result.history;
+      this.notify();
+    }
+    return result;
+  }
+  /**
+   * Toggle track solo
+   * 
+   * @param trackId - ID of the track
+   * @returns Dispatch result
+   */
+  toggleTrackSolo(trackId) {
+    const result = legacyDispatch(
+      this.history,
+      (state) => toggleTrackSolo(state, trackId)
+    );
+    if (result.accepted && result.history) {
+      this.history = result.history;
+      this.notify();
+    }
+    return result;
+  }
+  /**
+   * Set track height
+   * 
+   * @param trackId - ID of the track
+   * @param height - New height in pixels
+   * @returns Dispatch result
+   */
+  setTrackHeight(trackId, height) {
+    const result = legacyDispatch(
+      this.history,
+      (state) => setTrackHeight(state, trackId, height)
+    );
+    if (result.accepted && result.history) {
+      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 = legacyDispatch(
+      this.history,
+      (state) => setTimelineDuration(state, duration)
+    );
+    if (result.accepted && result.history) {
+      this.history = result.history;
+      this.notify();
+    }
+    return result;
+  }
+  /**
+   * Set timeline name
+   * 
+   * @param name - New timeline name
+   * @returns Dispatch result
+   */
+  setTimelineName(name) {
+    const result = legacyDispatch(
+      this.history,
+      (state) => setTimelineName(state, name)
+    );
+    if (result.accepted && result.history) {
+      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(f) {
+    return getClipsAtFrame(this.getState(), f);
+  }
+  /**
+   * 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());
+  }
+  // ===== RIPPLE OPERATIONS =====
+  /**
+   * Ripple delete - delete clip and shift subsequent clips left
+   * 
+   * @param clipId - ID of the clip to delete
+   * @returns Dispatch result
+   */
+  rippleDelete(clipId) {
+    const result = legacyDispatch(
+      this.history,
+      (state) => rippleDelete(state, clipId)
+    );
+    if (result.accepted && result.history) {
+      this.history = result.history;
+      this.notify();
+    }
+    return result;
+  }
+  /**
+   * Ripple trim - trim clip end and shift subsequent clips
+   * 
+   * @param clipId - ID of the clip to trim
+   * @param newEnd - New end frame for the clip
+   * @returns Dispatch result
+   */
+  rippleTrim(clipId, newEnd) {
+    const result = legacyDispatch(
+      this.history,
+      (state) => rippleTrim(state, clipId, newEnd)
+    );
+    if (result.accepted && result.history) {
+      this.history = result.history;
+      this.notify();
+    }
+    return result;
+  }
+  /**
+   * Insert edit - insert clip and shift subsequent clips right
+   * 
+   * @param trackId - ID of the track to insert into
+   * @param clip - Clip to insert
+   * @param atFrame - Frame to insert at
+   * @returns Dispatch result
+   */
+  insertEdit(trackId, clip, atFrame) {
+    const result = legacyDispatch(
+      this.history,
+      (state) => insertEdit(state, trackId, clip, atFrame)
+    );
+    if (result.accepted && result.history) {
+      this.history = result.history;
+      this.notify();
+    }
+    return result;
+  }
+  /**
+   * Ripple move - move clip and shift surrounding clips to accommodate
+   * 
+   * This moves a clip to a new position while maintaining timeline continuity:
+   * - Closes the gap at the source position
+   * - Makes space at the destination position
+   * - All operations are atomic (single undo entry)
+   * 
+   * @param clipId - ID of the clip to move
+   * @param newStart - New start frame for the clip
+   * @returns Dispatch result
+   */
+  rippleMove(clipId, newStart) {
+    const result = legacyDispatch(
+      this.history,
+      (state) => rippleMove(state, clipId, newStart)
+    );
+    if (result.accepted && result.history) {
+      this.history = result.history;
+      this.notify();
+    } else if (!result.accepted && result.errors?.[0]?.code === "OPERATION_ERROR") {
+      throw new Error(result.errors[0].message);
+    }
+    return result;
+  }
+  /**
+   * Insert move - move clip and shift destination clips right
+   * 
+   * This moves a clip to a new position without closing the gap at source:
+   * - Leaves gap at the source position
+   * - Pushes all clips at destination right to make space
+   * - All operations are atomic (single undo entry)
+   * 
+   * @param clipId - ID of the clip to move
+   * @param newStart - New start frame for the clip
+   * @returns Dispatch result
+   */
+  insertMove(clipId, newStart) {
+    const result = legacyDispatch(
+      this.history,
+      (state) => insertMove(state, clipId, newStart)
+    );
+    if (result.accepted && result.history) {
+      this.history = result.history;
+      this.notify();
+    } else if (!result.accepted && result.errors?.[0]?.code === "OPERATION_ERROR") {
+      throw new Error(result.errors[0].message);
+    }
+    return result;
+  }
+  // Phase 2: Marker and WorkArea operations are gated to Phase 2.
+  // They are intentionally omitted here to keep Phase 0 clean.
+};
+
+// src/types/clip-transform.ts
+function createAnimatableProperty(value) {
+  return { value, keyframes: [] };
+}
+var DEFAULT_CLIP_TRANSFORM = {
+  positionX: createAnimatableProperty(0),
+  positionY: createAnimatableProperty(0),
+  scaleX: createAnimatableProperty(1),
+  scaleY: createAnimatableProperty(1),
+  rotation: createAnimatableProperty(0),
+  opacity: createAnimatableProperty(1),
+  anchorX: createAnimatableProperty(0),
+  anchorY: createAnimatableProperty(0)
+};
+
+// src/types/audio-properties.ts
+var DEFAULT_AUDIO_PROPERTIES = {
+  gain: createAnimatableProperty(0),
+  pan: createAnimatableProperty(0),
+  mute: false,
+  channelRouting: "stereo",
+  normalizationGain: 0
+};
+
+// src/types/caption.ts
+var toCaptionId = (s) => s;
+
+// src/engine/subtitle-import.ts
+var defaultCaptionStyle = {
+  fontFamily: "sans-serif",
+  fontSize: 16,
+  color: "#ffffff",
+  backgroundColor: "rgba(0,0,0,0.75)",
+  hAlign: "center",
+  vAlign: "bottom"
+};
+function timecodeToFrame(tc, fps) {
+  const normalized = tc.trim().replace(",", ".");
+  const parts = normalized.split(":");
+  let h = 0;
+  let m;
+  let s;
+  let ms;
+  if (parts.length === 3) {
+    h = parseInt(parts[0], 10) || 0;
+    m = parseInt(parts[1], 10) || 0;
+    const sMs = parts[2].split(".");
+    s = parseInt(sMs[0], 10) || 0;
+    ms = parseInt(sMs[1] ?? "0", 10) || 0;
+  } else if (parts.length === 2) {
+    m = parseInt(parts[0], 10) || 0;
+    const sMs = parts[1].split(".");
+    s = parseInt(sMs[0], 10) || 0;
+    ms = parseInt(sMs[1] ?? "0", 10) || 0;
+  } else {
+    return toFrame(0);
+  }
+  const totalSeconds = h * 3600 + m * 60 + s + ms / 1e3;
+  return toFrame(Math.round(totalSeconds * fps));
+}
+function stripTags(text) {
+  return text.replace(/<b>\s*<\/b>/gi, "").replace(/<i>\s*<\/i>/gi, "").replace(/<u>\s*<\/u>/gi, "").replace(/<b>/gi, "").replace(/<\/b>/gi, "").replace(/<i>/gi, "").replace(/<\/i>/gi, "").replace(/<u>/gi, "").replace(/<\/u>/gi, "").replace(/<font[^>]*>/gi, "").replace(/<\/font>/gi, "").replace(/<ruby>\s*<\/ruby>/gi, "").replace(/<rt>\s*<\/rt>/gi, "").replace(/<ruby>/gi, "").replace(/<\/ruby>/gi, "").replace(/<rt>/gi, "").replace(/<\/rt>/gi, "").replace(/<lang[^>]*>/gi, "").replace(/<\/lang>/gi, "").replace(/<[0-9]{2}:[0-9]{2}:[0-9]{2}\.[0-9]{3}>/g, "");
+}
+var FULL_TIMECODE_RE = /^(\d{1,2}:\d{1,2}:\d{1,2}[,.]\d{3})\s*-->\s*(\d{1,2}:\d{1,2}:\d{1,2}[,.]\d{3})/;
+var SHORT_TIMECODE_RE = /^(\d{1,2}:\d{1,2}[,.]\d{3})\s*-->\s*(\d{1,2}:\d{1,2}[,.]\d{3})/;
+function matchTimecodeLine(line) {
+  const full = line.match(FULL_TIMECODE_RE);
+  if (full) return { start: full[1], end: full[2] };
+  const short = line.match(SHORT_TIMECODE_RE);
+  if (short) return { start: short[1], end: short[2] };
+  return null;
+}
+function parseSRT(raw, fps, options) {
+  const language = options?.language ?? "en-US";
+  const burnIn = options?.burnIn ?? false;
+  const style = { ...defaultCaptionStyle, ...options?.defaultStyle };
+  const blocks = raw.split(/\r?\n\r?\n/).filter((b) => b.trim().length > 0);
+  const captions = [];
+  for (const block of blocks) {
+    const lines = block.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
+    if (lines.length < 2) continue;
+    const indexStr = lines[0];
+    const timecodeLine = lines[1];
+    const matched = matchTimecodeLine(timecodeLine);
+    if (!matched) continue;
+    const startTc = matched.start.replace(",", ".");
+    const endTc = matched.end.replace(",", ".");
+    const textLines = lines.slice(2);
+    const text = stripTags(textLines.join("\n"));
+    const index = indexStr.replace(/\D/g, "") || indexStr;
+    captions.push({
+      id: toCaptionId(`srt-${index}`),
+      text,
+      startFrame: timecodeToFrame(startTc, fps),
+      endFrame: timecodeToFrame(endTc, fps),
+      language,
+      style,
+      burnIn
+    });
+  }
+  return captions;
+}
+function parseVTT(raw, fps, options) {
+  const lines = raw.split(/\r?\n/);
+  if (lines.length === 0 || !lines[0].trim().startsWith("WEBVTT")) {
+    return [];
+  }
+  const language = options?.language ?? "en-US";
+  const burnIn = options?.burnIn ?? false;
+  const style = { ...defaultCaptionStyle, ...options?.defaultStyle };
+  const captions = [];
+  let cueIndex = 0;
+  const blocks = raw.split(/\r?\n\r?\n/);
+  for (const block of blocks) {
+    const blockLines = block.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
+    if (blockLines.length === 0) continue;
+    const first = blockLines[0];
+    if (first.startsWith("NOTE") || first.startsWith("STYLE") || first.startsWith("REGION")) continue;
+    let timecodeLine;
+    let textLines;
+    if (first.includes("-->")) {
+      timecodeLine = first;
+      textLines = blockLines.slice(1);
+    } else if (blockLines.length >= 2 && blockLines[1].includes("-->")) {
+      timecodeLine = blockLines[1];
+      textLines = blockLines.slice(2);
+    } else {
+      continue;
+    }
+    const matched = matchTimecodeLine(timecodeLine);
+    if (!matched) continue;
+    cueIndex++;
+    const startTc = matched.start.replace(",", ".");
+    const endTc = matched.end.replace(",", ".");
+    const text = stripTags(textLines.join("\n"));
+    captions.push({
+      id: toCaptionId(`vtt-${cueIndex}`),
+      text,
+      startFrame: timecodeToFrame(startTc, fps),
+      endFrame: timecodeToFrame(endTc, fps),
+      language,
+      style,
+      burnIn
+    });
+  }
+  return captions;
+}
+function subtitleImportToOps(captions, trackId) {
+  return captions.map((caption) => ({
+    type: "ADD_CAPTION",
+    caption,
+    trackId
+  }));
+}
+
+// src/validation/invariants.ts
+function checkInvariants(state) {
+  const violations = [];
+  if (state.schemaVersion !== CURRENT_SCHEMA_VERSION) {
+    violations.push({
+      type: "SCHEMA_VERSION_MISMATCH",
+      entityId: "timeline",
+      message: `Expected schema v${CURRENT_SCHEMA_VERSION}, got v${state.schemaVersion}`
+    });
+    return violations;
+  }
+  for (const track of state.timeline.tracks) {
+    checkTrack(state, track, violations);
+  }
+  checkMarkerBounds(state, violations);
+  checkInOutPoints(state, violations);
+  checkBeatGrid(state, violations);
+  checkLinkGroups(state, violations);
+  checkTrackGroups(state, violations);
+  return violations;
+}
+function checkTrack(state, track, violations) {
+  const clips = track.clips;
+  for (let i = 1; i < clips.length; i++) {
+    const prev = clips[i - 1];
+    const curr = clips[i];
+    if (prev.timelineStart > curr.timelineStart) {
+      violations.push({
+        type: "TRACK_NOT_SORTED",
+        entityId: track.id,
+        message: `Track '${track.id}': clip '${curr.id}' (start=${curr.timelineStart}) appears after clip '${prev.id}' (start=${prev.timelineStart}) \u2014 not sorted.`
+      });
+    }
+  }
+  for (let i = 0; i < clips.length; i++) {
+    for (let j = i + 1; j < clips.length; j++) {
+      const a = clips[i];
+      const b = clips[j];
+      if (clipsOverlap(a, b)) {
+        violations.push({
+          type: "OVERLAP",
+          entityId: a.id,
+          message: `Track '${track.id}': clips '${a.id}' [${a.timelineStart}-${a.timelineEnd}) and '${b.id}' [${b.timelineStart}-${b.timelineEnd}) overlap.`
+        });
+      }
+    }
+  }
+  for (const clip of clips) {
+    checkClip(state, track, clip, violations);
+  }
+  checkCaptionBounds(state, track, violations);
+}
+function checkClip(state, track, clip, violations) {
+  const asset = state.assetRegistry.get(clip.assetId);
+  if (!asset) {
+    violations.push({
+      type: "ASSET_MISSING",
+      entityId: clip.id,
+      message: `Clip '${clip.id}' references asset '${clip.assetId}' which is not in the registry.`
+    });
+    return;
+  }
+  if (asset.mediaType !== track.type) {
+    violations.push({
+      type: "TRACK_TYPE_MISMATCH",
+      entityId: clip.id,
+      message: `Clip '${clip.id}' has asset mediaType '${asset.mediaType}' but is on a '${track.type}' track '${track.id}'.`
+    });
+  }
+  if (clip.mediaIn < 0) {
+    violations.push({
+      type: "MEDIA_BOUNDS_INVALID",
+      entityId: clip.id,
+      message: `Clip '${clip.id}': mediaIn (${clip.mediaIn}) must be >= 0.`
+    });
+  }
+  if (clip.mediaOut > asset.intrinsicDuration) {
+    violations.push({
+      type: "MEDIA_BOUNDS_INVALID",
+      entityId: clip.id,
+      message: `Clip '${clip.id}': mediaOut (${clip.mediaOut}) exceeds asset intrinsicDuration (${asset.intrinsicDuration}).`
+    });
+  }
+  const mediaDuration = clip.mediaOut - clip.mediaIn;
+  const timelineDuration = clip.timelineEnd - clip.timelineStart;
+  const expectedMediaDuration = timelineDuration / clip.speed;
+  if (Math.abs(mediaDuration - expectedMediaDuration) > 0.5) {
+    violations.push({
+      type: "DURATION_MISMATCH",
+      entityId: clip.id,
+      message: `Clip '${clip.id}': mediaDuration (${mediaDuration}) \u2260 timelineDuration/speed (${expectedMediaDuration.toFixed(2)}).`
+    });
+  }
+  if (clip.timelineEnd > state.timeline.duration) {
+    violations.push({
+      type: "CLIP_BEYOND_TIMELINE",
+      entityId: clip.id,
+      message: `Clip '${clip.id}': timelineEnd (${clip.timelineEnd}) exceeds timeline duration (${state.timeline.duration}).`
+    });
+  }
+  if (clip.speed <= 0) {
+    violations.push({
+      type: "SPEED_INVALID",
+      entityId: clip.id,
+      message: `Clip '${clip.id}': speed (${clip.speed}) must be > 0.`
+    });
+  }
+  checkEffects(clip, violations);
+  checkTransitions(clip, state, violations);
+}
+function checkEffects(clip, violations) {
+  const effects = clip.effects ?? [];
+  const validStages = ["preComposite", "postComposite", "output"];
+  for (const effect of effects) {
+    if (!validStages.includes(effect.renderStage)) {
+      violations.push({
+        type: "INVALID_RENDER_STAGE",
+        entityId: effect.id,
+        message: `Effect '${effect.id}': renderStage '${effect.renderStage}' is invalid.`
+      });
+    }
+    const kfs = effect.keyframes;
+    for (let i = 1; i < kfs.length; i++) {
+      const prev = kfs[i - 1];
+      const curr = kfs[i];
+      if (prev.frame > curr.frame || prev.frame === curr.frame) {
+        violations.push({
+          type: "KEYFRAME_ORDER_VIOLATION",
+          entityId: effect.id,
+          message: `Effect '${effect.id}': keyframes must be sorted ascending by frame with no duplicates.`
+        });
+        break;
+      }
+    }
+  }
+}
+function checkMarkerBounds(state, violations) {
+  const dur = state.timeline.duration;
+  for (const m of state.timeline.markers) {
+    if (m.type === "point") {
+      if (m.frame < 0) {
+        violations.push({
+          type: "MARKER_OUT_OF_BOUNDS",
+          entityId: m.id,
+          message: `Point marker '${m.id}' frame (${m.frame}) must be >= 0.`
+        });
+      }
+      if (m.frame >= dur) {
+        violations.push({
+          type: "MARKER_OUT_OF_BOUNDS",
+          entityId: m.id,
+          message: `Point marker '${m.id}' frame (${m.frame}) must be < timeline duration (${dur}).`
+        });
+      }
+    } else {
+      if (m.frameStart < 0) {
+        violations.push({
+          type: "MARKER_OUT_OF_BOUNDS",
+          entityId: m.id,
+          message: `Range marker '${m.id}' frameStart (${m.frameStart}) must be >= 0.`
+        });
+      }
+      if (m.frameStart >= dur) {
+        violations.push({
+          type: "MARKER_OUT_OF_BOUNDS",
+          entityId: m.id,
+          message: `Range marker '${m.id}' frameStart (${m.frameStart}) must be < timeline duration (${dur}).`
+        });
+      }
+      if (m.frameEnd > dur) {
+        violations.push({
+          type: "MARKER_OUT_OF_BOUNDS",
+          entityId: m.id,
+          message: `Range marker '${m.id}' frameEnd (${m.frameEnd}) exceeds timeline duration (${dur}).`
+        });
+      }
+      if (m.frameEnd <= m.frameStart) {
+        violations.push({
+          type: "MARKER_OUT_OF_BOUNDS",
+          entityId: m.id,
+          message: `Range marker '${m.id}' frameEnd must be > frameStart.`
+        });
+      }
+    }
+  }
+}
+function checkInOutPoints(state, violations) {
+  const dur = state.timeline.duration;
+  const inPt = state.timeline.inPoint;
+  const outPt = state.timeline.outPoint;
+  if (inPt !== null && inPt < 0) {
+    violations.push({
+      type: "IN_OUT_INVALID",
+      entityId: "timeline",
+      message: `In point (${inPt}) must be >= 0.`
+    });
+  }
+  if (outPt !== null && outPt > dur) {
+    violations.push({
+      type: "IN_OUT_INVALID",
+      entityId: "timeline",
+      message: `Out point (${outPt}) must be <= timeline duration (${dur}).`
+    });
+  }
+  if (inPt !== null && outPt !== null && inPt >= outPt) {
+    violations.push({
+      type: "IN_OUT_INVALID",
+      entityId: "timeline",
+      message: `In point (${inPt}) must be < out point (${outPt}).`
+    });
+  }
+}
+function checkBeatGrid(state, violations) {
+  const bg = state.timeline.beatGrid;
+  if (bg === null) return;
+  if (bg.bpm <= 0) {
+    violations.push({
+      type: "BEAT_GRID_INVALID",
+      entityId: "timeline",
+      message: `Beat grid bpm (${bg.bpm}) must be > 0.`
+    });
+  }
+  if (bg.timeSignature[0] <= 0 || bg.timeSignature[1] <= 0) {
+    violations.push({
+      type: "BEAT_GRID_INVALID",
+      entityId: "timeline",
+      message: `Beat grid timeSignature must be positive.`
+    });
+  }
+}
+function checkCaptionBounds(state, track, violations) {
+  const dur = state.timeline.duration;
+  for (const cap of track.captions) {
+    if (cap.endFrame > dur) {
+      violations.push({
+        type: "CAPTION_OUT_OF_BOUNDS",
+        entityId: cap.id,
+        message: `Caption '${cap.id}' endFrame (${cap.endFrame}) exceeds timeline duration (${dur}).`
+      });
+    }
+    if (cap.endFrame <= cap.startFrame) {
+      violations.push({
+        type: "CAPTION_OUT_OF_BOUNDS",
+        entityId: cap.id,
+        message: `Caption '${cap.id}' endFrame must be > startFrame.`
+      });
+    }
+  }
+  const byStart = [...track.captions].sort((a, b) => a.startFrame - b.startFrame);
+  for (let i = 0; i < byStart.length - 1; i++) {
+    const a = byStart[i];
+    const b = byStart[i + 1];
+    if (a.endFrame > b.startFrame) {
+      violations.push({
+        type: "CAPTION_OVERLAP",
+        entityId: track.id,
+        message: `Captions '${a.id}' and '${b.id}' overlap on track '${track.id}'.`
+      });
+    }
+  }
+}
+var VALID_TRANSITION_ALIGNMENTS = ["centerOnCut", "endAtCut", "startAtCut"];
+function checkTransitions(clip, state, violations) {
+  const trans = clip.transition;
+  if (!trans) return;
+  if (trans.durationFrames <= 0) {
+    violations.push({
+      type: "INVALID_RANGE",
+      entityId: clip.id,
+      message: `Clip '${clip.id}' transition durationFrames (${trans.durationFrames}) must be > 0.`
+    });
+  }
+  if (!VALID_TRANSITION_ALIGNMENTS.includes(trans.alignment)) {
+    violations.push({
+      type: "INVALID_RANGE",
+      entityId: clip.id,
+      message: `Clip '${clip.id}' transition alignment '${trans.alignment}' is invalid.`
+    });
+  }
+}
+function checkLinkGroups(state, violations) {
+  const groups = state.timeline.linkGroups ?? [];
+  const clipIdsInGroups = /* @__PURE__ */ new Map();
+  for (const g of groups) {
+    if (g.clipIds.length < 2) {
+      violations.push({
+        type: "INVALID_RANGE",
+        entityId: g.id,
+        message: `Link group '${g.id}' must have at least 2 clipIds.`
+      });
+    }
+    for (const cid of g.clipIds) {
+      const clip = findClipInState(state, cid);
+      if (!clip) {
+        violations.push({
+          type: "LINK_GROUP_NOT_FOUND",
+          entityId: g.id,
+          message: `Link group '${g.id}' references non-existent clip '${cid}'.`
+        });
+      }
+      const count = (clipIdsInGroups.get(cid) ?? 0) + 1;
+      clipIdsInGroups.set(cid, count);
+    }
+  }
+  for (const [cid, count] of clipIdsInGroups) {
+    if (count > 1) {
+      violations.push({
+        type: "INVALID_RANGE",
+        entityId: cid,
+        message: `Clip '${cid}' appears in more than one link group.`
+      });
+    }
+  }
+}
+function checkTrackGroups(state, violations) {
+  const groups = state.timeline.trackGroups ?? [];
+  const groupIds = new Set(groups.map((g) => g.id));
+  for (const g of groups) {
+    for (const tid of g.trackIds) {
+      if (!state.timeline.tracks.some((t) => t.id === tid)) {
+        violations.push({
+          type: "TRACK_GROUP_NOT_FOUND",
+          entityId: g.id,
+          message: `Track group '${g.id}' references non-existent track '${tid}'.`
+        });
+      }
+    }
+  }
+  for (const track of state.timeline.tracks) {
+    const gid = track.groupId;
+    if (gid !== void 0 && !groupIds.has(gid)) {
+      violations.push({
+        type: "TRACK_GROUP_NOT_FOUND",
+        entityId: track.id,
+        message: `Track '${track.id}' has groupId '${gid}' which does not exist.`
+      });
+    }
+  }
+}
+function findClipInState(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;
+}
+
+// src/engine/apply.ts
+function applyOperation2(state, op) {
+  switch (op.type) {
+    // — Clip operations ——————————————————————————————————————————————————
+    case "INSERT_CLIP": {
+      return updateTrack2(
+        state,
+        op.trackId,
+        (track) => sortTrackClips({ ...track, clips: [...track.clips, op.clip] })
+      );
+    }
+    case "DELETE_CLIP": {
+      return updateTrackOfClip(state, op.clipId, (track) => ({
+        ...track,
+        clips: track.clips.filter((c) => c.id !== op.clipId)
+      }));
+    }
+    case "MOVE_CLIP": {
+      const targetTrackId = op.targetTrackId;
+      let foundClip;
+      for (const track of state.timeline.tracks) {
+        const c = track.clips.find((c2) => c2.id === op.clipId);
+        if (c) {
+          foundClip = c;
+          break;
+        }
+      }
+      if (!foundClip) return state;
+      const delta = op.newTimelineStart - foundClip.timelineStart;
+      const movedClip = {
+        ...foundClip,
+        trackId: targetTrackId ?? foundClip.trackId,
+        timelineStart: op.newTimelineStart,
+        timelineEnd: foundClip.timelineEnd + delta
+      };
+      const effectiveTargetTrackId = targetTrackId ?? foundClip.trackId;
+      const isCrossTrack = effectiveTargetTrackId !== foundClip.trackId;
+      let stateWithMovedClip;
+      if (!isCrossTrack) {
+        stateWithMovedClip = updateClip2(state, op.clipId, () => movedClip);
+      } else {
+        const newTracks = state.timeline.tracks.map((track) => {
+          if (track.id === foundClip.trackId) {
+            return { ...track, clips: track.clips.filter((c) => c.id !== op.clipId) };
+          }
+          if (track.id === effectiveTargetTrackId) {
+            return sortTrackClips({ ...track, clips: [...track.clips, movedClip] });
+          }
+          return track;
+        });
+        stateWithMovedClip = { ...state, timeline: { ...state.timeline, tracks: newTracks } };
+      }
+      const shiftedMarkers = shiftLinkedMarkers(
+        stateWithMovedClip.timeline.markers,
+        op.clipId,
+        delta
+      );
+      return {
+        ...stateWithMovedClip,
+        timeline: { ...stateWithMovedClip.timeline, markers: shiftedMarkers }
+      };
+    }
+    case "RESIZE_CLIP": {
+      return updateClip2(state, op.clipId, (clip) => {
+        if (op.edge === "start") {
+          const delta = op.newFrame - clip.timelineStart;
+          return {
+            ...clip,
+            timelineStart: op.newFrame,
+            mediaIn: clip.mediaIn + delta
+          };
+        } else {
+          const delta = op.newFrame - clip.timelineEnd;
+          return {
+            ...clip,
+            timelineEnd: op.newFrame,
+            mediaOut: clip.mediaOut + delta
+          };
+        }
+      });
+    }
+    case "SLICE_CLIP": {
+      return state;
+    }
+    case "SET_MEDIA_BOUNDS": {
+      return updateClip2(state, op.clipId, (clip) => ({
+        ...clip,
+        mediaIn: op.mediaIn,
+        mediaOut: op.mediaOut
+      }));
+    }
+    case "SET_CLIP_ENABLED": {
+      return updateClip2(state, op.clipId, (clip) => ({ ...clip, enabled: op.enabled }));
+    }
+    case "SET_CLIP_REVERSED": {
+      return updateClip2(state, op.clipId, (clip) => ({ ...clip, reversed: op.reversed }));
+    }
+    case "SET_CLIP_SPEED": {
+      return updateClip2(state, op.clipId, (clip) => ({ ...clip, speed: op.speed }));
+    }
+    case "SET_CLIP_COLOR": {
+      return updateClip2(state, op.clipId, (clip) => ({ ...clip, color: op.color }));
+    }
+    case "SET_CLIP_NAME": {
+      return updateClip2(state, op.clipId, (clip) => ({ ...clip, name: op.name }));
+    }
+    // — Track operations ——————————————————————————————————————————————————
+    case "ADD_TRACK": {
+      return {
+        ...state,
+        timeline: {
+          ...state.timeline,
+          tracks: [...state.timeline.tracks, op.track]
+        }
+      };
+    }
+    case "DELETE_TRACK": {
+      return {
+        ...state,
+        timeline: {
+          ...state.timeline,
+          tracks: state.timeline.tracks.filter((t) => t.id !== op.trackId)
+        }
+      };
+    }
+    case "REORDER_TRACK": {
+      const tracks = [...state.timeline.tracks];
+      const idx = tracks.findIndex((t) => t.id === op.trackId);
+      if (idx === -1) return state;
+      const [track] = tracks.splice(idx, 1);
+      if (!track) return state;
+      tracks.splice(op.newIndex, 0, track);
+      return { ...state, timeline: { ...state.timeline, tracks } };
+    }
+    case "SET_TRACK_HEIGHT": {
+      return updateTrack2(state, op.trackId, (t) => ({ ...t, height: op.height }));
+    }
+    case "SET_TRACK_NAME": {
+      return updateTrack2(state, op.trackId, (t) => ({ ...t, name: op.name }));
+    }
+    // — Asset operations ——————————————————————————————————————————————————
+    case "REGISTER_ASSET": {
+      const next = new Map(state.assetRegistry);
+      next.set(op.asset.id, op.asset);
+      return { ...state, assetRegistry: next };
+    }
+    case "UNREGISTER_ASSET": {
+      const next = new Map(state.assetRegistry);
+      next.delete(op.assetId);
+      return { ...state, assetRegistry: next };
+    }
+    case "SET_ASSET_STATUS": {
+      const asset = state.assetRegistry.get(op.assetId);
+      if (!asset) return state;
+      const next = new Map(state.assetRegistry);
+      next.set(op.assetId, { ...asset, status: op.status });
+      return { ...state, assetRegistry: next };
+    }
+    // — Timeline operations ———————————————————————————————————————————————
+    case "RENAME_TIMELINE": {
+      return { ...state, timeline: { ...state.timeline, name: op.name } };
+    }
+    case "SET_TIMELINE_DURATION": {
+      return { ...state, timeline: { ...state.timeline, duration: op.duration } };
+    }
+    case "SET_TIMELINE_START_TC": {
+      return { ...state, timeline: { ...state.timeline, startTimecode: op.startTimecode } };
+    }
+    case "SET_SEQUENCE_SETTINGS": {
+      return {
+        ...state,
+        timeline: {
+          ...state.timeline,
+          sequenceSettings: { ...state.timeline.sequenceSettings, ...op.settings }
+        }
+      };
+    }
+    // — Phase 3: Marker operations ————————————————————————————————————————
+    case "ADD_MARKER": {
+      const markers = [...state.timeline.markers, op.marker].sort(sortMarkersByAnchor);
+      return { ...state, timeline: { ...state.timeline, markers } };
+    }
+    case "MOVE_MARKER": {
+      const marker = state.timeline.markers.find((m) => m.id === op.markerId);
+      if (!marker) return state;
+      const updated = marker.type === "point" ? { ...marker, frame: op.newFrame } : {
+        ...marker,
+        frameStart: op.newFrame,
+        frameEnd: op.newFrame + (marker.frameEnd - marker.frameStart)
+      };
+      const markers = state.timeline.markers.map((m) => m.id === op.markerId ? updated : m).sort(sortMarkersByAnchor);
+      return { ...state, timeline: { ...state.timeline, markers } };
+    }
+    case "DELETE_MARKER": {
+      const markers = state.timeline.markers.filter((m) => m.id !== op.markerId);
+      return { ...state, timeline: { ...state.timeline, markers } };
+    }
+    case "SET_IN_POINT": {
+      return { ...state, timeline: { ...state.timeline, inPoint: op.frame } };
+    }
+    case "SET_OUT_POINT": {
+      return { ...state, timeline: { ...state.timeline, outPoint: op.frame } };
+    }
+    case "ADD_BEAT_GRID": {
+      return { ...state, timeline: { ...state.timeline, beatGrid: op.beatGrid } };
+    }
+    case "REMOVE_BEAT_GRID": {
+      return { ...state, timeline: { ...state.timeline, beatGrid: null } };
+    }
+    case "INSERT_GENERATOR": {
+      const track = state.timeline.tracks.find((t) => t.id === op.trackId);
+      if (!track) return state;
+      const genAsset = createGeneratorAsset({
+        id: op.generator.id,
+        name: op.generator.name,
+        mediaType: track.type,
+        generatorDef: op.generator,
+        nativeFps: state.timeline.fps
+      });
+      const clip = createClip({
+        id: `gen-clip-${op.generator.id}`,
+        assetId: genAsset.id,
+        trackId: op.trackId,
+        timelineStart: op.atFrame,
+        timelineEnd: op.atFrame + op.generator.duration,
+        mediaIn: 0,
+        mediaOut: op.generator.duration
+      });
+      const nextRegistry = new Map(state.assetRegistry);
+      nextRegistry.set(genAsset.id, genAsset);
+      return updateTrack2(
+        { ...state, assetRegistry: nextRegistry },
+        op.trackId,
+        (t) => sortTrackClips({ ...t, clips: [...t.clips, clip] })
+      );
+    }
+    case "ADD_CAPTION": {
+      const captionToAdd = {
+        ...op.caption,
+        style: op.caption.style ?? defaultCaptionStyle
+      };
+      return updateTrack2(state, op.trackId, (track) => {
+        const captions = [...track.captions, captionToAdd].sort(
+          (a, b) => a.startFrame - b.startFrame
+        );
+        return { ...track, captions };
+      });
+    }
+    case "EDIT_CAPTION": {
+      return updateTrack2(state, op.trackId, (track) => {
+        const cap = track.captions.find((c) => c.id === op.captionId);
+        if (!cap) return track;
+        const updated = {
+          ...cap,
+          ...op.text !== void 0 && { text: op.text },
+          ...op.language !== void 0 && { language: op.language },
+          ...op.style !== void 0 && { style: { ...cap.style, ...op.style } },
+          ...op.burnIn !== void 0 && { burnIn: op.burnIn },
+          ...op.startFrame !== void 0 && { startFrame: op.startFrame },
+          ...op.endFrame !== void 0 && { endFrame: op.endFrame }
+        };
+        const captions = track.captions.map((c) => c.id === op.captionId ? updated : c).sort((a, b) => a.startFrame - b.startFrame);
+        return { ...track, captions };
+      });
+    }
+    case "DELETE_CAPTION": {
+      return updateTrack2(state, op.trackId, (track) => ({
+        ...track,
+        captions: track.captions.filter((c) => c.id !== op.captionId)
+      }));
+    }
+    // — Phase 4: Effect & Keyframe ————————————————————————————————————————
+    case "ADD_EFFECT": {
+      return updateClipEffects(state, op.clipId, (effects) => [...effects, op.effect]);
+    }
+    case "REMOVE_EFFECT": {
+      return updateClipEffects(
+        state,
+        op.clipId,
+        (effects) => effects.filter((e) => e.id !== op.effectId)
+      );
+    }
+    case "REORDER_EFFECT": {
+      return updateClipEffects(state, op.clipId, (effects) => {
+        const idx = effects.findIndex((e) => e.id === op.effectId);
+        if (idx < 0) return effects;
+        const arr = [...effects];
+        const [removed] = arr.splice(idx, 1);
+        if (!removed) return effects;
+        arr.splice(op.newIndex, 0, removed);
+        return arr;
+      });
+    }
+    case "SET_EFFECT_ENABLED": {
+      return updateClipEffects(
+        state,
+        op.clipId,
+        (effects) => effects.map((e) => e.id === op.effectId ? { ...e, enabled: op.enabled } : e)
+      );
+    }
+    case "SET_EFFECT_PARAM": {
+      return updateClipEffects(
+        state,
+        op.clipId,
+        (effects) => effects.map((e) => {
+          if (e.id !== op.effectId) return e;
+          const idx = e.params.findIndex((p) => p.key === op.key);
+          const newParams = idx >= 0 ? e.params.map((p, i) => i === idx ? { key: op.key, value: op.value } : p) : [...e.params, { key: op.key, value: op.value }];
+          return { ...e, params: newParams };
+        })
+      );
+    }
+    case "ADD_KEYFRAME": {
+      return updateClipEffects(
+        state,
+        op.clipId,
+        (effects) => effects.map((e) => {
+          if (e.id !== op.effectId) return e;
+          const keyframes = [...e.keyframes, op.keyframe].sort((a, b) => a.frame - b.frame);
+          return { ...e, keyframes };
+        })
+      );
+    }
+    case "MOVE_KEYFRAME": {
+      return updateClipEffects(
+        state,
+        op.clipId,
+        (effects) => effects.map((e) => {
+          if (e.id !== op.effectId) return e;
+          const keyframes = e.keyframes.map((k) => k.id === op.keyframeId ? { ...k, frame: op.newFrame } : k).sort((a, b) => a.frame - b.frame);
+          return { ...e, keyframes };
+        })
+      );
+    }
+    case "DELETE_KEYFRAME": {
+      return updateClipEffects(
+        state,
+        op.clipId,
+        (effects) => effects.map(
+          (e) => e.id === op.effectId ? { ...e, keyframes: e.keyframes.filter((k) => k.id !== op.keyframeId) } : e
+        )
+      );
+    }
+    case "SET_KEYFRAME_EASING": {
+      return updateClipEffects(
+        state,
+        op.clipId,
+        (effects) => effects.map((e) => ({
+          ...e,
+          keyframes: e.keyframes.map(
+            (k) => k.id === op.keyframeId ? { ...k, easing: op.easing } : k
+          )
+        }))
+      );
+    }
+    // — Phase 4 Step 3: Transform, Audio, Transitions, Groups ———————————————
+    case "SET_CLIP_TRANSFORM": {
+      return updateClip2(state, op.clipId, (clip) => {
+        const base = clip.transform ?? DEFAULT_CLIP_TRANSFORM;
+        const p = op.transform;
+        const merged = {
+          positionX: p.positionX ?? base.positionX,
+          positionY: p.positionY ?? base.positionY,
+          scaleX: p.scaleX ?? base.scaleX,
+          scaleY: p.scaleY ?? base.scaleY,
+          rotation: p.rotation ?? base.rotation,
+          opacity: p.opacity ?? base.opacity,
+          anchorX: p.anchorX ?? base.anchorX,
+          anchorY: p.anchorY ?? base.anchorY
+        };
+        return { ...clip, transform: merged };
+      });
+    }
+    case "SET_AUDIO_PROPERTIES": {
+      return updateClip2(state, op.clipId, (clip) => {
+        const base = clip.audio ?? DEFAULT_AUDIO_PROPERTIES;
+        const merged = { ...base, ...op.properties };
+        return { ...clip, audio: merged };
+      });
+    }
+    case "ADD_TRANSITION": {
+      return updateClip2(state, op.clipId, (clip) => ({ ...clip, transition: op.transition }));
+    }
+    case "DELETE_TRANSITION": {
+      return updateClip2(state, op.clipId, (clip) => {
+        const { transition: _, ...rest } = clip;
+        return rest;
+      });
+    }
+    case "SET_TRANSITION_DURATION": {
+      return updateClip2(state, op.clipId, (clip) => {
+        if (!clip.transition) return clip;
+        return { ...clip, transition: { ...clip.transition, durationFrames: op.durationFrames } };
+      });
+    }
+    case "SET_TRANSITION_ALIGNMENT": {
+      return updateClip2(state, op.clipId, (clip) => {
+        if (!clip.transition) return clip;
+        return { ...clip, transition: { ...clip.transition, alignment: op.alignment } };
+      });
+    }
+    case "LINK_CLIPS": {
+      const linkGroups = [...state.timeline.linkGroups ?? [], op.linkGroup];
+      return { ...state, timeline: { ...state.timeline, linkGroups } };
+    }
+    case "UNLINK_CLIPS": {
+      const linkGroups = (state.timeline.linkGroups ?? []).filter((g) => g.id !== op.linkGroupId);
+      return { ...state, timeline: { ...state.timeline, linkGroups } };
+    }
+    case "ADD_TRACK_GROUP": {
+      const trackGroups = [...state.timeline.trackGroups ?? [], op.trackGroup];
+      const tracks = state.timeline.tracks.map(
+        (t) => op.trackGroup.trackIds.some((id) => id === t.id) ? { ...t, groupId: op.trackGroup.id } : t
+      );
+      return {
+        ...state,
+        timeline: { ...state.timeline, trackGroups, tracks }
+      };
+    }
+    case "DELETE_TRACK_GROUP": {
+      const trackGroups = (state.timeline.trackGroups ?? []).filter((g) => g.id !== op.trackGroupId);
+      const tracks = state.timeline.tracks.map((t) => {
+        if (t.groupId !== op.trackGroupId) return t;
+        const { groupId: _, ...rest } = t;
+        return rest;
+      });
+      return {
+        ...state,
+        timeline: { ...state.timeline, trackGroups, tracks }
+      };
+    }
+    case "SET_TRACK_BLEND_MODE": {
+      return updateTrack2(state, op.trackId, (t) => ({ ...t, blendMode: op.blendMode }));
+    }
+    case "SET_TRACK_OPACITY": {
+      return updateTrack2(state, op.trackId, (t) => ({ ...t, opacity: op.opacity }));
+    }
+  }
+}
+function shiftLinkedMarkers(markers, clipId, delta) {
+  const shifted = markers.map((m) => {
+    if (m.clipId !== clipId) return m;
+    if (m.type === "point") {
+      return { ...m, frame: m.frame + delta };
+    }
+    return {
+      ...m,
+      frameStart: m.frameStart + delta,
+      frameEnd: m.frameEnd + delta
+    };
+  });
+  return [...shifted].sort(sortMarkersByAnchor);
+}
+function sortMarkersByAnchor(a, b) {
+  const anchorA = a.type === "point" ? a.frame : a.frameStart;
+  const anchorB = b.type === "point" ? b.frame : b.frameStart;
+  return anchorA - anchorB;
+}
+function updateClipEffects(state, clipId, fn) {
+  return updateClip2(state, clipId, (clip) => ({
+    ...clip,
+    effects: fn(clip.effects ?? [])
+  }));
+}
+function updateTrack2(state, trackId, fn) {
+  return {
+    ...state,
+    timeline: {
+      ...state.timeline,
+      tracks: state.timeline.tracks.map((t) => t.id === trackId ? fn(t) : t)
+    }
+  };
+}
+function updateTrackOfClip(state, clipId, fn) {
+  return {
+    ...state,
+    timeline: {
+      ...state.timeline,
+      tracks: state.timeline.tracks.map(
+        (t) => t.clips.some((c) => c.id === clipId) ? fn(t) : t
+      )
+    }
+  };
+}
+function updateClip2(state, clipId, fn) {
+  return {
+    ...state,
+    timeline: {
+      ...state.timeline,
+      tracks: state.timeline.tracks.map((track) => {
+        if (!track.clips.some((c) => c.id === clipId)) return track;
+        const updatedTrack = {
+          ...track,
+          clips: track.clips.map((c) => c.id === clipId ? fn(c) : c)
+        };
+        return sortTrackClips(updatedTrack);
+      })
+    }
+  };
+}
+
+// src/validation/validators.ts
+function validateOperation(state, op) {
+  switch (op.type) {
+    case "MOVE_CLIP":
+      return validateMoveClip(state, op);
+    case "RESIZE_CLIP":
+      return validateResizeClip(state, op);
+    case "SLICE_CLIP":
+      return validateSliceClip(state, op);
+    case "DELETE_CLIP":
+      return validateDeleteClip(state, op);
+    case "INSERT_CLIP":
+      return validateInsertClip(state, op);
+    case "SET_MEDIA_BOUNDS":
+      return validateSetMediaBounds(state, op);
+    case "SET_CLIP_SPEED":
+      return validateSetClipSpeed(state, op);
+    case "ADD_TRACK":
+      return validateAddTrack(state, op);
+    case "DELETE_TRACK":
+      return validateDeleteTrack(state, op);
+    case "UNREGISTER_ASSET":
+      return validateUnregisterAsset(state, op);
+    case "ADD_MARKER":
+      return validateAddMarker(state, op);
+    case "MOVE_MARKER":
+      return validateMoveMarker(state, op);
+    case "DELETE_MARKER":
+      return validateDeleteMarker(state, op);
+    case "SET_IN_POINT":
+      return validateSetInPoint(state, op);
+    case "SET_OUT_POINT":
+      return validateSetOutPoint(state, op);
+    case "ADD_BEAT_GRID":
+      return validateAddBeatGrid(state, op);
+    case "REMOVE_BEAT_GRID":
+      return validateRemoveBeatGrid(state, op);
+    case "INSERT_GENERATOR":
+      return validateInsertGenerator(state, op);
+    case "ADD_CAPTION":
+      return validateAddCaption(state, op);
+    case "EDIT_CAPTION":
+      return validateEditCaption(state, op);
+    case "DELETE_CAPTION":
+      return validateDeleteCaption(state, op);
+    case "ADD_EFFECT":
+      return validateAddEffect(state, op);
+    case "REMOVE_EFFECT":
+      return validateRemoveEffect(state, op);
+    case "REORDER_EFFECT":
+      return validateReorderEffect(state, op);
+    case "SET_EFFECT_ENABLED":
+      return validateSetEffectEnabled(state, op);
+    case "SET_EFFECT_PARAM":
+      return validateSetEffectParam(state, op);
+    case "ADD_KEYFRAME":
+      return validateAddKeyframe(state, op);
+    case "MOVE_KEYFRAME":
+      return validateMoveKeyframe(state, op);
+    case "DELETE_KEYFRAME":
+      return validateDeleteKeyframe(state, op);
+    case "SET_KEYFRAME_EASING":
+      return validateSetKeyframeEasing(state, op);
+    case "SET_CLIP_TRANSFORM":
+      return validateSetClipTransform(state, op);
+    case "SET_AUDIO_PROPERTIES":
+      return validateSetAudioProperties(state, op);
+    case "ADD_TRANSITION":
+      return validateAddTransition(state, op);
+    case "DELETE_TRANSITION":
+      return validateDeleteTransition(state, op);
+    case "SET_TRANSITION_DURATION":
+      return validateSetTransitionDuration(state, op);
+    case "SET_TRANSITION_ALIGNMENT":
+      return validateSetTransitionAlignment(state, op);
+    case "LINK_CLIPS":
+      return validateLinkClips(state, op);
+    case "UNLINK_CLIPS":
+      return validateUnlinkClips(state, op);
+    case "ADD_TRACK_GROUP":
+      return validateAddTrackGroup(state, op);
+    case "DELETE_TRACK_GROUP":
+      return validateDeleteTrackGroup(state, op);
+    case "SET_TRACK_BLEND_MODE":
+      return validateSetTrackBlendMode(state, op);
+    case "SET_TRACK_OPACITY":
+      return validateSetTrackOpacity(state, op);
+    default:
+      return null;
+  }
+}
+function validateMoveClip(state, op) {
+  const clip = findClip(state, op.clipId);
+  if (!clip) return { reason: "ASSET_MISSING", message: `Clip '${op.clipId}' not found.` };
+  const targetTrackId = op.targetTrackId ?? clip.trackId;
+  const track = state.timeline.tracks.find((t) => t.id === targetTrackId);
+  if (!track) return { reason: "OUT_OF_BOUNDS", message: `Track '${targetTrackId}' not found.` };
+  if (track.locked) return { reason: "LOCKED_TRACK", message: `Track '${targetTrackId}' is locked.` };
+  const duration = clip.timelineEnd - clip.timelineStart;
+  const newEnd = op.newTimelineStart + duration;
+  if (op.newTimelineStart < 0 || newEnd > state.timeline.duration) {
+    return { reason: "OUT_OF_BOUNDS", message: `MOVE_CLIP would place clip '${op.clipId}' outside timeline bounds.` };
+  }
+  for (const existing of track.clips) {
+    if (existing.id === op.clipId) continue;
+    const overlaps = op.newTimelineStart < existing.timelineEnd && newEnd > existing.timelineStart;
+    if (overlaps) {
+      return { reason: "OVERLAP", message: `Clip '${op.clipId}' would overlap '${existing.id}' on track '${targetTrackId}'.` };
+    }
+  }
+  return null;
+}
+function validateResizeClip(state, op) {
+  const clip = findClip(state, op.clipId);
+  if (!clip) return { reason: "ASSET_MISSING", message: `Clip '${op.clipId}' not found.` };
+  if (op.edge === "start" && op.newFrame >= clip.timelineEnd) {
+    return { reason: "OUT_OF_BOUNDS", message: `RESIZE_CLIP start edge must be < timelineEnd.` };
+  }
+  if (op.edge === "end" && op.newFrame <= clip.timelineStart) {
+    return { reason: "OUT_OF_BOUNDS", message: `RESIZE_CLIP end edge must be > timelineStart.` };
+  }
+  return null;
+}
+function validateSliceClip(state, op) {
+  const clip = findClip(state, op.clipId);
+  if (!clip) return { reason: "ASSET_MISSING", message: `Clip '${op.clipId}' not found.` };
+  if (op.atFrame <= clip.timelineStart || op.atFrame >= clip.timelineEnd) {
+    return { reason: "OUT_OF_BOUNDS", message: `SLICE_CLIP atFrame must be strictly inside the clip bounds.` };
+  }
+  return null;
+}
+function validateDeleteClip(state, op) {
+  const clip = findClip(state, op.clipId);
+  if (!clip) return { reason: "ASSET_MISSING", message: `Clip '${op.clipId}' not found.` };
+  const track = state.timeline.tracks.find((t) => t.id === clip.trackId);
+  if (track?.locked) return { reason: "LOCKED_TRACK", message: `Track '${clip.trackId}' is locked.` };
+  return null;
+}
+function validateInsertClip(state, op) {
+  const track = state.timeline.tracks.find((t) => t.id === op.trackId);
+  if (!track) return { reason: "OUT_OF_BOUNDS", message: `Track '${op.trackId}' not found.` };
+  if (track.locked) return { reason: "LOCKED_TRACK", message: `Track '${op.trackId}' is locked.` };
+  const asset = state.assetRegistry.get(op.clip.assetId);
+  if (!asset) return { reason: "ASSET_MISSING", message: `Asset '${op.clip.assetId}' not in registry.` };
+  if (asset.mediaType !== track.type) return { reason: "TYPE_MISMATCH", message: `Asset mediaType '${asset.mediaType}' \u2260 track type '${track.type}'.` };
+  for (const existing of track.clips) {
+    const overlaps = op.clip.timelineStart < existing.timelineEnd && op.clip.timelineEnd > existing.timelineStart;
+    if (overlaps) {
+      return { reason: "OVERLAP", message: `INSERT_CLIP would overlap '${existing.id}'.` };
+    }
+  }
+  return null;
+}
+function validateSetMediaBounds(state, op) {
+  const clip = findClip(state, op.clipId);
+  if (!clip) return { reason: "ASSET_MISSING", message: `Clip '${op.clipId}' not found.` };
+  const asset = state.assetRegistry.get(clip.assetId);
+  if (!asset) return { reason: "ASSET_MISSING", message: `Asset '${clip.assetId}' not found.` };
+  if (op.mediaIn < 0) return { reason: "MEDIA_BOUNDS_INVALID", message: `mediaIn must be >= 0.` };
+  if (op.mediaOut > asset.intrinsicDuration) {
+    return { reason: "MEDIA_BOUNDS_INVALID", message: `mediaOut (${op.mediaOut}) exceeds asset intrinsicDuration (${asset.intrinsicDuration}).` };
+  }
+  return null;
+}
+function validateSetClipSpeed(_state, op) {
+  if (op.speed <= 0) return { reason: "SPEED_INVALID", message: `speed must be > 0, got ${op.speed}.` };
+  return null;
+}
+function validateAddTrack(state, op) {
+  if (state.timeline.tracks.some((t) => t.id === op.track.id)) {
+    return { reason: "OVERLAP", message: `Track '${op.track.id}' already exists.` };
+  }
+  return null;
+}
+function validateDeleteTrack(state, op) {
+  const track = state.timeline.tracks.find((t) => t.id === op.trackId);
+  if (!track) return { reason: "OUT_OF_BOUNDS", message: `Track '${op.trackId}' not found.` };
+  if (track.clips.length > 0) return { reason: "TRACK_NOT_EMPTY", message: `Cannot delete track '${op.trackId}': it has ${track.clips.length} clips. Delete all clips first.` };
+  return null;
+}
+function validateUnregisterAsset(state, op) {
+  for (const track of state.timeline.tracks) {
+    for (const clip of track.clips) {
+      if (clip.assetId === op.assetId) {
+        return { reason: "ASSET_IN_USE", message: `Asset '${op.assetId}' is referenced by clip '${clip.id}'.` };
+      }
+    }
+  }
+  return null;
+}
+function validateAddMarker(state, op) {
+  const { marker } = op;
+  if (state.timeline.markers.some((m) => m.id === marker.id)) {
+    return { reason: "OUT_OF_BOUNDS", message: `Marker '${marker.id}' already exists.` };
+  }
+  if (marker.clipId != null) {
+    const clip = findClip(state, marker.clipId);
+    if (!clip) {
+      return { reason: "NOT_FOUND", message: `Clip '${marker.clipId}' not found.` };
+    }
+  }
+  const dur = state.timeline.duration;
+  if (marker.type === "point") {
+    if (marker.frame < 0 || marker.frame > dur) {
+      return { reason: "OUT_OF_BOUNDS", message: `Point marker frame (${marker.frame}) must be in [0, ${dur}].` };
+    }
+  } else {
+    if (marker.frameStart >= marker.frameEnd) {
+      return { reason: "OUT_OF_BOUNDS", message: `Range marker frameStart must be < frameEnd.` };
+    }
+    if (marker.frameEnd > dur) {
+      return { reason: "OUT_OF_BOUNDS", message: `Range marker frameEnd (${marker.frameEnd}) exceeds timeline duration (${dur}).` };
+    }
+  }
+  return null;
+}
+function validateMoveMarker(state, op) {
+  const marker = findMarker(state, op.markerId);
+  if (!marker) return { reason: "NOT_FOUND", message: `Marker '${op.markerId}' not found.` };
+  const dur = state.timeline.duration;
+  if (marker.type === "point") {
+    if (op.newFrame < 0 || op.newFrame > dur) {
+      return { reason: "OUT_OF_BOUNDS", message: `newFrame (${op.newFrame}) must be in [0, ${dur}].` };
+    }
+  } else {
+    const duration = marker.frameEnd - marker.frameStart;
+    const newEnd = op.newFrame + duration;
+    if (op.newFrame < 0 || newEnd > dur) {
+      return { reason: "OUT_OF_BOUNDS", message: `MOVE_MARKER would place range marker outside timeline.` };
+    }
+  }
+  return null;
+}
+function validateDeleteMarker(state, op) {
+  if (!findMarker(state, op.markerId)) {
+    return { reason: "NOT_FOUND", message: `Marker '${op.markerId}' not found.` };
+  }
+  return null;
+}
+function validateSetInPoint(state, op) {
+  if (op.frame === null) return null;
+  if (op.frame < 0) return { reason: "OUT_OF_BOUNDS", message: `In point frame must be >= 0.` };
+  const out = state.timeline.outPoint;
+  if (out !== null && op.frame >= out) {
+    return { reason: "OUT_OF_BOUNDS", message: `In point must be < out point (${out}).` };
+  }
+  return null;
+}
+function validateSetOutPoint(state, op) {
+  if (op.frame === null) return null;
+  if (op.frame < 0) return { reason: "OUT_OF_BOUNDS", message: `Out point frame must be >= 0.` };
+  const inPt = state.timeline.inPoint;
+  if (inPt !== null && op.frame <= inPt) {
+    return { reason: "OUT_OF_BOUNDS", message: `Out point must be > in point (${inPt}).` };
+  }
+  return null;
+}
+function validateAddBeatGrid(state, op) {
+  if (state.timeline.beatGrid !== null) {
+    return { reason: "BEAT_GRID_EXISTS", message: `Timeline already has a beat grid.` };
+  }
+  const { beatGrid } = op;
+  if (beatGrid.bpm <= 0) return { reason: "OUT_OF_BOUNDS", message: `Beat grid bpm must be > 0.` };
+  if (beatGrid.timeSignature[0] <= 0 || beatGrid.timeSignature[1] <= 0) {
+    return { reason: "OUT_OF_BOUNDS", message: `Beat grid timeSignature must be positive.` };
+  }
+  return null;
+}
+function validateRemoveBeatGrid(_state, _op) {
+  return null;
+}
+function validateInsertGenerator(state, op) {
+  const track = state.timeline.tracks.find((t) => t.id === op.trackId);
+  if (!track) return { reason: "OUT_OF_BOUNDS", message: `Track '${op.trackId}' not found.` };
+  if (track.locked) return { reason: "LOCKED_TRACK", message: `Track '${op.trackId}' is locked.` };
+  if (track.type !== "video" && track.type !== "audio") {
+    return { reason: "TYPE_MISMATCH", message: `INSERT_GENERATOR requires video or audio track.` };
+  }
+  const dur = state.timeline.duration;
+  if (op.atFrame < 0 || op.atFrame + op.generator.duration > dur) {
+    return { reason: "OUT_OF_BOUNDS", message: `INSERT_GENERATOR would place clip outside timeline.` };
+  }
+  for (const c of track.clips) {
+    const overlaps = op.atFrame < c.timelineEnd && op.atFrame + op.generator.duration > c.timelineStart;
+    if (overlaps) return { reason: "OVERLAP", message: `INSERT_GENERATOR would overlap clip '${c.id}'.` };
+  }
+  return null;
+}
+function validateAddCaption(state, op) {
+  const track = state.timeline.tracks.find((t) => t.id === op.trackId);
+  if (!track) return { reason: "OUT_OF_BOUNDS", message: `Track '${op.trackId}' not found.` };
+  if (track.locked) return { reason: "LOCKED_TRACK", message: `Track '${op.trackId}' is locked.` };
+  const { caption } = op;
+  if (caption.startFrame >= caption.endFrame) {
+    return { reason: "OUT_OF_BOUNDS", message: `Caption startFrame must be < endFrame.` };
+  }
+  if (caption.endFrame > state.timeline.duration) {
+    return { reason: "OUT_OF_BOUNDS", message: `Caption endFrame exceeds timeline duration.` };
+  }
+  if (track.captions.some((c) => c.id === caption.id)) {
+    return { reason: "OUT_OF_BOUNDS", message: `Caption '${caption.id}' already on track.` };
+  }
+  const overlaps = track.captions.some(
+    (c) => caption.startFrame < c.endFrame && caption.endFrame > c.startFrame
+  );
+  if (overlaps) {
+    return { reason: "OVERLAP", message: `Caption overlaps an existing caption on track '${op.trackId}'.` };
+  }
+  return null;
+}
+function validateEditCaption(state, op) {
+  const track = state.timeline.tracks.find((t) => t.id === op.trackId);
+  if (!track) return { reason: "NOT_FOUND", message: `Track '${op.trackId}' not found.` };
+  const caption = track.captions.find((c) => c.id === op.captionId);
+  if (!caption) return { reason: "NOT_FOUND", message: `Caption '${op.captionId}' not found on track.` };
+  if (op.startFrame !== void 0 && op.endFrame !== void 0) {
+    if (op.startFrame >= op.endFrame) return { reason: "OUT_OF_BOUNDS", message: `startFrame must be < endFrame.` };
+    if (op.endFrame > state.timeline.duration) return { reason: "OUT_OF_BOUNDS", message: `endFrame exceeds timeline duration.` };
+  } else if (op.startFrame !== void 0) {
+    if (op.startFrame >= caption.endFrame) return { reason: "OUT_OF_BOUNDS", message: `startFrame must be < endFrame.` };
+  } else if (op.endFrame !== void 0) {
+    if (caption.startFrame >= op.endFrame) return { reason: "OUT_OF_BOUNDS", message: `endFrame must be > startFrame.` };
+    if (op.endFrame > state.timeline.duration) return { reason: "OUT_OF_BOUNDS", message: `endFrame exceeds timeline duration.` };
+  }
+  return null;
+}
+function validateDeleteCaption(state, op) {
+  const track = state.timeline.tracks.find((t) => t.id === op.trackId);
+  if (!track) return { reason: "NOT_FOUND", message: `Track '${op.trackId}' not found.` };
+  if (!track.captions.some((c) => c.id === op.captionId)) {
+    return { reason: "NOT_FOUND", message: `Caption '${op.captionId}' not found on track.` };
+  }
+  return null;
+}
+function validateAddEffect(state, op) {
+  const clip = findClip(state, op.clipId);
+  if (!clip) return { reason: "CLIP_NOT_FOUND", message: `Clip '${op.clipId}' not found.` };
+  const effects = clip.effects ?? [];
+  if (effects.some((e) => e.id === op.effect.id)) {
+    return { reason: "DUPLICATE_EFFECT_ID", message: `Effect '${op.effect.id}' already exists on clip '${op.clipId}'.` };
+  }
+  return null;
+}
+function validateRemoveEffect(state, op) {
+  const clip = findClip(state, op.clipId);
+  if (!clip) return { reason: "CLIP_NOT_FOUND", message: `Clip '${op.clipId}' not found.` };
+  const effect = findEffect(clip, op.effectId);
+  if (!effect) return { reason: "EFFECT_NOT_FOUND", message: `Effect '${op.effectId}' not found on clip '${op.clipId}'.` };
+  return null;
+}
+function validateReorderEffect(state, op) {
+  const clip = findClip(state, op.clipId);
+  if (!clip) return { reason: "CLIP_NOT_FOUND", message: `Clip '${op.clipId}' not found.` };
+  const effect = findEffect(clip, op.effectId);
+  if (!effect) return { reason: "EFFECT_NOT_FOUND", message: `Effect '${op.effectId}' not found on clip '${op.clipId}'.` };
+  const effects = clip.effects ?? [];
+  if (op.newIndex < 0 || op.newIndex >= effects.length) {
+    return { reason: "EFFECT_INDEX_OUT_OF_RANGE", message: `newIndex ${op.newIndex} out of range [0, ${effects.length - 1}].` };
+  }
+  return null;
+}
+function validateSetEffectEnabled(state, op) {
+  const clip = findClip(state, op.clipId);
+  if (!clip) return { reason: "CLIP_NOT_FOUND", message: `Clip '${op.clipId}' not found.` };
+  const effect = findEffect(clip, op.effectId);
+  if (!effect) return { reason: "EFFECT_NOT_FOUND", message: `Effect '${op.effectId}' not found on clip '${op.clipId}'.` };
+  return null;
+}
+function validateSetEffectParam(state, op) {
+  const clip = findClip(state, op.clipId);
+  if (!clip) return { reason: "CLIP_NOT_FOUND", message: `Clip '${op.clipId}' not found.` };
+  const effect = findEffect(clip, op.effectId);
+  if (!effect) return { reason: "EFFECT_NOT_FOUND", message: `Effect '${op.effectId}' not found on clip '${op.clipId}'.` };
+  return null;
+}
+function validateAddKeyframe(state, op) {
+  const clip = findClip(state, op.clipId);
+  if (!clip) return { reason: "CLIP_NOT_FOUND", message: `Clip '${op.clipId}' not found.` };
+  const effect = findEffect(clip, op.effectId);
+  if (!effect) return { reason: "EFFECT_NOT_FOUND", message: `Effect '${op.effectId}' not found on clip '${op.clipId}'.` };
+  if (effect.keyframes.some((k) => k.id === op.keyframe.id)) {
+    return { reason: "DUPLICATE_KEYFRAME_ID", message: `Keyframe '${op.keyframe.id}' already exists on effect '${op.effectId}'.` };
+  }
+  if (op.keyframe.frame < 0) {
+    return { reason: "INVALID_RANGE", message: `Keyframe frame (${op.keyframe.frame}) must be >= 0.` };
+  }
+  return null;
+}
+function validateMoveKeyframe(state, op) {
+  const clip = findClip(state, op.clipId);
+  if (!clip) return { reason: "CLIP_NOT_FOUND", message: `Clip '${op.clipId}' not found.` };
+  const effect = findEffect(clip, op.effectId);
+  if (!effect) return { reason: "EFFECT_NOT_FOUND", message: `Effect '${op.effectId}' not found on clip '${op.clipId}'.` };
+  const kf = effect.keyframes.find((k) => k.id === op.keyframeId);
+  if (!kf) return { reason: "KEYFRAME_NOT_FOUND", message: `Keyframe '${op.keyframeId}' not found on effect '${op.effectId}'.` };
+  if (op.newFrame < 0) {
+    return { reason: "INVALID_RANGE", message: `newFrame (${op.newFrame}) must be >= 0.` };
+  }
+  return null;
+}
+function validateDeleteKeyframe(state, op) {
+  const clip = findClip(state, op.clipId);
+  if (!clip) return { reason: "CLIP_NOT_FOUND", message: `Clip '${op.clipId}' not found.` };
+  const effect = findEffect(clip, op.effectId);
+  if (!effect) return { reason: "EFFECT_NOT_FOUND", message: `Effect '${op.effectId}' not found on clip '${op.clipId}'.` };
+  const kf = effect.keyframes.find((k) => k.id === op.keyframeId);
+  if (!kf) return { reason: "KEYFRAME_NOT_FOUND", message: `Keyframe '${op.keyframeId}' not found on effect '${op.effectId}'.` };
+  return null;
+}
+function validateSetKeyframeEasing(state, op) {
+  const clip = findClip(state, op.clipId);
+  if (!clip) return { reason: "CLIP_NOT_FOUND", message: `Clip '${op.clipId}' not found.` };
+  const effect = findEffect(clip, op.effectId);
+  if (!effect) return { reason: "EFFECT_NOT_FOUND", message: `Effect '${op.effectId}' not found on clip '${op.clipId}'.` };
+  const kf = effect.keyframes.find((k) => k.id === op.keyframeId);
+  if (!kf) return { reason: "KEYFRAME_NOT_FOUND", message: `Keyframe '${op.keyframeId}' not found on effect '${op.effectId}'.` };
+  return null;
+}
+function validateSetClipTransform(state, op) {
+  const clip = findClip(state, op.clipId);
+  if (!clip) return { reason: "CLIP_NOT_FOUND", message: `Clip '${op.clipId}' not found.` };
+  return null;
+}
+function validateSetAudioProperties(state, op) {
+  const clip = findClip(state, op.clipId);
+  if (!clip) return { reason: "CLIP_NOT_FOUND", message: `Clip '${op.clipId}' not found.` };
+  const p = op.properties;
+  if (p.pan !== void 0 && typeof p.pan === "object" && p.pan !== null && "value" in p.pan) {
+    const v = p.pan.value;
+    if (v < -1 || v > 1) {
+      return { reason: "INVALID_RANGE", message: `pan must be in [-1, 1].` };
+    }
+  }
+  if (p.normalizationGain !== void 0 && p.normalizationGain < 0) {
+    return { reason: "INVALID_RANGE", message: `normalizationGain must be >= 0.` };
+  }
+  return null;
+}
+function validateAddTransition(state, op) {
+  const clip = findClip(state, op.clipId);
+  if (!clip) return { reason: "CLIP_NOT_FOUND", message: `Clip '${op.clipId}' not found.` };
+  if (op.transition.durationFrames <= 0) {
+    return { reason: "INVALID_RANGE", message: `transition.durationFrames must be > 0.` };
+  }
+  return null;
+}
+function validateDeleteTransition(state, op) {
+  const clip = findClip(state, op.clipId);
+  if (!clip) return { reason: "CLIP_NOT_FOUND", message: `Clip '${op.clipId}' not found.` };
+  if (!clip.transition) {
+    return { reason: "TRANSITION_NOT_FOUND", message: `Clip '${op.clipId}' has no transition to delete.` };
+  }
+  return null;
+}
+function validateSetTransitionDuration(state, op) {
+  const clip = findClip(state, op.clipId);
+  if (!clip) return { reason: "CLIP_NOT_FOUND", message: `Clip '${op.clipId}' not found.` };
+  if (!clip.transition) {
+    return { reason: "TRANSITION_NOT_FOUND", message: `Clip '${op.clipId}' has no transition.` };
+  }
+  if (op.durationFrames <= 0) {
+    return { reason: "INVALID_RANGE", message: `durationFrames must be > 0.` };
+  }
+  return null;
+}
+function validateSetTransitionAlignment(state, op) {
+  const clip = findClip(state, op.clipId);
+  if (!clip) return { reason: "CLIP_NOT_FOUND", message: `Clip '${op.clipId}' not found.` };
+  if (!clip.transition) {
+    return { reason: "TRANSITION_NOT_FOUND", message: `Clip '${op.clipId}' has no transition.` };
+  }
+  return null;
+}
+function validateLinkClips(state, op) {
+  const linkGroup = op.linkGroup;
+  if (!linkGroup.clipIds.length || linkGroup.clipIds.length < 2) {
+    return { reason: "INVALID_RANGE", message: `linkGroup.clipIds must have length >= 2.` };
+  }
+  for (const cid of linkGroup.clipIds) {
+    if (!findClip(state, cid)) {
+      return { reason: "CLIP_NOT_FOUND", message: `Clip '${cid}' not found.` };
+    }
+  }
+  const existing = state.timeline.linkGroups ?? [];
+  if (existing.some((g) => g.id === linkGroup.id)) {
+    return { reason: "DUPLICATE_LINK_GROUP_ID", message: `Link group '${linkGroup.id}' already exists.` };
+  }
+  return null;
+}
+function validateUnlinkClips(state, op) {
+  const groups = state.timeline.linkGroups ?? [];
+  if (!groups.some((g) => g.id === op.linkGroupId)) {
+    return { reason: "LINK_GROUP_NOT_FOUND", message: `Link group '${op.linkGroupId}' not found.` };
+  }
+  return null;
+}
+function validateAddTrackGroup(state, op) {
+  const groups = state.timeline.trackGroups ?? [];
+  if (groups.some((g) => g.id === op.trackGroup.id)) {
+    return { reason: "DUPLICATE_TRACK_GROUP_ID", message: `Track group '${op.trackGroup.id}' already exists.` };
+  }
+  for (const tid of op.trackGroup.trackIds) {
+    if (!state.timeline.tracks.some((t) => t.id === tid)) {
+      return { reason: "TRACK_NOT_FOUND", message: `Track '${tid}' not found.` };
+    }
+  }
+  return null;
+}
+function validateDeleteTrackGroup(state, op) {
+  const groups = state.timeline.trackGroups ?? [];
+  if (!groups.some((g) => g.id === op.trackGroupId)) {
+    return { reason: "TRACK_GROUP_NOT_FOUND", message: `Track group '${op.trackGroupId}' not found.` };
+  }
+  return null;
+}
+function validateSetTrackBlendMode(state, op) {
+  const track = state.timeline.tracks.find((t) => t.id === op.trackId);
+  if (!track) return { reason: "TRACK_NOT_FOUND", message: `Track '${op.trackId}' not found.` };
+  return null;
+}
+function validateSetTrackOpacity(state, op) {
+  const track = state.timeline.tracks.find((t) => t.id === op.trackId);
+  if (!track) return { reason: "TRACK_NOT_FOUND", message: `Track '${op.trackId}' not found.` };
+  if (op.opacity < 0 || op.opacity > 1) {
+    return { reason: "INVALID_OPACITY", message: `opacity must be in [0, 1].` };
+  }
+  return null;
+}
+function findEffect(clip, effectId) {
+  const effects = clip.effects ?? [];
+  return effects.find((e) => e.id === effectId);
+}
+function findClip(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 findMarker(state, markerId) {
+  return state.timeline.markers.find((m) => m.id === markerId);
+}
+
+// src/engine/dispatcher.ts
+function dispatch(state, transaction) {
+  let proposedState = state;
+  for (const op of transaction.operations) {
+    const rejection = validateOperation(proposedState, op);
+    if (rejection) {
+      return {
+        accepted: false,
+        reason: rejection.reason,
+        message: rejection.message
+      };
+    }
+    proposedState = applyOperation2(proposedState, op);
+  }
+  const violations = checkInvariants(proposedState);
+  if (violations.length > 0) {
+    return {
+      accepted: false,
+      reason: "INVARIANT_VIOLATED",
+      message: violations.map((v) => v.message).join("; ")
+    };
+  }
+  const nextState = {
+    ...proposedState,
+    timeline: {
+      ...proposedState.timeline,
+      version: state.timeline.version + 1
+    }
+  };
+  return { accepted: true, nextState };
+}
+
+// src/snap-index.ts
+var PRIORITIES = {
+  Marker: 100,
+  InPoint: 90,
+  OutPoint: 90,
+  ClipStart: 80,
+  ClipEnd: 80,
+  Playhead: 70,
+  BeatGrid: 50
+};
+function buildSnapIndex(state, playheadFrame, enabled = true) {
+  const points = [];
+  for (const track of state.timeline.tracks) {
+    for (const clip of track.clips) {
+      points.push({
+        frame: clip.timelineStart,
+        type: "ClipStart",
+        priority: PRIORITIES.ClipStart,
+        trackId: track.id,
+        sourceId: clip.id
+      });
+      points.push({
+        frame: clip.timelineEnd,
+        type: "ClipEnd",
+        priority: PRIORITIES.ClipEnd,
+        trackId: track.id,
+        sourceId: clip.id
+      });
+    }
+  }
+  points.push({
+    frame: playheadFrame,
+    type: "Playhead",
+    priority: PRIORITIES.Playhead,
+    trackId: null,
+    sourceId: "__playhead__"
+  });
+  const beatGrid = state.timeline.beatGrid;
+  const dur = state.timeline.duration;
+  if (beatGrid !== null) {
+    const fps = state.timeline.fps;
+    const beatDurationFrames = Math.round(60 / beatGrid.bpm * fps);
+    let f = beatGrid.offset;
+    while (f < dur) {
+      points.push({
+        frame: f,
+        type: "BeatGrid",
+        priority: PRIORITIES.BeatGrid,
+        trackId: null,
+        sourceId: `__beat_${f}__`
+      });
+      f = f + beatDurationFrames;
+    }
+  }
+  points.sort((a, b) => a.frame - b.frame);
+  return { points, builtAt: Date.now(), enabled };
+}
+function nearest(index, frame2, radiusFrames, exclude, allowedTypes) {
+  if (!index.enabled) return null;
+  const excludeSet = exclude ? new Set(exclude) : null;
+  let best = null;
+  let bestDist = Infinity;
+  for (const point of index.points) {
+    if (excludeSet && excludeSet.has(point.sourceId)) continue;
+    if (allowedTypes && !allowedTypes.includes(point.type)) continue;
+    const dist = Math.abs(point.frame - frame2);
+    if (dist > radiusFrames) continue;
+    if (dist < bestDist || dist === bestDist && best !== null && point.priority > best.priority) {
+      best = point;
+      bestDist = dist;
+    }
+  }
+  return best;
+}
+function toggleSnap(index, enabled) {
+  return { ...index, enabled };
+}
+
+// src/tools/types.ts
+function toToolId(s) {
+  return s;
+}
+
+// src/tools/registry.ts
+function createRegistry(tools, defaultId) {
+  const map = /* @__PURE__ */ new Map();
+  for (const tool of tools) {
+    map.set(tool.id, tool);
+  }
+  if (!map.has(defaultId)) {
+    throw new Error(
+      `createRegistry: defaultId "${defaultId}" not found in tools. Available: [${[...map.keys()].join(", ")}]`
+    );
+  }
+  return { tools: map, activeToolId: defaultId };
+}
+function activateTool(registry, id) {
+  getActiveTool(registry).onCancel();
+  if (!registry.tools.has(id)) {
+    throw new Error(
+      `activateTool: unknown toolId "${id}". Registered: [${[...registry.tools.keys()].join(", ")}]`
+    );
+  }
+  return { ...registry, activeToolId: id };
+}
+function getActiveTool(registry) {
+  const tool = registry.tools.get(registry.activeToolId);
+  if (!tool) {
+    throw new Error(
+      `getActiveTool: activeToolId "${registry.activeToolId}" is not registered. Registry is corrupt.`
+    );
+  }
+  return tool;
+}
+function registerTool(registry, tool) {
+  const next = new Map(registry.tools);
+  next.set(tool.id, tool);
+  return { ...registry, tools: next };
+}
+var NoOpTool = {
+  id: toToolId("noop"),
+  shortcutKey: "",
+  getCursor(_ctx) {
+    return "default";
+  },
+  getSnapCandidateTypes() {
+    return [];
+  },
+  onPointerDown(_evt, _ctx) {
+  },
+  onPointerMove(_evt, _ctx) {
+    return null;
+  },
+  onPointerUp(_evt, _ctx) {
+    return null;
+  },
+  onKeyDown(_evt, _ctx) {
+    return null;
+  },
+  onKeyUp(_evt, _ctx) {
+  },
+  onCancel() {
+  }
+};
+
+// src/tools/provisional.ts
+function createProvisionalManager() {
+  return { current: null };
+}
+function setProvisional(_manager, state) {
+  return { current: state };
+}
+function clearProvisional(_manager) {
+  return { current: null };
+}
+function resolveClip(clipId, state, manager) {
+  if (manager.current !== null) {
+    const ghost = manager.current.clips.find((c) => c.id === clipId);
+    if (ghost) return ghost;
+  }
+  for (const track of state.timeline.tracks) {
+    const clip = track.clips.find((c) => c.id === clipId);
+    if (clip) return clip;
+  }
+  return void 0;
+}
+
+// src/engine/marker-search.ts
+function findMarkersByColor(state, color) {
+  return state.timeline.markers.filter((m) => m.color === color);
+}
+function findMarkersByLabel(state, label) {
+  const lower = label.toLowerCase();
+  return state.timeline.markers.filter(
+    (m) => m.label.toLowerCase().includes(lower)
+  );
+}
+
+// src/types/easing.ts
+var LINEAR_EASING = { kind: "Linear" };
+var HOLD_EASING = { kind: "Hold" };
+
+// src/types/keyframe.ts
+function toKeyframeId(s) {
+  return s;
+}
+
+// src/types/effect.ts
+function toEffectId(s) {
+  return s;
+}
+function createEffect(id, effectType, renderStage = "preComposite", params = []) {
+  return { id, effectType, enabled: true, renderStage, params, keyframes: [] };
+}
+
+// src/types/transition.ts
+function toTransitionId(s) {
+  return s;
+}
+function createTransition(id, type, durationFrames, alignment = "centerOnCut", easing = LINEAR_EASING, params = []) {
+  return { id, type, durationFrames, alignment, easing, params };
+}
+
+// src/types/track-group.ts
+function toTrackGroupId(s) {
+  return s;
+}
+function createTrackGroup(id, label, trackIds = []) {
+  return { id, label, trackIds, collapsed: false };
+}
+
+// src/types/link-group.ts
+function toLinkGroupId(s) {
+  return s;
+}
+function createLinkGroup(id, clipIds) {
+  return { id, clipIds };
+}
+
+// src/tools/transition-tool.ts
+var TRANSITION_EDGE_THRESHOLD_PX = 8;
+function findClip2(state, clipId) {
+  for (const track of state.timeline.tracks) {
+    const c = track.clips.find((c2) => c2.id === clipId);
+    if (c) return c;
+  }
+  return void 0;
+}
+function findClipAtRightEdge(state, x, pixelsPerFrame) {
+  for (let ti = 0; ti < state.timeline.tracks.length; ti++) {
+    const track = state.timeline.tracks[ti];
+    for (const clip of track.clips) {
+      const rightEdgePx = clip.timelineEnd * pixelsPerFrame;
+      if (Math.abs(x - rightEdgePx) <= TRANSITION_EDGE_THRESHOLD_PX) {
+        return { clip, trackIndex: ti };
+      }
+    }
+  }
+  return null;
+}
+function findClipInTransitionZone(state, x, pixelsPerFrame) {
+  for (const track of state.timeline.tracks) {
+    for (const clip of track.clips) {
+      if (!clip.transition) continue;
+      const rightEdgePx = clip.timelineEnd * pixelsPerFrame;
+      const leftOfTransitionPx = rightEdgePx - clip.transition.durationFrames * pixelsPerFrame;
+      if (x >= leftOfTransitionPx && x <= rightEdgePx) return clip;
+    }
+  }
+  return null;
+}
+var _txSeq = 0;
+function txId() {
+  return `transition-tx-${++_txSeq}`;
+}
+var TransitionTool = class {
+  id = toToolId("transition");
+  shortcutKey = "T";
+  pendingClipId = null;
+  dragStartX = 0;
+  pendingDeleteTransitionClipId = null;
+  getCursor(_ctx) {
+    return "ew-resize";
+  }
+  getSnapCandidateTypes() {
+    return ["ClipStart", "ClipEnd", "Marker", "BeatGrid"];
+  }
+  onPointerDown(event, ctx) {
+    const { state, pixelsPerFrame } = ctx;
+    const x = event.x;
+    const atEdge = findClipAtRightEdge(state, x, pixelsPerFrame);
+    if (atEdge) {
+      this.pendingClipId = atEdge.clip.id;
+      this.dragStartX = x;
+      return;
+    }
+    const inTransition = findClipInTransitionZone(state, x, pixelsPerFrame);
+    if (inTransition) {
+      this.pendingDeleteTransitionClipId = inTransition.id;
+    }
+  }
+  onPointerMove(event, ctx) {
+    if (this.pendingClipId === null) return null;
+    const clip = findClip2(ctx.state, this.pendingClipId);
+    if (!clip) return null;
+    const dragDeltaX = event.x - this.dragStartX;
+    const deltaFrames = Math.round(dragDeltaX / ctx.pixelsPerFrame);
+    const durationFrames = Math.max(1, deltaFrames);
+    const transition = createTransition(
+      toTransitionId(`tr-${clip.id}-preview`),
+      "dissolve",
+      durationFrames,
+      "centerOnCut",
+      LINEAR_EASING
+    );
+    let nextState;
+    if (clip.transition) {
+      nextState = applyOperation2(ctx.state, {
+        type: "SET_TRANSITION_DURATION",
+        clipId: clip.id,
+        durationFrames
+      });
+    } else {
+      nextState = applyOperation2(ctx.state, {
+        type: "ADD_TRANSITION",
+        clipId: clip.id,
+        transition
+      });
+    }
+    const updatedClip = nextState.timeline.tracks.flatMap((t) => t.clips).find((c) => c.id === this.pendingClipId);
+    if (!updatedClip) return null;
+    return {
+      clips: [updatedClip],
+      isProvisional: true
+    };
+  }
+  onPointerUp(event, ctx) {
+    const pendingClipId = this.pendingClipId;
+    const dragStartX = this.dragStartX;
+    const pendingDelete = this.pendingDeleteTransitionClipId;
+    this.pendingClipId = null;
+    this.dragStartX = 0;
+    this.pendingDeleteTransitionClipId = null;
+    if (pendingDelete !== null) {
+      return {
+        id: txId(),
+        label: "Delete transition",
+        timestamp: Date.now(),
+        operations: [{ type: "DELETE_TRANSITION", clipId: pendingDelete }]
+      };
+    }
+    if (pendingClipId === null) return null;
+    const clip = findClip2(ctx.state, pendingClipId);
+    if (!clip) return null;
+    const dragDeltaX = event.x - dragStartX;
+    const deltaFrames = Math.round(dragDeltaX / ctx.pixelsPerFrame);
+    const durationFrames = Math.max(1, deltaFrames);
+    if (deltaFrames < 1) return null;
+    if (clip.transition) {
+      return {
+        id: txId(),
+        label: "Set transition duration",
+        timestamp: Date.now(),
+        operations: [
+          {
+            type: "SET_TRANSITION_DURATION",
+            clipId: pendingClipId,
+            durationFrames
+          }
+        ]
+      };
+    }
+    const transition = createTransition(
+      toTransitionId(`tr-${clip.id}-${Date.now()}`),
+      "dissolve",
+      durationFrames,
+      "centerOnCut",
+      LINEAR_EASING
+    );
+    return {
+      id: txId(),
+      label: "Add transition",
+      timestamp: Date.now(),
+      operations: [
+        {
+          type: "ADD_TRANSITION",
+          clipId: pendingClipId,
+          transition
+        }
+      ]
+    };
+  }
+  onKeyDown(_event, _ctx) {
+    return null;
+  }
+  onKeyUp(_event, _ctx) {
+  }
+  onCancel() {
+    this.pendingClipId = null;
+    this.dragStartX = 0;
+    this.pendingDeleteTransitionClipId = null;
+  }
+};
+
+// src/tools/keyframe-tool.ts
+var KEYFRAME_HIT_RADIUS_PX = 6;
+var SNAP_RADIUS_FRAMES = 5;
+function findClip3(state, clipId) {
+  for (const track of state.timeline.tracks) {
+    const c = track.clips.find((c2) => c2.id === clipId);
+    if (c) return c;
+  }
+  return void 0;
+}
+function findKeyframeAt(clip, x, pixelsPerFrame) {
+  const effects = clip.effects ?? [];
+  for (const effect of effects) {
+    for (const kf of effect.keyframes) {
+      const kfPx = kf.frame * pixelsPerFrame;
+      if (Math.abs(x - kfPx) <= KEYFRAME_HIT_RADIUS_PX) {
+        return { effectId: effect.id, keyframe: kf };
+      }
+    }
+  }
+  return null;
+}
+var _txSeq2 = 0;
+function txId2() {
+  return `keyframe-tx-${++_txSeq2}`;
+}
+var KeyframeTool = class {
+  id = toToolId("keyframe");
+  shortcutKey = "P";
+  draggingKeyframe = null;
+  activeClipId = null;
+  activeEffectId = null;
+  pendingAddKeyframe = null;
+  getCursor(_ctx) {
+    return "crosshair";
+  }
+  getSnapCandidateTypes() {
+    return ["ClipStart", "ClipEnd", "Marker", "BeatGrid"];
+  }
+  onPointerDown(event, ctx) {
+    if (event.clipId === null) return;
+    const clip = findClip3(ctx.state, event.clipId);
+    if (!clip) return;
+    const effects = clip.effects ?? [];
+    if (effects.length === 0) return;
+    const hitKf = findKeyframeAt(clip, event.x, ctx.pixelsPerFrame);
+    if (hitKf) {
+      this.draggingKeyframe = {
+        clipId: clip.id,
+        effectId: hitKf.effectId,
+        keyframeId: hitKf.keyframe.id,
+        startX: event.x,
+        startFrame: hitKf.keyframe.frame
+      };
+      return;
+    }
+    const firstEffect = effects[0];
+    let targetFrame = ctx.frameAtX(event.x);
+    if (ctx.snapIndex.enabled) {
+      const snapPoint = nearest(
+        ctx.snapIndex,
+        targetFrame,
+        SNAP_RADIUS_FRAMES,
+        void 0,
+        ["ClipStart", "ClipEnd", "Marker", "BeatGrid"]
+      );
+      if (snapPoint) targetFrame = snapPoint.frame;
+    }
+    this.activeClipId = clip.id;
+    this.activeEffectId = firstEffect.id;
+    this.pendingAddKeyframe = {
+      clipId: clip.id,
+      effectId: firstEffect.id,
+      targetFrame
+    };
+  }
+  onPointerMove(event, ctx) {
+    if (this.draggingKeyframe === null) return null;
+    const clip = findClip3(ctx.state, this.draggingKeyframe.clipId);
+    if (!clip) return null;
+    const dragDeltaX = event.x - this.draggingKeyframe.startX;
+    const deltaFrames = Math.round(dragDeltaX / ctx.pixelsPerFrame);
+    let newFrame = Math.max(0, this.draggingKeyframe.startFrame + deltaFrames);
+    if (ctx.snapIndex.enabled) {
+      const snapPoint = nearest(
+        ctx.snapIndex,
+        newFrame,
+        SNAP_RADIUS_FRAMES,
+        void 0,
+        ["ClipStart", "ClipEnd", "Marker", "BeatGrid"]
+      );
+      if (snapPoint) newFrame = snapPoint.frame;
+    }
+    const nextState = applyOperation2(ctx.state, {
+      type: "MOVE_KEYFRAME",
+      clipId: this.draggingKeyframe.clipId,
+      effectId: this.draggingKeyframe.effectId,
+      keyframeId: this.draggingKeyframe.keyframeId,
+      newFrame
+    });
+    const updatedClip = nextState.timeline.tracks.flatMap((t) => t.clips).find((c) => c.id === this.draggingKeyframe.clipId);
+    if (!updatedClip) return null;
+    return {
+      clips: [updatedClip],
+      isProvisional: true
+    };
+  }
+  onPointerUp(event, ctx) {
+    const dragging = this.draggingKeyframe;
+    const pendingAdd = this.pendingAddKeyframe;
+    this.draggingKeyframe = null;
+    this.activeClipId = null;
+    this.activeEffectId = null;
+    this.pendingAddKeyframe = null;
+    if (pendingAdd !== null) {
+      return {
+        id: txId2(),
+        label: "Add keyframe",
+        timestamp: Date.now(),
+        operations: [
+          {
+            type: "ADD_KEYFRAME",
+            clipId: pendingAdd.clipId,
+            effectId: pendingAdd.effectId,
+            keyframe: {
+              id: toKeyframeId(`kf-${Date.now()}`),
+              frame: pendingAdd.targetFrame,
+              value: 1,
+              easing: LINEAR_EASING
+            }
+          }
+        ]
+      };
+    }
+    if (dragging === null) return null;
+    const dragDeltaX = event.x - dragging.startX;
+    const deltaFrames = Math.round(dragDeltaX / ctx.pixelsPerFrame);
+    let newFrame = Math.max(0, dragging.startFrame + deltaFrames);
+    if (ctx.snapIndex.enabled) {
+      const snapPoint = nearest(
+        ctx.snapIndex,
+        newFrame,
+        SNAP_RADIUS_FRAMES,
+        void 0,
+        ["ClipStart", "ClipEnd", "Marker", "BeatGrid"]
+      );
+      if (snapPoint) newFrame = snapPoint.frame;
+    }
+    if (newFrame === dragging.startFrame) return null;
+    return {
+      id: txId2(),
+      label: "Move keyframe",
+      timestamp: Date.now(),
+      operations: [
+        {
+          type: "MOVE_KEYFRAME",
+          clipId: dragging.clipId,
+          effectId: dragging.effectId,
+          keyframeId: dragging.keyframeId,
+          newFrame
+        }
+      ]
+    };
+  }
+  onKeyDown(event, ctx) {
+    if (event.key !== "Delete" && event.key !== "Backspace") return null;
+    const dragging = this.draggingKeyframe;
+    this.draggingKeyframe = null;
+    this.activeClipId = null;
+    this.activeEffectId = null;
+    this.pendingAddKeyframe = null;
+    if (dragging === null) return null;
+    return {
+      id: txId2(),
+      label: "Delete keyframe",
+      timestamp: Date.now(),
+      operations: [
+        {
+          type: "DELETE_KEYFRAME",
+          clipId: dragging.clipId,
+          effectId: dragging.effectId,
+          keyframeId: dragging.keyframeId
+        }
+      ]
+    };
+  }
+  onKeyUp(_event, _ctx) {
+  }
+  onCancel() {
+    this.draggingKeyframe = null;
+    this.activeClipId = null;
+    this.activeEffectId = null;
+    this.pendingAddKeyframe = null;
+  }
+};
+
+// src/engine/serialization-error.ts
+var SerializationError = class extends Error {
+  constructor(message, violations) {
+    super(message);
+    this.violations = violations;
+    this.name = "SerializationError";
+  }
+};
+
+// src/engine/migrator.ts
+function migrateV1toV2(raw) {
+  return {
+    ...raw,
+    schemaVersion: 2
+  };
+}
+function migrate(raw) {
+  if (typeof raw !== "object" || raw === null) {
+    throw new SerializationError("Invalid JSON structure");
+  }
+  const obj = raw;
+  const version = obj.schemaVersion;
+  if (typeof version !== "number") {
+    throw new SerializationError("Missing schemaVersion");
+  }
+  if (version > CURRENT_SCHEMA_VERSION) {
+    throw new SerializationError(`Unknown schema version: ${version}`);
+  }
+  let current = raw;
+  if (version < 2) current = migrateV1toV2(current);
+  const curr = current;
+  const registry = curr.assetRegistry;
+  const assetRegistry = registry instanceof Map ? registry : new Map(
+    Object.entries(registry).map(([k, v]) => [k, v])
+  );
+  return {
+    schemaVersion: curr.schemaVersion,
+    timeline: curr.timeline,
+    assetRegistry
+  };
+}
+
+// src/engine/serializer.ts
+function serializeTimeline(state) {
+  const plain = {
+    schemaVersion: state.schemaVersion,
+    timeline: state.timeline,
+    assetRegistry: Object.fromEntries(state.assetRegistry)
+  };
+  return JSON.stringify(plain, null, 2);
+}
+function deserializeTimeline(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : "Invalid JSON";
+    throw new SerializationError(msg);
+  }
+  let state;
+  try {
+    state = migrate(parsed);
+  } catch (e) {
+    if (e instanceof SerializationError) throw e;
+    throw new SerializationError(e instanceof Error ? e.message : "Migration failed");
+  }
+  const violations = checkInvariants(state);
+  if (violations.length > 0) {
+    throw new SerializationError("State failed invariant checks", violations);
+  }
+  return state;
+}
+function remapAssetPaths(state, remap) {
+  const next = /* @__PURE__ */ new Map();
+  for (const [id, asset] of state.assetRegistry) {
+    if (asset.kind === "file") {
+      next.set(id, remap(asset));
+    } else {
+      next.set(id, asset);
+    }
+  }
+  return { ...state, assetRegistry: next };
+}
+function findOfflineAssets(state, isOnline) {
+  const result = [];
+  for (const asset of state.assetRegistry.values()) {
+    if (asset.kind !== "file") continue;
+    if (isOnline(asset)) continue;
+    const clipIds = [];
+    for (const track of state.timeline.tracks) {
+      for (const clip of track.clips) {
+        if (clip.assetId === asset.id) clipIds.push(clip.id);
+      }
+    }
+    result.push({
+      assetId: asset.id,
+      path: asset.filePath,
+      clipIds
+    });
+  }
+  return result;
+}
+
+// src/engine/otio-export.ts
+function rationalTime(value, rate) {
+  return { value, rate };
+}
+function timeRange(start, duration, rate) {
+  return {
+    OTIO_SCHEMA: "TimeRange.1",
+    start_time: rationalTime(start, rate),
+    duration: rationalTime(duration, rate)
+  };
+}
+function fpsFromTimeline(state) {
+  return state.timeline.fps;
+}
+function clipDurationFrames(clip) {
+  return clip.timelineEnd - clip.timelineStart;
+}
+function mediaReferenceForClip(state, clip, fps) {
+  const asset = state.assetRegistry.get(clip.assetId);
+  if (!asset) {
+    return { OTIO_SCHEMA: "MissingReference.1" };
+  }
+  if (asset.kind === "file") {
+    const fa = asset;
+    const dur = fa.intrinsicDuration;
+    return {
+      OTIO_SCHEMA: "ExternalReference.1",
+      target_url: fa.filePath,
+      available_range: timeRange(0, dur, fps)
+    };
+  }
+  const ga = asset;
+  return {
+    OTIO_SCHEMA: "GeneratorReference.1",
+    generator_kind: ga.generatorDef.type
+  };
+}
+function effectToOTIO(e) {
+  return {
+    OTIO_SCHEMA: "Effect.1",
+    name: e.effectType,
+    effect_name: e.effectType,
+    enabled: e.enabled,
+    metadata: { params: e.params ?? [] }
+  };
+}
+function clipToOTIO(state, clip, fps) {
+  const durationFrames = clipDurationFrames(clip);
+  const mediaStart = clip.mediaIn;
+  const otioClip = {
+    OTIO_SCHEMA: "Clip.1",
+    name: clip.name ?? clip.id,
+    source_range: {
+      OTIO_SCHEMA: "TimeRange.1",
+      start_time: rationalTime(mediaStart, fps),
+      duration: rationalTime(durationFrames, fps)
+    },
+    media_reference: mediaReferenceForClip(state, clip, fps)
+  };
+  const effects = clip.effects;
+  if (effects && effects.length > 0) {
+    otioClip.effects = effects.map(effectToOTIO);
+  }
+  return otioClip;
+}
+function trackToOTIO(state, track, fps) {
+  const children = [];
+  const clips = track.clips;
+  for (let i = 0; i < clips.length; i++) {
+    const clip = clips[i];
+    const clipStart = clip.timelineStart;
+    const prevEnd = i === 0 ? 0 : clips[i - 1].timelineEnd;
+    const gapFrames = clipStart - prevEnd;
+    if (gapFrames > 0) {
+      children.push({
+        OTIO_SCHEMA: "Gap.1",
+        source_range: timeRange(0, gapFrames, fps)
+      });
+    }
+    children.push(clipToOTIO(state, clip, fps));
+  }
+  const kind = track.type === "video" ? "Video" : track.type === "audio" ? "Audio" : "Video";
+  return {
+    OTIO_SCHEMA: "Track.1",
+    kind,
+    children
+  };
+}
+function markerToOTIO(marker, fps) {
+  if (marker.type === "point") {
+    const frame2 = marker.frame;
+    return {
+      OTIO_SCHEMA: "Marker.1",
+      name: marker.label ?? "",
+      color: marker.color ?? "RED",
+      marked_range: timeRange(frame2, 0, fps)
+    };
+  }
+  const start = marker.frameStart;
+  const duration = marker.frameEnd - marker.frameStart;
+  return {
+    OTIO_SCHEMA: "Marker.1",
+    name: marker.label ?? "",
+    color: marker.color ?? "RED",
+    marked_range: timeRange(start, duration, fps)
+  };
+}
+function exportToOTIO(state) {
+  const fps = fpsFromTimeline(state);
+  const timeline = state.timeline;
+  const tracks = timeline.tracks.map((t) => trackToOTIO(state, t, fps));
+  const markers = (timeline.markers ?? []).map((m) => markerToOTIO(m, fps));
+  return {
+    OTIO_SCHEMA: "Timeline.1",
+    name: timeline.name ?? "Untitled",
+    global_start_time: rationalTime(0, fps),
+    tracks: {
+      OTIO_SCHEMA: "Stack.1",
+      children: tracks
+    },
+    markers
+  };
+}
+
+// src/types/marker.ts
+var toMarkerId = (s) => s;
+
+// src/types/generator.ts
+var toGeneratorId = (s) => s;
+
+// src/engine/otio-import.ts
+var clipIdCounter = 0;
+function generateClipId() {
+  return `clip-${++clipIdCounter}`;
+}
+function parseFps(doc, options) {
+  if (options?.fps != null) return options.fps;
+  const global = doc.global_start_time;
+  if (global?.rate != null) return global.rate;
+  const tracks = doc.tracks?.children;
+  if (tracks) {
+    for (const track of tracks) {
+      const children = track?.children ?? [];
+      for (const item of children) {
+        const sr = item?.source_range;
+        if (sr?.duration?.rate != null) return sr.duration.rate;
+      }
+    }
+  }
+  return 30;
+}
+function rationalTimeToFrames(rt, targetFps) {
+  if (!rt) return 0;
+  const value = rt.value ?? 0;
+  const rate = rt.rate ?? targetFps;
+  return Math.round(value * (targetFps / rate));
+}
+function ensureFrameRate(fps) {
+  const valid = [23.976, 24, 25, 29.97, 30, 50, 59.94, 60];
+  if (!valid.includes(fps)) return 30;
+  return frameRate(fps);
+}
+function importFromOTIO(doc, options) {
+  if (typeof doc !== "object" || doc === null) {
+    throw new SerializationError("Invalid OTIO document");
+  }
+  const d = doc;
+  const schema = d.OTIO_SCHEMA;
+  if (typeof schema !== "string" || !schema.startsWith("Timeline")) {
+    throw new SerializationError("Invalid OTIO document: OTIO_SCHEMA must be Timeline");
+  }
+  const targetFps = parseFps(d, options);
+  const fps = ensureFrameRate(targetFps);
+  const timelineName = options?.name ?? d.name ?? "Untitled";
+  const assetRegistry = /* @__PURE__ */ new Map();
+  const tracks = [];
+  const trackList = d.tracks?.children ?? [];
+  for (let ti = 0; ti < trackList.length; ti++) {
+    const otioTrack = trackList[ti];
+    const kind = otioTrack.kind ?? "Video";
+    const trackType = kind === "Audio" ? "audio" : "video";
+    const trackId = toTrackId(`track-${ti + 1}`);
+    const clips = [];
+    let cursorFrames = 0;
+    const children = otioTrack.children ?? [];
+    for (const item of children) {
+      const itemSchema = item?.OTIO_SCHEMA ?? "";
+      if (itemSchema === "Gap.1") {
+        const dur = item?.source_range?.duration;
+        const gapFrames = rationalTimeToFrames(dur, targetFps);
+        cursorFrames += gapFrames;
+        continue;
+      }
+      if (itemSchema === "Clip.1") {
+        const sr = item.source_range;
+        const durationFrames = rationalTimeToFrames(sr?.duration, targetFps);
+        const mediaStartFrames = rationalTimeToFrames(sr?.start_time, targetFps);
+        const clipName = item.name ?? generateClipId();
+        const clipId = toClipId(clipName);
+        const mediaRef = item.media_reference;
+        let assetId;
+        if (mediaRef?.OTIO_SCHEMA === "GeneratorReference.1") {
+          const genKind = mediaRef.generator_kind ?? "solid";
+          const assetIdStr = `gen-${ti}-${clips.length}`;
+          assetId = toAssetId(assetIdStr);
+          if (!assetRegistry.has(assetId)) {
+            const genAsset = createGeneratorAsset({
+              id: assetIdStr,
+              name: genKind,
+              mediaType: trackType,
+              generatorDef: {
+                id: toGeneratorId(assetIdStr),
+                type: ["solid", "bars", "countdown", "noise", "text"].includes(genKind) ? genKind : "solid",
+                params: {},
+                duration: toFrame(Math.max(1, durationFrames)),
+                name: genKind
+              },
+              nativeFps: fps
+            });
+            assetRegistry.set(assetId, genAsset);
+          }
+        } else if (mediaRef?.OTIO_SCHEMA === "ExternalReference.1" && mediaRef.target_url != null) {
+          const url = mediaRef.target_url;
+          const avail = mediaRef.available_range;
+          const intrinsicDuration = rationalTimeToFrames(avail?.duration, targetFps) || 1;
+          const aidStr = `asset-${url}-${intrinsicDuration}`;
+          assetId = toAssetId(aidStr);
+          if (!assetRegistry.has(assetId)) {
+            const fileAsset = createAsset({
+              id: aidStr,
+              name: url.split("/").pop() ?? "media",
+              mediaType: trackType,
+              filePath: url,
+              intrinsicDuration: toFrame(Math.max(1, intrinsicDuration)),
+              nativeFps: fps,
+              sourceTimecodeOffset: toFrame(0)
+            });
+            assetRegistry.set(assetId, fileAsset);
+          }
+        } else {
+          const aidStr = `missing-${ti}-${clips.length}`;
+          assetId = toAssetId(aidStr);
+          if (!assetRegistry.has(assetId)) {
+            const fileAsset = createAsset({
+              id: aidStr,
+              name: "Missing",
+              mediaType: trackType,
+              filePath: "",
+              intrinsicDuration: toFrame(Math.max(1, durationFrames)),
+              nativeFps: fps,
+              sourceTimecodeOffset: toFrame(0),
+              status: "missing"
+            });
+            assetRegistry.set(assetId, fileAsset);
+          }
+        }
+        const timelineStart = toFrame(cursorFrames);
+        const timelineEnd = toFrame(cursorFrames + durationFrames);
+        const mediaIn = toFrame(mediaStartFrames);
+        const mediaOut = toFrame(mediaStartFrames + durationFrames);
+        let effects;
+        const otioEffects = item.effects;
+        if (otioEffects && otioEffects.length > 0) {
+          effects = otioEffects.map((e, idx) => {
+            const effectType = e.effect_name ?? e.name ?? "effect";
+            return createEffect(
+              toEffectId(`eff-${clipId}-${idx}`),
+              effectType,
+              "preComposite",
+              e.metadata?.params ?? []
+            );
+          });
+        }
+        const clipParams = {
+          id: clipId,
+          assetId,
+          trackId,
+          timelineStart,
+          timelineEnd,
+          mediaIn,
+          mediaOut
+        };
+        if (effects?.length) clipParams.effects = effects;
+        const clip = createClip(clipParams);
+        clips.push(clip);
+        cursorFrames += durationFrames;
+      }
+    }
+    tracks.push(
+      createTrack({
+        id: trackId,
+        name: kind === "Audio" ? `Audio ${ti + 1}` : `Video ${ti + 1}`,
+        type: trackType,
+        clips
+      })
+    );
+  }
+  const markers = [];
+  const otioMarkers = d.markers ?? [];
+  for (let i = 0; i < otioMarkers.length; i++) {
+    const m = otioMarkers[i];
+    const range = m.marked_range;
+    const startFrames = rationalTimeToFrames(range?.start_time, targetFps);
+    const durationFrames = rationalTimeToFrames(range?.duration, targetFps);
+    if (durationFrames <= 0) {
+      markers.push({
+        type: "point",
+        id: toMarkerId(`m${i + 1}`),
+        frame: toFrame(startFrames),
+        label: m.name ?? "",
+        color: m.color ?? "RED",
+        scope: "global",
+        linkedClipId: null
+      });
+    } else {
+      markers.push({
+        type: "range",
+        id: toMarkerId(`m${i + 1}`),
+        frameStart: toFrame(startFrames),
+        frameEnd: toFrame(startFrames + durationFrames),
+        label: m.name ?? "",
+        color: m.color ?? "RED",
+        scope: "global",
+        linkedClipId: null
+      });
+    }
+  }
+  const timeline = createTimeline({
+    id: "tl",
+    name: timelineName,
+    fps,
+    duration: toFrame(Math.max(1, 86400)),
+    startTimecode: "00:00:00:00",
+    tracks,
+    markers
+  });
+  const state = createTimelineState({
+    timeline,
+    assetRegistry
+  });
+  const violations = checkInvariants(state);
+  if (violations.length > 0) {
+    throw new SerializationError("OTIO import produced invalid state", violations);
+  }
+  return state;
+}
+
+// src/engine/edl-export.ts
+function pad2(n) {
+  return String(n).padStart(2, "0");
+}
+function frameToTimecodeNonDrop(frame2, fps) {
+  const totalSeconds = Math.floor(frame2 / fps);
+  const ff = Math.floor(frame2 % fps);
+  const ss = totalSeconds % 60;
+  const mm = Math.floor(totalSeconds / 60) % 60;
+  const hh = Math.floor(totalSeconds / 3600);
+  return `${pad2(hh)}:${pad2(mm)}:${pad2(ss)}:${pad2(ff)}`;
+}
+function frameToTimecodeDropFrame29_97(frame2) {
+  const FRAMES_PER_MIN = 1798;
+  const FRAMES_PER_10_MIN = 17982;
+  const d = Math.floor(frame2 / FRAMES_PER_10_MIN);
+  const m = Math.floor(frame2 % FRAMES_PER_10_MIN / FRAMES_PER_MIN);
+  const totalMinutes = 10 * d + m;
+  const r = frame2 % FRAMES_PER_MIN;
+  const ss = Math.floor(r / 30);
+  const ff = r % 30;
+  const hh = Math.floor(totalMinutes / 60);
+  const mm = totalMinutes % 60;
+  return `${pad2(hh)}:${pad2(mm)}:${pad2(ss)}:${pad2(ff)}`;
+}
+function frameToTimecode(frame2, fps, dropFrame) {
+  if (!dropFrame || fps !== 29.97) {
+    return frameToTimecodeNonDrop(frame2, fps);
+  }
+  return frameToTimecodeDropFrame29_97(frame2);
+}
+function reelName(asset) {
+  let raw;
+  if (!asset || asset.kind === "generator") raw = "AX";
+  else {
+    const fa = asset;
+    const path = fa.filePath;
+    const base = path.split("/").pop() ?? path;
+    const noExt = base.includes(".") ? base.slice(0, base.lastIndexOf(".")) : base;
+    raw = noExt.toUpperCase().replace(/[^A-Z0-9_-]/g, "_").slice(0, 8);
+  }
+  return raw.padEnd(8).slice(0, 8);
+}
+function transitionCode(clip) {
+  const t = clip.transition;
+  if (t && t.type === "dissolve") return "D";
+  return "C";
+}
+function clipDisplayName(asset, clipName) {
+  if (!asset) return clipName ?? "unknown";
+  if (asset.kind === "file") return asset.filePath.split("/").pop() ?? asset.filePath;
+  return asset.generatorDef?.type ?? asset.name ?? "generator";
+}
+function clipDurationFrames2(clip) {
+  return clip.timelineEnd - clip.timelineStart;
+}
+function exportToEDL(state, options) {
+  const title = options?.title ?? state.timeline.name ?? "Untitled";
+  const dropFrame = options?.dropFrame ?? false;
+  const trackIndex = options?.trackIndex ?? 0;
+  const videoTracks = state.timeline.tracks.filter((t) => t.type === "video");
+  const track = videoTracks[trackIndex];
+  if (!track) {
+    return `TITLE: ${title}
+FCM: ${dropFrame ? "DROP FRAME" : "NON-DROP FRAME"}
+`;
+  }
+  const fps = state.timeline.fps;
+  const useDropFrame = dropFrame && fps === 29.97;
+  let headerComment = "";
+  if (dropFrame && fps !== 29.97) {
+    headerComment = "* DROP FRAME NOT SUPPORTED FOR THIS FRAME RATE\n\n";
+  }
+  const lines = [];
+  lines.push(`TITLE: ${title}`);
+  lines.push(`FCM: ${useDropFrame ? "DROP FRAME" : "NON-DROP FRAME"}`);
+  if (headerComment) lines.push(headerComment.trim());
+  const clips = track.clips;
+  for (let i = 0; i < clips.length; i++) {
+    const clip = clips[i];
+    const asset = state.assetRegistry.get(clip.assetId);
+    const eventNum = String(i + 1).padStart(3, "0");
+    const reel = reelName(asset);
+    const channel = "V";
+    const trans = transitionCode(clip);
+    const startFrame = clip.timelineStart;
+    const dur = clipDurationFrames2(clip);
+    const mediaStart = clip.mediaIn;
+    const srcIn = frameToTimecode(mediaStart, fps, useDropFrame);
+    const srcOut = frameToTimecode(mediaStart + dur, fps, useDropFrame);
+    const recIn = frameToTimecode(startFrame, fps, useDropFrame);
+    const recOut = frameToTimecode(startFrame + dur, fps, useDropFrame);
+    const eventLine = `${eventNum}  ${reel}       ${channel}     ${trans}        ${srcIn} ${srcOut} ${recIn} ${recOut}`;
+    lines.push(eventLine);
+    lines.push(`* FROM CLIP NAME: ${clipDisplayName(asset, clip.name)}`);
+    if (i < clips.length - 1) lines.push("");
+  }
+  return lines.join("\n");
+}
+
+// src/engine/aaf-export.ts
+function xmlEscape(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function clipDurationFrames3(clip) {
+  return clip.timelineEnd - clip.timelineStart;
+}
+function sourceRefForClip(state, clip) {
+  const asset = state.assetRegistry.get(clip.assetId);
+  if (!asset) return "missing";
+  if (asset.kind === "file") return asset.filePath;
+  return asset.generatorDef.type;
+}
+function dataDefinition(track) {
+  return track.type === "video" ? "Picture" : track.type === "audio" ? "Sound" : "Picture";
+}
+function exportToAAF(state, options) {
+  const projectName = xmlEscape(options?.projectName ?? state.timeline.name ?? "Untitled");
+  const fps = state.timeline.fps;
+  const editRate = options?.frameRate ?? `${fps}/1`;
+  const timelineName = xmlEscape(state.timeline.name ?? "Timeline");
+  const lines = [];
+  const indent = (n) => "  ".repeat(n);
+  lines.push('<?xml version="1.0" encoding="UTF-8"?>');
+  lines.push(`<AAF version="1.1"`);
+  lines.push(`     xmlns="urn:aaf:schema:1.1"`);
+  lines.push(`     projectName="${projectName}">`);
+  lines.push(`${indent(1)}<Dictionary/>`);
+  lines.push(`${indent(1)}<ContentStorage>`);
+  const clipTrackPairs = [];
+  for (const track of state.timeline.tracks) {
+    for (const clip of track.clips) clipTrackPairs.push({ clip, track });
+  }
+  for (const { clip, track } of clipTrackPairs) {
+    const clipId = xmlEscape(clip.id);
+    const len = clipDurationFrames3(clip);
+    const ref = xmlEscape(sourceRefForClip(state, clip));
+    const def = dataDefinition(track);
+    lines.push(`${indent(2)}<MasterMob name="${clipId}" mobID="${clipId}">`);
+    lines.push(`${indent(3)}<TimelineMobSlot>`);
+    lines.push(`${indent(4)}<Sequence dataDefinition="${def}">`);
+    lines.push(`${indent(5)}<SourceClip length="${len}" sourceRef="${ref}"/>`);
+    lines.push(`${indent(4)}</Sequence>`);
+    lines.push(`${indent(3)}</TimelineMobSlot>`);
+    lines.push(`${indent(2)}</MasterMob>`);
+  }
+  lines.push(`${indent(2)}<CompositionMob name="${timelineName}">`);
+  state.timeline.tracks.forEach((track, slotIndex) => {
+    const def = dataDefinition(track);
+    lines.push(`${indent(3)}<TimelineMobSlot slotID="${slotIndex}" editRate="${editRate}">`);
+    lines.push(`${indent(4)}<Sequence dataDefinition="${def}">`);
+    let cursor = 0;
+    for (const clip of track.clips) {
+      const start = clip.timelineStart;
+      const gapFrames = start - cursor;
+      if (gapFrames > 0) {
+        lines.push(`${indent(5)}<Filler length="${gapFrames}"/>`);
+      }
+      const len = clipDurationFrames3(clip);
+      const clipId = xmlEscape(clip.id);
+      lines.push(`${indent(5)}<SourceClip length="${len}" sourceRef="${clipId}"/>`);
+      cursor = clip.timelineEnd;
+    }
+    lines.push(`${indent(4)}</Sequence>`);
+    lines.push(`${indent(3)}</TimelineMobSlot>`);
+  });
+  lines.push(`${indent(2)}</CompositionMob>`);
+  lines.push(`${indent(1)}</ContentStorage>`);
+  lines.push("</AAF>");
+  return lines.join("\n");
+}
+
+// src/engine/fcpxml-export.ts
+function xmlEscape2(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function toFCPTime(frames, fps) {
+  if (frames === 0) return "0s";
+  return `${frames}/${fps}s`;
+}
+function clipDurationFrames4(clip) {
+  return clip.timelineEnd - clip.timelineStart;
+}
+var DEFAULT_WIDTH = 1920;
+var DEFAULT_HEIGHT = 1080;
+function exportToFCPXML(state, options) {
+  const libraryName = xmlEscape2(options?.libraryName ?? "Library");
+  const eventName = xmlEscape2(options?.eventName ?? state.timeline.name ?? "Event");
+  const timelineName = xmlEscape2(state.timeline.name ?? "Project");
+  const fps = state.timeline.fps;
+  const lines = [];
+  const indent = (n) => "  ".repeat(n);
+  lines.push('<?xml version="1.0" encoding="UTF-8"?>');
+  lines.push("<!DOCTYPE fcpxml>");
+  lines.push('<fcpxml version="1.10">');
+  lines.push(`${indent(1)}<resources>`);
+  const frameDuration2 = fps > 0 ? `1/${fps}s` : "1/30s";
+  lines.push(`${indent(2)}<format id="r1" name="FFVideoFormat${DEFAULT_WIDTH}x${DEFAULT_HEIGHT}p${fps}" frameDuration="${frameDuration2}" width="${DEFAULT_WIDTH}" height="${DEFAULT_HEIGHT}"/>`);
+  const fileAssets = Array.from(state.assetRegistry.values()).filter((a) => a.kind === "file");
+  for (const asset of fileAssets) {
+    const fa = asset;
+    const id = xmlEscape2(fa.id);
+    const name = xmlEscape2(fa.name);
+    const src = "file://" + xmlEscape2(fa.filePath);
+    const duration = toFCPTime(fa.intrinsicDuration, fps);
+    const hasVideo = fa.mediaType === "video" ? "1" : "0";
+    const hasAudio = fa.mediaType === "audio" ? "1" : "0";
+    lines.push(`${indent(2)}<asset id="${id}" name="${name}" src="${src}" duration="${duration}" hasVideo="${hasVideo}" hasAudio="${hasAudio}"/>`);
+  }
+  const genAssets = Array.from(state.assetRegistry.values()).filter((a) => a.kind === "generator");
+  for (const asset of genAssets) {
+    const ga = asset;
+    const id = xmlEscape2(ga.id);
+    const genType = xmlEscape2(ga.generatorDef.type);
+    const uid = `.../Generators.localized/${genType}`;
+    lines.push(`${indent(2)}<effect id="${id}" name="${genType}" uid="${xmlEscape2(uid)}"/>`);
+  }
+  lines.push(`${indent(1)}</resources>`);
+  lines.push(`${indent(1)}<library name="${libraryName}">`);
+  lines.push(`${indent(2)}<event name="${eventName}">`);
+  lines.push(`${indent(3)}<project name="${timelineName}">`);
+  let totalDurationFrames = 0;
+  const firstTrack = state.timeline.tracks[0];
+  if (firstTrack?.clips.length) {
+    const last = firstTrack.clips[firstTrack.clips.length - 1];
+    totalDurationFrames = last.timelineEnd;
+  }
+  const totalDuration = toFCPTime(totalDurationFrames, fps);
+  lines.push(`${indent(4)}<sequence duration="${totalDuration}" format="r1" tcStart="0s" tcFormat="NDF">`);
+  lines.push(`${indent(5)}<spine>`);
+  const videoTrack = state.timeline.tracks.find((t) => t.type === "video") ?? state.timeline.tracks[0];
+  if (videoTrack) {
+    let cursor = 0;
+    for (const clip of videoTrack.clips) {
+      const start = clip.timelineStart;
+      const gapFrames = start - cursor;
+      if (gapFrames > 0) {
+        const gapOffset = toFCPTime(start, fps);
+        const gapDur = toFCPTime(gapFrames, fps);
+        lines.push(`${indent(6)}<gap name="Gap" offset="${gapOffset}" duration="${gapDur}" start="0s"/>`);
+      }
+      const asset = state.assetRegistry.get(clip.assetId);
+      const dur = clipDurationFrames4(clip);
+      const offset = toFCPTime(start, fps);
+      const durationStr = toFCPTime(dur, fps);
+      const mediaStart = toFCPTime(clip.mediaIn, fps);
+      const clipId = xmlEscape2(clip.id);
+      if (asset?.kind === "generator") {
+        const ga = asset;
+        const ref = xmlEscape2(ga.id);
+        lines.push(`${indent(6)}<clip name="${clipId}" offset="${offset}" duration="${durationStr}" start="${mediaStart}" tcFormat="NDF">`);
+        lines.push(`${indent(7)}<generator ref="${ref}" offset="0s" duration="${durationStr}" start="0s">`);
+        lines.push(`${indent(8)}<param name="Generator" value="${xmlEscape2(ga.generatorDef.type)}"/>`);
+        lines.push(`${indent(7)}</generator>`);
+        lines.push(`${indent(6)}</clip>`);
+      } else {
+        const ref = asset ? xmlEscape2(asset.id) : "missing";
+        lines.push(`${indent(6)}<clip name="${clipId}" offset="${offset}" duration="${durationStr}" start="${mediaStart}" tcFormat="NDF">`);
+        lines.push(`${indent(7)}<video ref="${ref}" offset="0s" duration="${durationStr}" start="0s"/>`);
+        lines.push(`${indent(6)}</clip>`);
+      }
+      cursor = clip.timelineEnd;
+    }
+  }
+  for (const track of state.timeline.tracks) {
+    if (track.type !== "audio") continue;
+    for (const clip of track.clips) {
+      const dur = clipDurationFrames4(clip);
+      const start = clip.timelineStart;
+      const offset = toFCPTime(start, fps);
+      const durationStr = toFCPTime(dur, fps);
+      const asset = state.assetRegistry.get(clip.assetId);
+      const ref = asset ? xmlEscape2(asset.id) : "missing";
+      const clipId = xmlEscape2(clip.id);
+      lines.push(`${indent(6)}<asset-clip ref="${ref}" name="${clipId}" offset="${offset}" duration="${durationStr}" start="0s" role="dialogue"/>`);
+    }
+  }
+  lines.push(`${indent(5)}</spine>`);
+  lines.push(`${indent(4)}</sequence>`);
+  lines.push(`${indent(3)}</project>`);
+  lines.push(`${indent(2)}</event>`);
+  lines.push(`${indent(1)}</library>`);
+  lines.push("</fcpxml>");
+  return lines.join("\n");
+}
+
+// src/types/project.ts
+function toProjectId(s) {
+  return s;
+}
+function toBinId(s) {
+  return s;
+}
+function createBin(id, label, parentId = null) {
+  return { id, label, parentId, items: [] };
+}
+function createProject(id, name, timelines = []) {
+  const now = Date.now();
+  return {
+    id,
+    name,
+    timelines,
+    bins: [],
+    rootBinIds: [],
+    createdAt: now,
+    updatedAt: now,
+    schemaVersion: CURRENT_SCHEMA_VERSION
+  };
+}
+
+// src/engine/project-ops.ts
+function withUpdatedAt(project, updatedAt = Date.now()) {
+  return { ...project, updatedAt };
+}
+function itemsEqual(a, b) {
+  if (a.kind !== b.kind) return false;
+  switch (a.kind) {
+    case "asset":
+      return a.assetId === b.assetId;
+    case "sequence":
+      return a.timelineId === b.timelineId;
+    case "bin":
+      return a.binId === b.binId;
+  }
+}
+function addTimeline(project, state) {
+  return withUpdatedAt({
+    ...project,
+    timelines: [...project.timelines, state]
+  });
+}
+function removeTimeline(project, timelineId) {
+  const nextTimelines = project.timelines.filter((t) => t.timeline.id !== timelineId);
+  if (nextTimelines.length === project.timelines.length) return project;
+  return withUpdatedAt({ ...project, timelines: nextTimelines });
+}
+function addBin(project, bin) {
+  const nextBins = [...project.bins, bin];
+  const nextRoot = bin.parentId === null ? [...project.rootBinIds, bin.id] : project.rootBinIds;
+  return withUpdatedAt({ ...project, bins: nextBins, rootBinIds: nextRoot });
+}
+function removeBin(project, binId) {
+  const toRemove = /* @__PURE__ */ new Set();
+  const byParent = /* @__PURE__ */ new Map();
+  for (const b of project.bins) {
+    const key = b.parentId;
+    const arr = byParent.get(key) ?? [];
+    arr.push(b);
+    byParent.set(key, arr);
+  }
+  const stack = [binId];
+  while (stack.length) {
+    const id = stack.pop();
+    if (toRemove.has(id)) continue;
+    toRemove.add(id);
+    const children = byParent.get(id) ?? [];
+    for (const child of children) stack.push(child.id);
+  }
+  if (toRemove.size === 1 && !project.bins.some((b) => b.id === binId)) {
+    return project;
+  }
+  const nextBins = project.bins.filter((b) => !toRemove.has(b.id));
+  const nextRoot = project.rootBinIds.filter((id) => !toRemove.has(id));
+  return withUpdatedAt({ ...project, bins: nextBins, rootBinIds: nextRoot });
+}
+function addItemToBin(project, binId, item) {
+  const idx = project.bins.findIndex((b) => b.id === binId);
+  if (idx < 0) throw new Error(`Bin not found: ${binId}`);
+  const target = project.bins[idx];
+  const updated = { ...target, items: [...target.items, item] };
+  const nextBins = [...project.bins];
+  nextBins[idx] = updated;
+  return withUpdatedAt({ ...project, bins: nextBins });
+}
+function removeItemFromBin(project, binId, item) {
+  const idx = project.bins.findIndex((b) => b.id === binId);
+  if (idx < 0) throw new Error(`Bin not found: ${binId}`);
+  const target = project.bins[idx];
+  const nextItems = target.items.filter((i) => !itemsEqual(i, item));
+  if (nextItems.length === target.items.length) return project;
+  const updated = { ...target, items: nextItems };
+  const nextBins = [...project.bins];
+  nextBins[idx] = updated;
+  return withUpdatedAt({ ...project, bins: nextBins });
+}
+function moveItemBetweenBins(project, fromBinId, toBinId2, item) {
+  const fromIdx = project.bins.findIndex((b) => b.id === fromBinId);
+  const toIdx = project.bins.findIndex((b) => b.id === toBinId2);
+  if (fromIdx < 0) throw new Error(`Bin not found: ${fromBinId}`);
+  if (toIdx < 0) throw new Error(`Bin not found: ${toBinId2}`);
+  const fromBin = project.bins[fromIdx];
+  const toBin = project.bins[toIdx];
+  const nextFromItems = fromBin.items.filter((i) => !itemsEqual(i, item));
+  const nextToItems = [...toBin.items, item];
+  const nextBins = [...project.bins];
+  nextBins[fromIdx] = { ...fromBin, items: nextFromItems };
+  nextBins[toIdx] = { ...toBin, items: nextToItems };
+  return withUpdatedAt({ ...project, bins: nextBins });
+}
+
+// src/engine/project-serializer.ts
+function isObject(v) {
+  return typeof v === "object" && v !== null;
+}
+function validateBinItem(item) {
+  if (!isObject(item)) throw new SerializationError("Invalid bin item");
+  const kind = item.kind;
+  if (kind === "asset") {
+    if (typeof item.assetId !== "string") throw new SerializationError("Invalid bin item");
+    return;
+  }
+  if (kind === "sequence") {
+    if (typeof item.timelineId !== "string") throw new SerializationError("Invalid bin item");
+    return;
+  }
+  if (kind === "bin") {
+    if (typeof item.binId !== "string") throw new SerializationError("Invalid bin item");
+    return;
+  }
+  throw new SerializationError("Invalid bin item");
+}
+function validateBin(bin) {
+  if (!isObject(bin)) throw new SerializationError("Invalid bin");
+  if (typeof bin.id !== "string") throw new SerializationError("Invalid bin");
+  if (typeof bin.label !== "string") throw new SerializationError("Invalid bin");
+  if (!(typeof bin.parentId === "string" || bin.parentId === null)) throw new SerializationError("Invalid bin");
+  if (!Array.isArray(bin.items)) throw new SerializationError("Invalid bin");
+  for (const item of bin.items) validateBinItem(item);
+  if (bin.color !== void 0 && typeof bin.color !== "string") throw new SerializationError("Invalid bin");
+}
+function toPlainTimeline(state) {
+  return {
+    schemaVersion: state.schemaVersion,
+    timeline: state.timeline,
+    assetRegistry: Object.fromEntries(state.assetRegistry)
+  };
+}
+function serializeProject(project) {
+  const plain = {
+    id: project.id,
+    name: project.name,
+    timelines: project.timelines.map(toPlainTimeline),
+    bins: project.bins,
+    rootBinIds: project.rootBinIds,
+    createdAt: project.createdAt,
+    updatedAt: project.updatedAt,
+    schemaVersion: project.schemaVersion
+  };
+  return JSON.stringify(plain, null, 2);
+}
+function deserializeProject(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : "Invalid JSON";
+    throw new SerializationError(msg);
+  }
+  if (!isObject(parsed)) throw new SerializationError("Invalid JSON structure");
+  const obj = parsed;
+  const schemaVersion = obj.schemaVersion;
+  if (typeof schemaVersion !== "number") throw new SerializationError("Missing schemaVersion");
+  if (schemaVersion > CURRENT_SCHEMA_VERSION) {
+    throw new SerializationError(`Unknown project schema version: ${schemaVersion}`);
+  }
+  if (!Array.isArray(obj.timelines)) throw new SerializationError("Missing timelines");
+  const timelines = [];
+  for (const t of obj.timelines) {
+    const state = migrate(t);
+    const violations = checkInvariants(state);
+    if (violations.length > 0) {
+      throw new SerializationError("Timeline failed invariant checks", violations);
+    }
+    timelines.push(state);
+  }
+  const binsRaw = obj.bins;
+  if (binsRaw !== void 0 && !Array.isArray(binsRaw)) throw new SerializationError("Invalid bins");
+  const bins = binsRaw ?? [];
+  for (const b of bins) validateBin(b);
+  const rootBinIdsRaw = obj.rootBinIds;
+  if (rootBinIdsRaw !== void 0 && !Array.isArray(rootBinIdsRaw)) {
+    throw new SerializationError("Invalid rootBinIds");
+  }
+  const rootBinIds = rootBinIdsRaw ?? [];
+  for (const id of rootBinIds) {
+    if (typeof id !== "string") throw new SerializationError("Invalid rootBinIds");
+  }
+  if (typeof obj.id !== "string") throw new SerializationError("Invalid project id");
+  if (typeof obj.name !== "string") throw new SerializationError("Invalid project name");
+  if (typeof obj.createdAt !== "number") throw new SerializationError("Invalid createdAt");
+  if (typeof obj.updatedAt !== "number") throw new SerializationError("Invalid updatedAt");
+  return {
+    id: obj.id,
+    name: obj.name,
+    schemaVersion,
+    createdAt: obj.createdAt,
+    updatedAt: obj.updatedAt,
+    timelines,
+    bins,
+    rootBinIds
+  };
+}
+
+export {
+  createTimeline,
+  toTrackId,
+  createTrack,
+  sortTrackClips,
+  toClipId,
+  createClip,
+  getClipDuration,
+  getClipMediaDuration,
+  clipContainsFrame,
+  clipsOverlap,
+  toAssetId,
+  createAsset,
+  CURRENT_SCHEMA_VERSION,
+  createTimelineState,
+  toFrame,
+  frame,
+  FrameRates,
+  frameRate,
+  toTimecode,
+  isValidFrame,
+  isDropFrame,
+  framesToSeconds,
+  secondsToFrames,
+  framesToTimecode,
+  framesToMinutesSeconds,
+  clampFrame,
+  addFrames,
+  subtractFrames,
+  frameDuration,
+  createHistory,
+  pushHistory,
+  undo,
+  redo,
+  canUndo,
+  canRedo,
+  getCurrentState,
+  findClipById,
+  findTrackById,
+  getClipsOnTrack,
+  getClipsAtFrame,
+  getClipsInRange,
+  getAllClips,
+  getAllTracks,
+  findTrackIndex,
+  validResult,
+  invalidResult,
+  invalidResults,
+  combineResults,
+  registerAsset,
+  getAsset,
+  hasAsset,
+  getAllAssets,
+  unregisterAsset,
+  validateClip,
+  validateTrack,
+  validateTimeline,
+  validateNoOverlap,
+  addClip,
+  removeClip,
+  moveClip,
+  resizeClip,
+  trimClip,
+  updateClip,
+  moveClipToTrack,
+  addTrack,
+  removeTrack,
+  moveTrack,
+  updateTrack,
+  toggleTrackMute,
+  toggleTrackLock,
+  setTimelineDuration,
+  setTimelineName,
+  rippleDelete,
+  rippleTrim,
+  insertEdit,
+  rippleMove,
+  insertMove,
+  TimelineEngine,
+  createAnimatableProperty,
+  DEFAULT_CLIP_TRANSFORM,
+  DEFAULT_AUDIO_PROPERTIES,
+  defaultCaptionStyle,
+  parseSRT,
+  parseVTT,
+  subtitleImportToOps,
+  checkInvariants,
+  dispatch,
+  buildSnapIndex,
+  nearest,
+  toggleSnap,
+  toToolId,
+  createRegistry,
+  activateTool,
+  getActiveTool,
+  registerTool,
+  NoOpTool,
+  createProvisionalManager,
+  setProvisional,
+  clearProvisional,
+  resolveClip,
+  findMarkersByColor,
+  findMarkersByLabel,
+  LINEAR_EASING,
+  HOLD_EASING,
+  toKeyframeId,
+  toEffectId,
+  createEffect,
+  toTransitionId,
+  createTransition,
+  toTrackGroupId,
+  createTrackGroup,
+  toLinkGroupId,
+  createLinkGroup,
+  TransitionTool,
+  KeyframeTool,
+  SerializationError,
+  serializeTimeline,
+  deserializeTimeline,
+  remapAssetPaths,
+  findOfflineAssets,
+  exportToOTIO,
+  importFromOTIO,
+  frameToTimecode,
+  reelName,
+  exportToEDL,
+  exportToAAF,
+  toFCPTime,
+  exportToFCPXML,
+  toProjectId,
+  toBinId,
+  createBin,
+  createProject,
+  addTimeline,
+  removeTimeline,
+  addBin,
+  removeBin,
+  addItemToBin,
+  removeItemFromBin,
+  moveItemBetweenBins,
+  serializeProject,
+  deserializeProject
+};