Adding some fixes

gnommo/transformer.py

@@ -760,27 +760,57 @@ def _extract_slide_events(
 
     Each slide starts at its own marker timestamp and ends when the next
     slide's marker appears. Before the first slide, no slide is shown.
+
+    Slides that could not be aligned (timestamp < 0) have their position
+    interpolated evenly between the surrounding aligned slides rather than
+    being excluded.
     """
     range_start, range_end = time_range if time_range else (0.0, float("inf"))
 
-    # Get slide markers in manuscript order (not sorted by timestamp!)
-    # The order in marker_timings reflects manuscript order
-    slide_markers: list[tuple[float, str]] = []
+    # Get ALL slide markers in manuscript order (aligned and unaligned)
+    all_slide_markers: list[tuple[float, str]] = []
     for timing in marker_timings:
-        if timing.marker_id in slides and timing.timestamp >= 0:
-            slide_markers.append((timing.timestamp, timing.marker_id))
+        if timing.marker_id in slides:
+            all_slide_markers.append((timing.timestamp, timing.marker_id))
 
-    if not slide_markers:
+    if not all_slide_markers:
         return []
 
+    # Interpolate timestamps for unaligned slides (timestamp < 0).
+    # For each run of consecutive unaligned slides, spread them evenly between
+    # the nearest aligned slides before and after in manuscript order.
+    n = len(all_slide_markers)
+    resolved: list[tuple[float, str]] = list(all_slide_markers)
+
+    i = 0
+    while i < n:
+        if resolved[i][0] < 0:
+            run_start = i
+            while i < n and resolved[i][0] < 0:
+                i += 1
+            run_end = i  # exclusive
+
+            prev_time = resolved[run_start - 1][0] if run_start > 0 else 0.0
+            next_time = resolved[run_end][0] if run_end < n else total_duration
+
+            count = run_end - run_start
+            for j, idx in enumerate(range(run_start, run_end)):
+                frac = (j + 1) / (count + 1)
+                resolved[idx] = (
+                    prev_time + (next_time - prev_time) * frac,
+                    resolved[idx][1],
+                )
+        else:
+            i += 1
+
     events: list[SlideEvent] = []
-    for i, (marker_time, marker_id) in enumerate(slide_markers):
+    for i, (marker_time, marker_id) in enumerate(resolved):
         # Each slide starts at its own marker time
         start_time = marker_time
 
         # End time is when the NEXT slide's marker appears, or end of video
-        if i + 1 < len(slide_markers):
-            end_time = slide_markers[i + 1][0]
+        if i + 1 < len(resolved):
+            end_time = resolved[i + 1][0]
         else:
             end_time = total_duration