@webpacked-timeline/core 1.0.0-beta.1

package/dist/chunk-NXG52532.js

@@ -0,0 +1,2230 @@
+// 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
+  };
+}
+
+// src/types/track.ts
+var toTrackId = (s) => s;
+function createTrack(params) {
+  return {
+    id: params.id,
+    name: params.name,
+    type: params.type,
+    clips: params.clips ?? [],
+    locked: params.locked ?? false,
+    muted: params.muted ?? false,
+    solo: params.solo ?? false,
+    height: params.height ?? 56
+  };
+}
+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 ?? {}
+  };
+}
+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 {
+    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"
+  };
+}
+
+// src/types/state.ts
+var CURRENT_SCHEMA_VERSION = 1;
+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/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);
+  }
+  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);
+  }
+}
+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.`
+    });
+  }
+}
+
+// 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;
+      if (!isCrossTrack) {
+        return updateClip2(state, op.clipId, () => movedClip);
+      }
+      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;
+      });
+      return { ...state, timeline: { ...state.timeline, tracks: newTracks } };
+    }
+    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 }
+        }
+      };
+    }
+  }
+}
+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);
+    // All other ops are always valid at the primitive level
+    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 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;
+}
+
+// src/engine/dispatcher.ts
+function dispatch(state, transaction) {
+  for (const op of transaction.operations) {
+    const rejection = validateOperation(state, op);
+    if (rejection) {
+      return {
+        accepted: false,
+        reason: rejection.reason,
+        message: rejection.message
+      };
+    }
+  }
+  let proposedState = state;
+  for (const op of transaction.operations) {
+    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__"
+  });
+  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;
+}
+
+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,
+  checkInvariants,
+  dispatch,
+  buildSnapIndex,
+  nearest,
+  toggleSnap,
+  toToolId,
+  createRegistry,
+  activateTool,
+  getActiveTool,
+  registerTool,
+  NoOpTool,
+  createProvisionalManager,
+  setProvisional,
+  clearProvisional,
+  resolveClip
+};