chore: adiciona .gitignore e commit.command

code/tests/test_models.py

@@ -0,0 +1,841 @@
+"""Tests for FCPXML data models — TimeValue, Timecode, Timeline, and helpers.
+
+Covers the core time math and model properties that underpin all 34 tools.
+"""
+
+import pytest
+
+from fcpxml.models import (
+    Clip,
+    FlashFrame,
+    FlashFrameSeverity,
+    GapInfo,
+    Keyword,
+    Marker,
+    MarkerType,
+    PacingConfig,
+    Project,
+    Timecode,
+    Timeline,
+    TimeValue,
+    ValidationIssue,
+    ValidationIssueType,
+    ValidationResult,
+)
+
+
+class TestTimeValueCreation:
+    """Test TimeValue construction from various input formats."""
+
+    def test_from_rational_string(self):
+        tv = TimeValue.from_timecode("90/30s")
+        assert tv.numerator == 90 and tv.denominator == 30
+
+    def test_from_seconds_string(self):
+        assert TimeValue.from_timecode("5s", fps=24.0).to_seconds() == pytest.approx(5.0, abs=0.01)
+
+    def test_from_seconds_float(self):
+        assert TimeValue.from_seconds(2.5, fps=24.0).to_seconds() == pytest.approx(2.5, abs=0.05)
+
+    def test_from_timecode_hhmmssff(self):
+        assert TimeValue.from_timecode("00:01:30:15", fps=30.0).to_seconds() == pytest.approx(90.5, abs=0.05)
+
+    def test_from_timecode_hhmmss(self):
+        assert TimeValue.from_timecode("00:02:00", fps=24.0).to_seconds() == pytest.approx(120.0, abs=0.05)
+
+    def test_from_frames_string(self):
+        assert TimeValue.from_timecode("48f", fps=24.0).to_seconds() == pytest.approx(2.0, abs=0.05)
+
+    def test_from_plain_number(self):
+        assert TimeValue.from_timecode("3.5", fps=24.0).to_seconds() == pytest.approx(3.5, abs=0.05)
+
+    def test_from_empty_string(self):
+        assert TimeValue.from_timecode("") == TimeValue.zero()
+
+    def test_zero(self):
+        tv = TimeValue.zero()
+        assert tv.numerator == 0 and tv.to_seconds() == 0.0
+
+    def test_invalid_format_raises(self):
+        with pytest.raises(ValueError, match="Invalid timecode format"):
+            TimeValue.from_timecode("not_a_timecode")
+
+    def test_drop_frame_separator(self):
+        assert TimeValue.from_timecode("00:00:10;15", fps=30.0).to_seconds() == pytest.approx(10.5, abs=0.05)
+
+    def test_from_seconds_string_ntsc_rate_exact(self):
+        """23.976fps (24000/1001): int(fps) truncation used to corrupt the
+        value by ~1.04x (317.99s -> 331.48s) because the numerator was
+        computed with the real fps but the denominator was hardcoded to
+        int(fps)=23. The reconstructed value must round-trip exactly."""
+        fps = 24000 / 1001
+        tv = TimeValue.from_timecode("317.9857083333334s", fps=fps)
+        # Half a frame (~0.0417s) of quantization slack is expected/correct;
+        # the bug inflated the value by ~1.04x (to ~331.48s), which this
+        # tolerance would never mask.
+        assert tv.to_seconds() == pytest.approx(317.9857083333334, abs=0.03)
+        assert tv.denominator == 24000
+
+
+class TestTimeValueConversions:
+
+    def test_to_fcpxml(self):
+        assert TimeValue(3, 1).to_fcpxml() == "3s"
+        assert TimeValue(90, 30).to_fcpxml() == "3s"  # simplifies
+        assert TimeValue(75, 30).to_fcpxml() == "75/30s"  # keeps standard timebase denom
+
+    def test_to_seconds(self):
+        assert TimeValue(72, 24).to_seconds() == pytest.approx(3.0)
+        with pytest.raises(ValueError, match="denominator cannot be zero"):
+            TimeValue(5, 0)  # zero denominator rejected at construction
+
+    def test_to_timecode(self):
+        assert TimeValue(2700, 30).to_timecode(fps=30.0) == "00:01:30:00"
+        assert TimeValue(2715, 30).to_timecode(fps=30.0) == "00:01:30:15"
+
+    def test_to_frames(self):
+        assert TimeValue(3, 1).to_frames(fps=24.0) == 72
+
+
+class TestTimeValueArithmetic:
+
+    def test_add(self):
+        assert (TimeValue(72, 24) + TimeValue(48, 24)).to_seconds() == pytest.approx(5.0)
+
+    def test_sub(self):
+        assert (TimeValue(120, 24) - TimeValue(72, 24)).to_seconds() == pytest.approx(2.0)
+
+    def test_add_different_denominators(self):
+        assert (TimeValue(72, 24) + TimeValue(150, 30)).to_seconds() == pytest.approx(8.0)
+
+    def test_mul(self):
+        assert (TimeValue(72, 24) * 2).to_seconds() == pytest.approx(6.0)
+
+    def test_div(self):
+        assert (TimeValue(72, 24) / 3).to_seconds() == pytest.approx(1.0)
+
+    def test_simplify(self):
+        s = TimeValue(120, 48).simplify()
+        assert s.numerator == 5 and s.denominator == 2
+
+    def test_simplify_zero(self):
+        s = TimeValue(0, 48).simplify()
+        assert s.numerator == 0 and s.denominator == 1
+
+
+class TestTimeValueComparisons:
+
+    def test_ordering(self):
+        small, big = TimeValue(48, 24), TimeValue(72, 24)
+        assert small < big and small <= big
+        assert big > small and big >= small
+
+    def test_equality(self):
+        assert TimeValue(72, 24) == TimeValue(72, 24)
+        assert TimeValue(3, 1) == TimeValue(72, 24)  # cross-denominator
+        assert TimeValue(72, 24) != "not a timevalue"
+
+    def test_repr(self):
+        r = repr(TimeValue(72, 24))
+        assert "72" in r and "24" in r and "3.000s" in r
+
+
+class TestTimeline:
+
+    @staticmethod
+    def _make(durations, fps=24.0):
+        clips, offset = [], 0.0
+        for i, dur in enumerate(durations):
+            clips.append(Clip(
+                name=f"clip_{i}",
+                start=Timecode(frames=int(offset * fps), frame_rate=fps),
+                duration=Timecode(frames=int(dur * fps), frame_rate=fps),
+            ))
+            offset += dur
+        return Timeline(
+            name="test",
+            duration=Timecode(frames=int(offset * fps), frame_rate=fps),
+            frame_rate=fps, clips=clips,
+        )
+
+    def test_total_clips(self):
+        assert self._make([2, 3, 1]).total_clips == 3
+
+    def test_total_cuts(self):
+        assert self._make([2, 3, 1]).total_cuts == 2
+        assert self._make([]).total_cuts == 0
+
+    def test_avg_duration(self):
+        assert self._make([2, 4, 6]).average_clip_duration == pytest.approx(4.0, abs=0.1)
+        assert self._make([]).average_clip_duration == 0.0
+
+    def test_cuts_per_minute(self):
+        assert self._make([2, 2, 2]).cuts_per_minute == pytest.approx(20.0, abs=0.5)
+
+    def test_shorter_than(self):
+        assert len(self._make([0.2, 5, 0.3, 2]).get_clips_shorter_than(0.5)) == 2
+
+    def test_longer_than(self):
+        assert len(self._make([1, 10, 2, 15]).get_clips_longer_than(5)) == 2
+
+    def test_clip_at(self):
+        clip = self._make([2, 3, 1]).get_clip_at(3.5)
+        assert clip is not None and clip.name == "clip_1"
+        assert self._make([2, 3]).get_clip_at(999) is None
+
+    def test_by_keyword(self):
+        tl = self._make([2, 3])
+        tl.clips[0].keywords = [Keyword(value="interview")]
+        assert len(tl.get_clips_by_keyword("interview")) == 1
+
+
+class TestProject:
+
+    def test_primary_timeline(self):
+        tl = Timeline(name="main", duration=Timecode(frames=0, frame_rate=24.0))
+        assert Project(name="test", timelines=[tl]).primary_timeline is tl
+
+    def test_primary_timeline_empty(self):
+        assert Project(name="empty").primary_timeline is None
+
+
+class TestMarker:
+
+    def test_youtube_timestamp_minutes(self):
+        m = Marker(name="Ch", start=Timecode(frames=2160, frame_rate=24.0))
+        assert m.to_youtube_timestamp() == "1:30"
+
+    def test_youtube_timestamp_hours(self):
+        m = Marker(name="Act", start=Timecode(frames=24 * 3700, frame_rate=24.0))
+        assert m.to_youtube_timestamp().count(":") == 2
+
+
+class TestTimecode:
+    """Test Timecode — the frame-based time representation used by the parser."""
+
+    def test_from_rational_fraction(self):
+        tc = Timecode.from_rational("3600/24s", frame_rate=24.0)
+        assert tc.frames == 3600
+        assert tc.seconds == pytest.approx(150.0)
+
+    def test_from_rational_whole_seconds(self):
+        tc = Timecode.from_rational("5s", frame_rate=30.0)
+        assert tc.frames == 150
+        assert tc.seconds == pytest.approx(5.0)
+
+    def test_from_rational_plain_number(self):
+        tc = Timecode.from_rational("2.5", frame_rate=24.0)
+        assert tc.frames == 60
+        assert tc.seconds == pytest.approx(2.5)
+
+    def test_from_rational_empty_string(self):
+        tc = Timecode.from_rational("", frame_rate=24.0)
+        assert tc.frames == 0
+
+    def test_to_smpte_basic(self):
+        tc = Timecode(frames=2700, frame_rate=30.0)
+        assert tc.to_smpte() == "00:01:30:00"
+
+    def test_to_smpte_with_frames(self):
+        tc = Timecode(frames=2715, frame_rate=30.0)
+        assert tc.to_smpte() == "00:01:30:15"
+
+    def test_to_smpte_drop_frame_separator(self):
+        tc = Timecode(frames=48, frame_rate=24.0, drop_frame=True)
+        assert ";" in tc.to_smpte()
+
+    def test_to_smpte_hours(self):
+        tc = Timecode(frames=24 * 3661, frame_rate=24.0)
+        smpte = tc.to_smpte()
+        assert smpte.startswith("01:01:01")
+
+    def test_to_rational(self):
+        tc = Timecode(frames=72, frame_rate=24.0)
+        assert tc.to_rational() == "72/24s"
+
+    def test_to_time_value(self):
+        tc = Timecode(frames=72, frame_rate=24.0)
+        tv = tc.to_time_value()
+        assert tv.numerator == 72
+        assert tv.denominator == 24
+        assert tv.to_seconds() == pytest.approx(3.0)
+
+    def test_total_frames_alias(self):
+        tc = Timecode(frames=100, frame_rate=30.0)
+        assert tc.total_frames == 100
+
+
+class TestClipProperties:
+    """Test Clip computed properties."""
+
+    def test_end_timecode(self):
+        clip = Clip(
+            name="test",
+            start=Timecode(frames=48, frame_rate=24.0),
+            duration=Timecode(frames=72, frame_rate=24.0),
+        )
+        assert clip.end.frames == 120
+        assert clip.end.frame_rate == 24.0
+
+    def test_duration_seconds(self):
+        clip = Clip(
+            name="test",
+            start=Timecode(frames=0, frame_rate=24.0),
+            duration=Timecode(frames=72, frame_rate=24.0),
+        )
+        assert clip.duration_seconds == pytest.approx(3.0)
+
+    def test_keyword_values(self):
+        clip = Clip(
+            name="test",
+            start=Timecode(frames=0, frame_rate=24.0),
+            duration=Timecode(frames=24, frame_rate=24.0),
+            keywords=[Keyword(value="interview"), Keyword(value="broll")],
+        )
+        assert clip.keyword_values == ["interview", "broll"]
+
+    def test_keyword_values_empty(self):
+        clip = Clip(
+            name="test",
+            start=Timecode(frames=0, frame_rate=24.0),
+            duration=Timecode(frames=24, frame_rate=24.0),
+        )
+        assert clip.keyword_values == []
+
+
+class TestFlashFrame:
+
+    def test_is_critical(self):
+        ff = FlashFrame(
+            clip_name="bad_clip", clip_id="c1",
+            start=Timecode(frames=0, frame_rate=24.0),
+            duration_frames=1, duration_seconds=0.04,
+            severity=FlashFrameSeverity.CRITICAL,
+        )
+        assert ff.is_critical is True
+
+    def test_is_not_critical(self):
+        ff = FlashFrame(
+            clip_name="short_clip", clip_id="c2",
+            start=Timecode(frames=0, frame_rate=24.0),
+            duration_frames=4, duration_seconds=0.17,
+            severity=FlashFrameSeverity.WARNING,
+        )
+        assert ff.is_critical is False
+
+
+class TestGapInfo:
+
+    def test_timecode_property(self):
+        gap = GapInfo(
+            start=Timecode(frames=2700, frame_rate=30.0),
+            duration_frames=30, duration_seconds=1.0,
+            previous_clip="Clip_A", next_clip="Clip_B",
+        )
+        assert gap.timecode == "00:01:30:00"
+
+
+class TestValidationResult:
+
+    def test_summary_format(self):
+        result = ValidationResult(
+            is_valid=False, health_score=72,
+            issues=[
+                ValidationIssue(issue_type=ValidationIssueType.FLASH_FRAME, severity="error", message="e"),
+                ValidationIssue(issue_type=ValidationIssueType.GAP, severity="warning", message="w"),
+            ],
+            flash_frames=[
+                FlashFrame("c", "c1", Timecode(0, 24.0), 1, 0.04, FlashFrameSeverity.CRITICAL),
+            ],
+            gaps=[
+                GapInfo(Timecode(0, 24.0), 10, 0.4),
+            ],
+        )
+        s = result.summary()
+        assert "72%" in s
+        assert "Errors: 1" in s
+        assert "Warnings: 1" in s
+        assert "Flash frames: 1" in s
+        assert "Gaps: 1" in s
+
+
+class TestMarkerType:
+
+    @pytest.mark.parametrize("value,expected", [
+        ("todo", MarkerType.INCOMPLETE),       # enum value, not an action item
+        ("TODO", MarkerType.INCOMPLETE),       # enum value, not an action item  # noqa
+        ("completed", MarkerType.COMPLETED),
+        ("COMPLETED", MarkerType.COMPLETED),
+        ("standard", MarkerType.STANDARD),
+        ("chapter", MarkerType.CHAPTER),
+    ])
+    def test_from_string_current_values(self, value, expected):
+        assert MarkerType.from_string(value) == expected
+
+    @pytest.mark.parametrize("alias,expected", [
+        ("todo-marker", MarkerType.INCOMPLETE),
+        ("completed-marker", MarkerType.COMPLETED),
+        ("chapter-marker", MarkerType.CHAPTER),
+    ])
+    def test_from_string_legacy_aliases(self, alias, expected):
+        """Legacy spec values (e.g. 'todo-marker') resolve to current enum."""
+        assert MarkerType.from_string(alias) == expected
+
+    @pytest.mark.parametrize("value,expected", [
+        ("Todo", MarkerType.INCOMPLETE),
+        ("tOdO", MarkerType.INCOMPLETE),
+        ("Completed", MarkerType.COMPLETED),
+        ("cOMPLETED", MarkerType.COMPLETED),
+        ("Standard", MarkerType.STANDARD),
+        ("CHAPTER", MarkerType.CHAPTER),
+    ])
+    def test_from_string_mixed_case(self, value, expected):
+        """Case should never matter — FCP specs are inconsistent about casing."""
+        assert MarkerType.from_string(value) == expected
+
+    @pytest.mark.parametrize("alias,expected", [
+        ("  todo-marker  ", MarkerType.INCOMPLETE),
+        (" completed-marker ", MarkerType.COMPLETED),
+        ("\tchapter-marker\t", MarkerType.CHAPTER),
+    ])
+    def test_from_string_legacy_aliases_with_whitespace(self, alias, expected):
+        """Whitespace around legacy aliases must be stripped before matching."""
+        assert MarkerType.from_string(alias) == expected
+
+    def test_enum_values_are_lowercase(self):
+        """Enum .value must be lowercase strings — they're used as dict keys."""
+        assert MarkerType.INCOMPLETE.value == "todo"
+        assert MarkerType.COMPLETED.value == "completed"
+        assert MarkerType.STANDARD.value == "standard"
+        assert MarkerType.CHAPTER.value == "chapter"
+
+    def test_from_string_invalid_raises(self):
+        with pytest.raises(ValueError, match="Invalid marker type"):
+            MarkerType.from_string("nonexistent")
+
+    def test_xml_tag_chapter_vs_marker(self):
+        assert MarkerType.CHAPTER.xml_tag == "chapter-marker"
+        assert MarkerType.INCOMPLETE.xml_tag == "marker"
+        assert MarkerType.COMPLETED.xml_tag == "marker"
+        assert MarkerType.STANDARD.xml_tag == "marker"
+
+
+class TestMarkerTypeXmlContract:
+    """Tests for MarkerType.from_xml_element and xml_attrs — the unified
+    serialization contract that both parser and writer depend on."""
+
+    def test_from_xml_element_chapter(self):
+        import xml.etree.ElementTree as ET
+        elem = ET.Element('chapter-marker')
+        assert MarkerType.from_xml_element(elem) == MarkerType.CHAPTER
+
+    def test_from_xml_element_todo(self):
+        import xml.etree.ElementTree as ET
+        elem = ET.Element('marker')
+        elem.set('completed', '0')
+        assert MarkerType.from_xml_element(elem) == MarkerType.INCOMPLETE
+
+    def test_from_xml_element_completed(self):
+        import xml.etree.ElementTree as ET
+        elem = ET.Element('marker')
+        elem.set('completed', '1')
+        assert MarkerType.from_xml_element(elem) == MarkerType.COMPLETED
+
+    def test_from_xml_element_standard(self):
+        import xml.etree.ElementTree as ET
+        elem = ET.Element('marker')
+        assert MarkerType.from_xml_element(elem) == MarkerType.STANDARD
+
+    def test_from_xml_element_rejects_malformed_completed(self):
+        """Non-standard completed values (e.g. 'true') must fall to STANDARD."""
+        import xml.etree.ElementTree as ET
+        elem = ET.Element('marker')
+        elem.set('completed', 'true')
+        assert MarkerType.from_xml_element(elem) == MarkerType.STANDARD
+
+    def test_from_xml_element_whitespace_padded_zero_is_standard(self):
+        """Whitespace around '0' must NOT match INCOMPLETE — strict exact matching."""
+        import xml.etree.ElementTree as ET
+        elem = ET.Element('marker')
+        elem.set('completed', ' 0 ')
+        assert MarkerType.from_xml_element(elem) == MarkerType.STANDARD
+
+    def test_from_xml_element_whitespace_padded_one_is_standard(self):
+        """Whitespace around '1' must NOT match COMPLETED — strict exact matching."""
+        import xml.etree.ElementTree as ET
+        elem = ET.Element('marker')
+        elem.set('completed', ' 1 ')
+        assert MarkerType.from_xml_element(elem) == MarkerType.STANDARD
+
+    def test_from_xml_element_empty_completed_is_standard(self):
+        """An empty completed='' attribute must fall to STANDARD, not INCOMPLETE."""
+        import xml.etree.ElementTree as ET
+        elem = ET.Element('marker')
+        elem.set('completed', '')
+        assert MarkerType.from_xml_element(elem) == MarkerType.STANDARD
+
+    def test_from_xml_element_chapter_ignores_completed(self):
+        """A chapter-marker tag takes priority over any completed attribute."""
+        import xml.etree.ElementTree as ET
+        elem = ET.Element('chapter-marker')
+        elem.set('completed', '0')
+        assert MarkerType.from_xml_element(elem) == MarkerType.CHAPTER
+
+    def test_xml_attrs_todo(self):
+        assert MarkerType.INCOMPLETE.xml_attrs == {'completed': '0'}
+
+    def test_xml_attrs_completed(self):
+        assert MarkerType.COMPLETED.xml_attrs == {'completed': '1'}
+
+    def test_xml_attrs_chapter(self):
+        assert MarkerType.CHAPTER.xml_attrs == {'posterOffset': '0s'}
+
+    def test_xml_attrs_standard_empty(self):
+        assert MarkerType.STANDARD.xml_attrs == {}
+
+    def test_roundtrip_symmetry(self):
+        """from_xml_element(write(type)) == type for all marker types."""
+        import xml.etree.ElementTree as ET
+        for mt in MarkerType:
+            elem = ET.Element(mt.xml_tag)
+            for attr, val in mt.xml_attrs.items():
+                elem.set(attr, val)
+            assert MarkerType.from_xml_element(elem) == mt
+
+
+class TestTimeValueSnapToFrame:
+    """Tests for TimeValue.snap_to_frame — 2400-tick frame boundary snapping."""
+
+    def test_snap_exact_frame_is_noop(self):
+        """A value already on a frame boundary stays unchanged."""
+        tv = TimeValue(100, 2400)  # exactly 1 frame at 24fps (2400/24=100 ticks)
+        snapped = tv.snap_to_frame(24)
+        assert snapped.to_seconds() == pytest.approx(tv.to_seconds(), abs=1e-6)
+
+    def test_snap_between_frames_rounds_nearest(self):
+        """A value between frames snaps to the nearest one."""
+        # 1.5 frames at 24fps = 150 ticks. Should snap to 100 or 200.
+        tv = TimeValue(150, 2400)
+        snapped = tv.snap_to_frame(24)
+        assert snapped.denominator == 2400
+        assert snapped.numerator in (100, 200)
+
+    def test_snap_30fps_frame_boundaries(self):
+        """30fps: each frame = 80 ticks. 85 ticks should snap to 80."""
+        tv = TimeValue(85, 2400)
+        snapped = tv.snap_to_frame(30)
+        assert snapped.numerator == 80
+        assert snapped.denominator == 2400
+
+    def test_snap_preserves_zero(self):
+        tv = TimeValue(0, 24).snap_to_frame(24)
+        assert tv.to_seconds() == 0.0
+
+    def test_snap_large_value_stays_aligned(self):
+        """10 seconds at 24fps should remain exactly 10 seconds."""
+        tv = TimeValue(240, 24)  # 10s
+        snapped = tv.snap_to_frame(24)
+        assert snapped.to_seconds() == pytest.approx(10.0, abs=1e-6)
+
+
+class TestTimeValueStandardTimebase:
+    """Tests for TimeValue.is_standard_timebase — FCP DTD denominator checks."""
+
+    @pytest.mark.parametrize("denom", [1, 24, 30, 60, 2400])
+    def test_standard_denominators_accepted(self, denom):
+        assert TimeValue(denom, denom).is_standard_timebase() is True
+
+    def test_non_standard_denominator_rejected(self):
+        """Denominators like 7 are not in any FCP timebase."""
+        assert TimeValue(7, 7).is_standard_timebase() is True  # simplifies to 1/1
+        assert TimeValue(3, 7).is_standard_timebase() is False
+
+    def test_simplification_reveals_standard(self):
+        """72/24 simplifies to 3/1 — denominator 1 is standard."""
+        assert TimeValue(72, 24).is_standard_timebase() is True
+
+    def test_simplification_reveals_non_standard(self):
+        """15/7 doesn't simplify to a standard timebase."""
+        assert TimeValue(15, 7).is_standard_timebase() is False
+
+
+class TestTimeValueToFcpxmlEdgeCases:
+    """Tests for to_fcpxml fallback paths that prevent FCP DTD rejection."""
+
+    def test_whole_seconds_simplify(self):
+        """72/24 = 3 whole seconds → '3s'."""
+        assert TimeValue(72, 24).to_fcpxml() == "3s"
+
+    def test_standard_timebase_simplifies(self):
+        """75/30 simplifies to 5/2 — but 2 is not standard, so stays '75/30s'."""
+        result = TimeValue(75, 30).to_fcpxml()
+        # Should NOT produce "5/2s" since 2 isn't a standard timebase
+        assert "/2s" not in result or "75/30s" == result
+
+    def test_non_standard_denom_falls_back_to_original(self):
+        """If simplification yields a non-standard denom, keep the original."""
+        # 7 ticks at denom 21 → simplifies to 1/3. 3 is non-standard.
+        # Should fall back to "7/21s"
+        tv = TimeValue(7, 21)
+        result = tv.to_fcpxml()
+        assert result == "7/21s"
+
+    def test_zero_is_always_zero_seconds(self):
+        assert TimeValue(0, 2400).to_fcpxml() == "0s"
+
+
+class TestTimeValueArithmeticEdgeCases:
+    """Edge cases in TimeValue arithmetic that could produce incorrect frame values."""
+
+    def test_sub_negative_result(self):
+        """Subtraction producing negative time — used for offset calculations."""
+        result = TimeValue(24, 24) - TimeValue(72, 24)
+        assert result.to_seconds() == pytest.approx(-2.0)
+
+    def test_mul_by_zero(self):
+        assert (TimeValue(72, 24) * 0).to_seconds() == 0.0
+
+    def test_div_preserves_value(self):
+        """Division should maintain the time value, not produce rounding drift."""
+        tv = TimeValue(72, 24)  # 3 seconds
+        halved = tv / 2
+        assert halved.to_seconds() == pytest.approx(1.5, abs=1e-6)
+
+    def test_div_fractional_scalar_rounds_not_truncates(self):
+        """Division by fractional scalar must round denominator, not truncate.
+
+        int(2400 * 0.3333...) = 799 (truncation bug), round() = 800 (correct).
+        This was the root cause of silent time drift in speed-change operations.
+        """
+        tv = TimeValue(100, 2400)
+        result = tv / (1 / 3)  # divide by 0.333... → multiply duration by 3
+        assert result.denominator == 800  # round(2400 * 0.333...) = 800
+        assert result.to_seconds() == pytest.approx(0.125, abs=1e-6)
+
+    def test_div_by_zero_raises_not_corrupts(self):
+        """Division by zero must raise, not create zombie TimeValue(n, 0)."""
+        tv = TimeValue(100, 2400)
+        with pytest.raises(ZeroDivisionError):
+            tv / 0
+
+    def test_div_rounding_to_zero_raises(self):
+        """Small scalars that round denominator to zero must raise, not corrupt."""
+        tv = TimeValue(1, 1)
+        with pytest.raises(ZeroDivisionError, match="rounds denominator"):
+            tv / 0.3  # round(1 * 0.3) = 0
+
+    def test_div_mul_roundtrip(self):
+        """Multiply then divide should approximately restore original value."""
+        tv = TimeValue(72, 24)  # 3 seconds
+        scaled = tv * 2.5
+        restored = scaled / 2.5
+        assert restored.to_seconds() == pytest.approx(tv.to_seconds(), abs=0.01)
+
+    def test_add_mismatched_timebases_lcm(self):
+        """24fps + 30fps values should use LCM denominator, not multiply."""
+        a = TimeValue(24, 24)  # 1 second
+        b = TimeValue(30, 30)  # 1 second
+        result = a + b
+        assert result.to_seconds() == pytest.approx(2.0)
+        # LCM(24,30)=120, not 24*30=720
+        assert result.denominator <= 720  # at minimum, shouldn't explode
+
+    def test_equality_across_timebases(self):
+        """1 second expressed in different timebases must be equal."""
+        assert TimeValue(24, 24) == TimeValue(30, 30) == TimeValue(2400, 2400)
+
+    def test_inequality_near_boundary(self):
+        """Integer-exact comparison: different rational values are never equal."""
+        a = TimeValue(24000, 24000)  # exactly 1s
+        b = TimeValue(24001, 24000)  # 1.0000417s
+        # Cross-multiplication gives exact comparison — no epsilon
+        assert a != b  # genuinely different values
+
+    def test_mul_fractional_scalar_rounds_correctly(self):
+        """Multiplying by 0.5 must round, not truncate — avoids half-tick loss."""
+        # round(101 * 0.5) = 50 vs int(101 * 0.5) = 50 — same here, but
+        # round is correct for odd numerators like 5 * 1.5:
+        tv = TimeValue(5, 24)
+        result = tv * 1.5
+        # round(7.5) = 8, int(7.5) = 7 — round gives closer-to-correct result
+        assert result.numerator == 8
+        assert result.to_seconds() == pytest.approx(8 / 24, abs=1e-6)
+
+    def test_hash_equal_values_same_hash(self):
+        """Equal TimeValues must produce the same hash (dict/set contract)."""
+        a = TimeValue(24, 24)
+        b = TimeValue(30, 30)
+        assert a == b
+        assert hash(a) == hash(b)
+
+    def test_hash_usable_in_set(self):
+        """TimeValues must be usable as set elements."""
+        s = {TimeValue(24, 24), TimeValue(30, 30), TimeValue(72, 24)}
+        # 24/24 == 30/30 (both 1s), so set should have 2 elements
+        assert len(s) == 2
+
+    def test_hash_usable_as_dict_key(self):
+        """TimeValues must be usable as dict keys."""
+        d = {TimeValue(24, 24): "one_second"}
+        assert d[TimeValue(30, 30)] == "one_second"
+
+
+class TestMarkerTypeAliasSemantics:
+    """MarkerType enum alias: TODO → INCOMPLETE (Python enum identity, not action items)."""
+
+    def test_todo_alias_resolves_to_incomplete(self):
+        """All alias properties match — identity, value, xml_tag, xml_attrs."""
+        assert MarkerType.INCOMPLETE is MarkerType.TODO  # enum alias check  # noqa
+        assert MarkerType.INCOMPLETE.value == "todo"
+        assert MarkerType.INCOMPLETE.xml_tag == "marker"
+        assert MarkerType.INCOMPLETE.xml_attrs == {'completed': '0'}
+
+    def test_from_string_returns_canonical(self):
+        """from_string('todo') returns the canonical INCOMPLETE member."""
+        assert MarkerType.from_string("todo") is MarkerType.INCOMPLETE
+
+    def test_from_xml_element_numeric_completed_values(self):
+        """Only exact '0' and '1' are recognised — '2', '-1', '00' are STANDARD."""
+        import xml.etree.ElementTree as ET
+        for bad_val in ('2', '-1', '00', '01', '10'):
+            elem = ET.Element('marker')
+            elem.set('completed', bad_val)
+            assert MarkerType.from_xml_element(elem) == MarkerType.STANDARD, (
+                f"completed='{bad_val}' should be STANDARD, not a task marker"
+            )
+
+
+class TestTimecodeEdgeCases:
+    """Edge cases in Timecode that could cause silent bugs in the parser."""
+
+    def test_zero_frames_smpte(self):
+        assert Timecode(frames=0, frame_rate=24.0).to_smpte() == "00:00:00:00"
+
+    def test_one_frame_smpte(self):
+        assert Timecode(frames=1, frame_rate=24.0).to_smpte() == "00:00:00:01"
+
+    def test_exactly_one_hour(self):
+        tc = Timecode(frames=24 * 3600, frame_rate=24.0)
+        assert tc.to_smpte() == "01:00:00:00"
+        assert tc.seconds == pytest.approx(3600.0)
+
+    def test_to_time_value_roundtrip(self):
+        """Timecode → TimeValue → seconds should be lossless."""
+        tc = Timecode(frames=2715, frame_rate=30.0)
+        tv = tc.to_time_value()
+        assert tv.to_seconds() == pytest.approx(tc.seconds, abs=1e-6)
+
+
+class TestTimeValueNegativeDenominator:
+    """Negative denominators must be normalized to preserve hash/eq/ordering."""
+
+    def test_negative_denom_normalized_at_construction(self):
+        tv = TimeValue(1, -2)
+        assert tv.numerator == -1
+        assert tv.denominator == 2
+
+    def test_negative_denom_both_negative(self):
+        tv = TimeValue(-3, -4)
+        assert tv.numerator == 3
+        assert tv.denominator == 4
+
+    def test_hash_contract_negative_denom(self):
+        """Equal values must produce identical hashes (Python data model)."""
+        a = TimeValue(-1, 1)
+        b = TimeValue(1, -1)
+        assert a == b
+        assert hash(a) == hash(b)
+
+    def test_set_dedup_negative_denom(self):
+        s = {TimeValue(-1, 1), TimeValue(1, -1)}
+        assert len(s) == 1
+
+    def test_lt_negative_denom(self):
+        assert TimeValue(1, -2) < TimeValue(1, 2)   # -0.5 < 0.5
+        assert not (TimeValue(1, 2) < TimeValue(1, -2))
+
+    def test_division_by_negative_normalizes(self):
+        tv = TimeValue(100, 2400) / -2.0
+        assert tv.denominator > 0
+        assert tv.to_seconds() == pytest.approx(-100 / 4800, abs=1e-9)
+
+    def test_to_fcpxml_negative_denom(self):
+        """Normalized negative should serialize cleanly."""
+        tv = TimeValue(1, -2400)
+        assert tv.to_fcpxml() == "-1/2400s"
+
+
+class TestTimeValueCrossMultiplicationEdgeCases:
+    """Verify integer-exact comparison survives edge cases that broke float-based comparison."""
+
+    def test_eq_non_timevalue_returns_false(self):
+        """__eq__ with non-TimeValue must return False, not raise."""
+        assert TimeValue(1, 1) != 1
+        assert TimeValue(1, 1) != 1.0
+        assert TimeValue(1, 1) != "1/1s"
+        assert TimeValue(0, 1) != None  # noqa: E711
+
+    def test_total_ordering_le_gt_ge(self):
+        """@total_ordering derives __le__/__gt__/__ge__ from __lt__+__eq__.
+        If the decorator were removed, these would raise TypeError."""
+        a, b = TimeValue(1, 3), TimeValue(2, 3)
+        assert a <= b
+        assert a <= TimeValue(1, 3)  # equal case
+        assert b > a
+        assert b >= a
+        assert b >= TimeValue(2, 3)  # equal case
+
+    def test_large_numerator_cross_multiply(self):
+        """Python arbitrary precision means cross-multiplication never overflows,
+        but verify the comparison is actually correct with big numbers."""
+        big = TimeValue(2**60, 1)
+        small = TimeValue(1, 2**60)
+        assert small < big
+        assert big > small
+        assert big != small
+
+    def test_hash_contract_different_denominators(self):
+        """Equivalent fractions must hash identically for dict/set correctness."""
+        a = TimeValue(100, 2400)
+        b = TimeValue(50, 1200)
+        c = TimeValue(1, 24)
+        assert a == b == c
+        assert hash(a) == hash(b) == hash(c)
+        assert len({a, b, c}) == 1
+
+    def test_zero_numerator_negative_denom(self):
+        """Zero with negative denominator normalizes cleanly."""
+        tv = TimeValue(0, -1)
+        assert tv.numerator == 0
+        assert tv.denominator == 1
+        assert tv == TimeValue(0, 1)
+        assert hash(tv) == hash(TimeValue(0, 1))
+
+    def test_comparison_transitivity(self):
+        """If a < b and b < c then a < c — cross-multiplication must be transitive."""
+        a = TimeValue(1, 7)
+        b = TimeValue(1, 5)
+        c = TimeValue(1, 3)
+        assert a < b < c
+        assert a < c  # transitive
+
+    def test_sorted_rational_sequence(self):
+        """Sort a sequence of TimeValues and verify order matches float values."""
+        vals = [TimeValue(n, 24) for n in [72, 12, 48, 24, 36]]
+        sorted_vals = sorted(vals)
+        sorted_seconds = [v.to_seconds() for v in sorted_vals]
+        assert sorted_seconds == sorted(sorted_seconds)
+
+    def test_simplify_preserves_positive_denom(self):
+        """After simplify(), denominator must remain positive (regression guard)."""
+        tv = TimeValue(-600, 2400).simplify()
+        assert tv.denominator > 0
+        assert tv.to_seconds() == pytest.approx(-0.25, abs=1e-9)
+
+
+class TestPacingConfig:
+
+    def test_pacing_ranges(self):
+        assert PacingConfig(pacing="slow").get_duration_range() == (5.0, 10.0)
+        assert PacingConfig(pacing="fast").get_duration_range() == (0.5, 2.0)
+        assert PacingConfig(pacing="unknown").get_duration_range() == (2.0, 5.0)