riplex 0.8.0__tar.gz → 0.9.0__tar.gz

{riplex-0.8.0/src/riplex.egg-info → riplex-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: riplex
-Version: 0.8.0
+Version: 0.9.0
 Summary: Automates the tedious manual work around MakeMKV: figuring out what to rip, which MKV files are actually what, and organizing everything into Plex-compatible folder structures.
 License: MIT
 Requires-Python: >=3.11

{riplex-0.8.0 → riplex-0.9.0}/docs/changelog.md

@@ -4,6 +4,27 @@ All notable changes to the riplex documentation are recorded here.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/).
 
+## v0.9.0 — 2026-06-13
+
+Summary: Plex-aligned movie version and edition support for combo-disc releases, with better organize preview matching for 4K, Blu-ray, and 3D movie rips.
+
+### Added
+
+- **Plex movie versions and editions.** Movie organization now distinguishes Plex versions, such as `4k` and `1080p`, from Plex editions, such as `{edition-3D}`. Multiple 2D resolutions are organized together in the base movie folder, while 3D rips are organized as a separate Plex edition folder.
+- **3D movie edition output.** 3D movie rips now use Plex's edition naming convention in both folder and file names, for example `Movie Title (Year) {edition-3D}/Movie Title (Year) - 1080p {edition-3D}.mkv`.
+- **Combo-pack movie matching.** Multi-disc releases with separate 4K, Blu-ray, and 3D film discs now match each main feature independently so the 4K movie, standard 1080p movie, and 3D edition can all be organized from the same release.
+
+### Changed
+
+- **2D is treated as the base movie, not an edition.** dvdcompare labels such as `2D` are still useful for matching disc targets, but the organized Plex output keeps 2D files in the normal `Movie Title (Year)` folder instead of creating `{edition-2D}` folders.
+- **Resolution suffixes are inferred from scanned video dimensions.** Standard Blu-ray movie rips now receive a `- 1080p` suffix when ffprobe reports 1920x1080 video, matching the existing `- 4k` behavior for 2160p content.
+- **Duplicate bonus features no longer clutter the missing list.** If the same bonus feature appears on multiple discs and one copy is matched, equivalent duplicate targets from other present discs are suppressed from the organize preview's missing section.
+
+### Fixed
+
+- **4K main feature skipped in 4K + 3D combo releases.** Multi-edition film entries on a separate 3D/2D Blu-ray disc no longer suppress the generic movie target needed to match a separate 4K film disc.
+- **Matched extras still shown as missing.** Duplicate extras such as `Behind The Scenes` and `Humpback Whales` no longer appear under missing after one copy has already been matched and planned for organization.
+
 ## v0.8.0 — 2026-06-12
 
 ### Added

{riplex-0.8.0 → riplex-0.9.0}/src/riplex/disc/analysis.py

@@ -16,6 +16,7 @@ _EDITION_RE = re.compile(
     r"((?:Extended|Director'?s|Unrated|Ultimate|Special|Theatrical)\s+(?:Cut|Edition|Version))",
     re.IGNORECASE,
 )
+_FORMAT_EDITION_RE = re.compile(r"\b(3D|2D|IMAX|Open Matte)\b", re.IGNORECASE)
 
 # Feature types that indicate featurette/bonus content (not episodes)
 _FEATURETTE_PLAY_ALL_TYPES = frozenset({
@@ -72,6 +73,70 @@ def _detect_edition_name(
     return candidates[0]
 
 
+def _extract_movie_edition(text: str) -> str | None:
+    """Extract a movie edition label from dvdcompare film-entry text."""
+    m = _EDITION_RE.search(text)
+    if m:
+        return m.group(1)
+    m = _FORMAT_EDITION_RE.search(text)
+    if not m:
+        return None
+    value = m.group(1)
+    if value.lower() == "open matte":
+        return "Open Matte"
+    return value.upper()
+
+
+def _apply_movie_variant_classifications(
+    classifications: dict[int, str],
+    titles: list,
+    current_disc_entries: list,
+    movie_runtime: int | None,
+) -> None:
+    """Label same-runtime movie variants such as 3D/2D using dvdcompare hints."""
+    if not movie_runtime:
+        return
+
+    film_entries = []
+    for disc in current_disc_entries:
+        if not getattr(disc, "is_film", False):
+            continue
+        for extra in getattr(disc, "extras", []):
+            title = getattr(extra, "title", "")
+            if not title.lower().startswith("the film"):
+                continue
+            edition = _extract_movie_edition(title)
+            if edition:
+                film_entries.append((edition, getattr(extra, "runtime_seconds", 0) or 0))
+
+    if len(film_entries) < 2:
+        return
+
+    candidate_titles = [
+        title for title in titles
+        if abs(title.duration_seconds - movie_runtime) < 60
+        and classifications.get(title.index, "").startswith("MAIN FILM")
+    ]
+    if len(candidate_titles) < 2:
+        return
+
+    edition_names = [edition for edition, _ in film_entries]
+    has_3d_2d = "3D" in edition_names and "2D" in edition_names
+    if has_3d_2d:
+        sorted_entries = sorted(film_entries, key=lambda entry: 0 if entry[0] == "3D" else 1)
+        sorted_titles = sorted(candidate_titles, key=lambda title: title.size_bytes, reverse=True)
+    else:
+        sorted_entries = sorted(
+            film_entries,
+            key=lambda entry: 0 if "theatrical" in entry[0].lower() else 1,
+        )
+        sorted_titles = sorted(candidate_titles, key=lambda title: title.duration_seconds)
+
+    for title, (edition, _) in zip(sorted_titles, sorted_entries):
+        res_label = "4K" if "3840" in (title.resolution or "") else "1080p"
+        classifications[title.index] = f"{edition} Edition ({res_label})"
+
+
 def format_seconds(seconds: int) -> str:
     """Format seconds as MM:SS or H:MM:SS."""
     m, s = divmod(seconds, 60)
@@ -593,6 +658,10 @@ def analyze_disc(
             t, titles, dvd_entries, is_movie, effective_movie_runtime,
             total_episode_runtime, episode_count,
         )
+    if is_movie:
+        _apply_movie_variant_classifications(
+            classifications, titles, current_disc_entries, effective_movie_runtime,
+        )
 
     return DiscAnalysis(
         disc_number=disc_number,

{riplex-0.8.0 → riplex-0.9.0}/src/riplex/matcher.py

@@ -188,6 +188,24 @@ def _is_unidentified(classification: str) -> bool:
         return False
     return classification.startswith(_UNIDENTIFIED_CLASSIFICATION_PREFIXES)
 
+
+_DISC_LABEL_PREFIX_RE = re.compile(r"^Disc\s+\d+:\s*", re.IGNORECASE)
+_TRAILING_TYPE_RE = re.compile(
+    r"\s+\((?:featurette|documentary|interview|interviews|deleted scenes?|trailer|trailers|short|shorts)\)$",
+    re.IGNORECASE,
+)
+
+
+def _duplicate_content_key(label: str) -> str | None:
+    """Return a cross-disc comparison key for duplicate non-movie targets."""
+    if _is_movie_target(label):
+        return None
+    key = _DISC_LABEL_PREFIX_RE.sub("", label).strip()
+    key = _TRAILING_TYPE_RE.sub("", key).strip()
+    if not key:
+        return None
+    return re.sub(r"\s+", " ", key).casefold()
+
 _PLAY_ALL_RE = re.compile(r"\bplay\s*all\b", re.IGNORECASE)
 
 # Edition patterns in dvdcompare feature titles
@@ -195,6 +213,21 @@ _EDITION_RE = re.compile(
     r"((?:Extended|Director'?s|Unrated|Ultimate|Special|Theatrical)\s+(?:Cut|Edition|Version))",
     re.IGNORECASE,
 )
+_FORMAT_EDITION_RE = re.compile(r"\b(3D|2D|IMAX|Open Matte)\b", re.IGNORECASE)
+
+
+def _extract_movie_edition(text: str) -> str:
+    """Extract a Plex movie edition label from dvdcompare film-entry text."""
+    m = _EDITION_RE.search(text)
+    if m:
+        return m.group(1)
+    m = _FORMAT_EDITION_RE.search(text)
+    if not m:
+        return ""
+    value = m.group(1)
+    if value.lower() == "open matte":
+        return "Open Matte"
+    return value.upper()
 
 
 def collect_disc_targets(
@@ -251,14 +284,15 @@ def collect_disc_targets(
         # Handle "The Film ..." entries on film discs
         if len(film_entries) > 1:
             # Multiple editions: create edition-aware targets and suppress
-            # the single TMDb movie target added above.  Runtimes may be
-            # zero when dvdcompare only lists the title/resolution; those
-            # are filled in during matching by pairing editions with files
-            # by duration order (shortest = theatrical, longest = extended).
-            suppress_movie_target = True
+            # the single TMDb movie target added above only when it would
+            # point at this same disc.  In combo packs, a separate 4K disc
+            # can be the base movie while a Blu-ray disc carries 3D/2D
+            # variants; those need both the generic movie target and the
+            # edition-aware targets.
+            if film_disc_num is None or disc.number == film_disc_num:
+                suppress_movie_target = True
             for ex in film_entries:
-                m = _EDITION_RE.search(ex.title)
-                edition = m.group(1) if m else ex.title
+                edition = _extract_movie_edition(ex.title) or ex.title
                 label = f"{prefix}: {edition} (movie)"
                 runtime = ex.runtime_seconds or 0
                 log.debug("Disc %d: multi-edition film entry '%s' -> target '%s' (%ds)",
@@ -515,14 +549,6 @@ def match_discs(
         if ti not in claimed_targets and runtime_s == 0 and "(movie)" in label
     ]
     if zero_edition_targets:
-        # Find unclaimed files on the same disc(s)
-        edition_disc = targets[zero_edition_targets[0]][2]
-        unclaimed_files = [
-            fi for fi in range(len(all_scanned))
-            if fi not in claimed_files
-            and all_scanned[fi].duration_seconds > 0
-            and (edition_disc is None or file_disc[fi] is None or file_disc[fi] == edition_disc)
-        ]
         # Sort targets: theatrical first, then extended
         def _edition_sort_key(ti: int) -> int:
             label_lower = targets[ti][0].lower()
@@ -531,28 +557,55 @@ def match_discs(
             if any(w in label_lower for w in _EXTENDED_WORDS):
                 return 1
             return 2
-        zero_edition_targets.sort(key=_edition_sort_key)
-        # Sort files by duration (shortest first = theatrical)
-        unclaimed_files.sort(key=lambda fi: all_scanned[fi].duration_seconds)
-
-        for ti, fi in zip(zero_edition_targets, unclaimed_files):
-            sf = all_scanned[fi]
-            label = targets[ti][0]
-            log.debug("Edition match (no runtime): %s (%ds) -> '%s'",
-                      sf.name, sf.duration_seconds, label)
-            matched.append(
-                MatchCandidate(
-                    file_name=sf.name,
-                    file_duration_seconds=sf.duration_seconds,
-                    matched_label=label,
-                    matched_runtime_seconds=sf.duration_seconds,
-                    delta_seconds=0,
-                    confidence="medium",
-                    classification=sf.classification,
-                )
+
+        edition_discs = sorted(
+            {targets[ti][2] for ti in zero_edition_targets},
+            key=lambda d: -1 if d is None else d,
+        )
+        for edition_disc in edition_discs:
+            disc_targets = [ti for ti in zero_edition_targets if targets[ti][2] == edition_disc]
+            unclaimed_files = [
+                fi for fi in range(len(all_scanned))
+                if fi not in claimed_files
+                and all_scanned[fi].duration_seconds > 0
+                and (edition_disc is None or file_disc[fi] is None or file_disc[fi] == edition_disc)
+            ]
+
+            disc_targets.sort(key=_edition_sort_key)
+            target_labels = [targets[ti][0].lower() for ti in disc_targets]
+            has_3d_2d_targets = (
+                any("3d" in label for label in target_labels)
+                and any("2d" in label for label in target_labels)
             )
-            claimed_files.add(fi)
-            claimed_targets.add(ti)
+            if has_3d_2d_targets:
+                # 3D MVC titles carry an extra eye view and are typically larger
+                # than their same-runtime 2D companion on the same disc.
+                disc_targets.sort(
+                    key=lambda ti: 0 if "3d" in targets[ti][0].lower() else 1
+                )
+                unclaimed_files.sort(key=lambda fi: all_scanned[fi].size_bytes, reverse=True)
+            else:
+                # Sort files by duration (shortest first = theatrical)
+                unclaimed_files.sort(key=lambda fi: all_scanned[fi].duration_seconds)
+
+            for ti, fi in zip(disc_targets, unclaimed_files):
+                sf = all_scanned[fi]
+                label = targets[ti][0]
+                log.debug("Edition match (no runtime): %s (%ds) -> '%s'",
+                          sf.name, sf.duration_seconds, label)
+                matched.append(
+                    MatchCandidate(
+                        file_name=sf.name,
+                        file_duration_seconds=sf.duration_seconds,
+                        matched_label=label,
+                        matched_runtime_seconds=sf.duration_seconds,
+                        delta_seconds=0,
+                        confidence="medium",
+                        classification=sf.classification,
+                    )
+                )
+                claimed_files.add(fi)
+                claimed_targets.add(ti)
 
     unmatched = [
         all_scanned[i]
@@ -560,6 +613,17 @@ def match_discs(
         if i not in claimed_files
     ]
 
+    matched_content_keys = {
+        key for key in (_duplicate_content_key(targets[i][0]) for i in claimed_targets)
+        if key is not None
+    }
+
+    def _is_missing_target(target_index: int) -> bool:
+        if target_index in claimed_targets:
+            return False
+        key = _duplicate_content_key(targets[target_index][0])
+        return key is None or key not in matched_content_keys
+
     # Only report missing targets from discs the user actually has
     # folders for (or targets with no disc constraint).  If no folder
     # mapped to any disc (e.g. single folder with no disc number),
@@ -569,14 +633,14 @@ def match_discs(
         missing = [
             targets[i][0]
             for i in range(len(targets))
-            if i not in claimed_targets
+            if _is_missing_target(i)
             and (targets[i][2] is None or targets[i][2] in present_discs)
         ]
     else:
         missing = [
             targets[i][0]
             for i in range(len(targets))
-            if i not in claimed_targets
+            if _is_missing_target(i)
         ]
 
     for sf in unmatched:

{riplex-0.8.0 → riplex-0.9.0}/src/riplex/normalize.py

@@ -86,10 +86,18 @@ def movie_folder_name(title: str, year: int, edition: str | None = None) -> str:
     return name
 
 
-def movie_file_name(title: str, year: int, ext: str = ".mkv", edition: str | None = None) -> str:
+def movie_file_name(
+    title: str,
+    year: int,
+    ext: str = ".mkv",
+    edition: str | None = None,
+    version_suffix: str = "",
+) -> str:
     """Build the canonical Plex movie filename."""
     safe = sanitize_filename(title)
     name = f"{safe} ({year})"
+    if version_suffix:
+        name += f" - {sanitize_filename(version_suffix)}"
     if edition:
         name += f" {{edition-{edition}}}"
     return f"{name}{ext}"

{riplex-0.8.0 → riplex-0.9.0}/src/riplex/organizer.py

@@ -35,6 +35,43 @@ _EDITION_RE = re.compile(
     r"((?:Extended|Director'?s|Unrated|Ultimate|Special|Theatrical)\s+(?:Cut|Edition|Version))",
     re.IGNORECASE,
 )
+_FORMAT_EDITION_RE = re.compile(r"\b(3D|IMAX|Open Matte)\b", re.IGNORECASE)
+_VERSION_4K_RE = re.compile(r"\b(?:4K|2160p)\b", re.IGNORECASE)
+_VERSION_1080P_RE = re.compile(r"\b1080p\b", re.IGNORECASE)
+
+
+def _extract_movie_edition(text: str) -> str:
+    """Extract a Plex movie edition label from classifier/match text."""
+    m = _EDITION_RE.search(text)
+    if m:
+        return m.group(1)
+    m = _FORMAT_EDITION_RE.search(text)
+    if not m:
+        return ""
+    value = m.group(1)
+    if value.lower() == "open matte":
+        return "Open Matte"
+    return value.upper()
+
+
+def _extract_movie_version_suffix(text: str) -> str:
+    """Extract a Plex multi-version suffix from classifier/match text."""
+    if _VERSION_4K_RE.search(text):
+        return "4k"
+    if _VERSION_1080P_RE.search(text):
+        return "1080p"
+    return ""
+
+
+def _infer_movie_version_suffix(scanned_file: ScannedFile | None, edition: str | None) -> str:
+    """Infer a Plex multi-version suffix from scanned video dimensions."""
+    if not scanned_file:
+        return ""
+    if scanned_file.max_width >= 3840 or scanned_file.max_height >= 2160:
+        return "4k"
+    if scanned_file.max_width >= 1920 or scanned_file.max_height >= 1080:
+        return "1080p"
+    return ""
 
 # Map dvdcompare feature_type strings to Plex extras folder names
 _EXTRAS_FOLDER_MAP: dict[str, str] = {
@@ -380,7 +417,7 @@ def build_organize_plan(
                         )
                         continue
 
-        dest = _compute_destination(candidate, plan, base)
+        dest = _compute_destination(candidate, plan, base, scanned_files.get(candidate.file_name))
         if dest is None:
             # Could not resolve to a valid Plex path; treat as unmatched.
             log.debug("No valid destination for '%s' (label='%s'), treating as unmatched",
@@ -452,6 +489,7 @@ def _compute_destination(
     candidate: MatchCandidate,
     plan: PlannedMovie | PlannedShow,
     base: Path,
+    scanned_file: ScannedFile | None = None,
 ) -> Path | None:
     """Compute the Plex-canonical destination path for a matched file.
 
@@ -464,20 +502,29 @@ def _compute_destination(
     # Movie main file
     if "(movie)" in label:
         edition = None
+        version_suffix = ""
         # Check for edition in label (from multi-edition disc targets)
         # e.g. "Disc 1: Theatrical Cut (movie)"
         if label.startswith("Disc ") and ": " in label:
             edition_part = label.split(": ", 1)[1].replace(" (movie)", "")
-            m = _EDITION_RE.search(edition_part)
-            if m:
-                edition = m.group(1)
+            edition = _extract_movie_edition(edition_part) or None
+            version_suffix = _extract_movie_version_suffix(edition_part)
         # Fallback: check rip-time classification
         if not edition and candidate.classification:
-            m = _EDITION_RE.search(candidate.classification)
-            if m:
-                edition = m.group(1)
-        dest = base / movie_file_name(plan.canonical_title, plan.year, edition=edition)
-        log.debug("  -> movie main file (edition=%s): %s", edition, dest)
+            edition = _extract_movie_edition(candidate.classification) or None
+        if not version_suffix and candidate.classification:
+            version_suffix = _extract_movie_version_suffix(candidate.classification)
+        if not version_suffix:
+            version_suffix = _infer_movie_version_suffix(scanned_file, edition)
+        movie_base = base.parent / movie_folder_name(plan.canonical_title, plan.year, edition=edition) if edition else base
+        file_name = movie_file_name(
+            plan.canonical_title,
+            plan.year,
+            edition=edition,
+            version_suffix=version_suffix,
+        )
+        dest = movie_base / file_name
+        log.debug("  -> movie main file (edition=%s, version=%s): %s", edition, version_suffix, dest)
         return dest
 
     # Episode: label like "Disc 1: Coasts" or "s01e01 - Title"

{riplex-0.8.0 → riplex-0.9.0/src/riplex.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: riplex
-Version: 0.8.0
+Version: 0.9.0
 Summary: Automates the tedious manual work around MakeMKV: figuring out what to rip, which MKV files are actually what, and organizing everything into Plex-compatible folder structures.
 License: MIT
 Requires-Python: >=3.11

{riplex-0.8.0 → riplex-0.9.0}/tests/test_disc_analysis.py

@@ -416,7 +416,7 @@ class TestDetectDiscNumber:
 class TestAnalyzeDisc:
     """Tests for the analyze_disc() shared entry point."""
 
-    def _make_fake_disc(self, number, ep_runtimes, extra_runtimes=None):
+    def _make_fake_disc(self, number, ep_runtimes, extra_runtimes=None, extra_titles=None, is_film=False):
         class FakeEp:
             def __init__(self, title, runtime):
                 self.title = title
@@ -434,9 +434,16 @@ class TestAnalyzeDisc:
                 self.episodes = eps
                 self.extras = extras
                 self.disc_format = "Blu-ray"
+                self.is_film = is_film
 
         eps = [FakeEp(f"Ep {i+1}", rt) for i, rt in enumerate(ep_runtimes)]
-        extras = [FakeExtra(f"Extra {i+1}", rt) for i, rt in enumerate(extra_runtimes or [])]
+        if extra_titles is None:
+            extras = [FakeExtra(f"Extra {i+1}", rt) for i, rt in enumerate(extra_runtimes or [])]
+        else:
+            extras = [
+                FakeExtra(title, runtime)
+                for title, runtime in zip(extra_titles, extra_runtimes or [])
+            ]
         return FakeDisc(number, eps, extras)
 
     def test_filters_to_detected_disc(self):
@@ -507,3 +514,30 @@ class TestAnalyzeDisc:
         # Should still classify titles (main film detected by runtime)
         assert len(analysis.rippable_titles) >= 1
         assert len(analysis.classifications) == 2
+
+    def test_3d_2d_movie_variants_are_labeled_by_size(self):
+        disc = self._make_fake_disc(
+            2,
+            [],
+            extra_runtimes=[0, 0],
+            extra_titles=["The Film (3D) (1080p)", "The Film (2D) (1080p)"],
+            is_film=True,
+        )
+        titles = [
+            _make_title(
+                0, 2653, resolution="1920x1080",
+                size=14_494_550_016,
+            ),
+            _make_title(
+                3, 2653, resolution="1920x1080",
+                size=13_900_886_016,
+            ),
+        ]
+        info = DiscInfo(disc_name="MYSTERY", disc_type="Blu-ray disc", titles=titles)
+
+        analysis = analyze_disc(
+            info, [disc], disc_number=2, is_movie=True, movie_runtime=2700,
+        )
+
+        assert analysis.classifications[0] == "3D Edition (1080p)"
+        assert analysis.classifications[3] == "2D Edition (1080p)"

{riplex-0.8.0 → riplex-0.9.0}/tests/test_matcher.py

@@ -753,6 +753,31 @@ class TestMissingFilteredToPresent:
         assert any("Feature A" in l for l in labels)
         assert any("Feature B" in l for l in labels)
 
+    def test_duplicate_extra_matched_on_one_disc_not_reported_missing_on_another(self):
+        discs = [
+            PlannedDisc(
+                number=1, disc_format="Blu-ray 4K",
+                extras=[PlannedExtra(title="Humpback Whales", runtime_seconds=138)],
+            ),
+            PlannedDisc(
+                number=2, disc_format="Blu-ray",
+                extras=[PlannedExtra(title="Humpback Whales", runtime_seconds=138)],
+            ),
+        ]
+        scanned = [
+            ScannedDisc(folder_name="Disc 1", files=[]),
+            ScannedDisc(
+                folder_name="Disc 2",
+                files=[ScannedFile(name="humpback.mkv", path="x", duration_seconds=138)],
+            ),
+        ]
+
+        result = match_discs(scanned, discs)
+
+        assert len(result.matched) == 1
+        assert result.matched[0].matched_label == "Disc 2: Humpback Whales"
+        assert result.missing == []
+
 
 class TestMultiEditionFilm:
     """Multiple editions (Theatrical + Extended) on the same film disc."""
@@ -808,6 +833,29 @@ class TestMultiEditionFilm:
         assert any("Extended Cut" in l and "(movie)" in l for l in labels)
         assert not any(l == "King Kong (movie)" for l in labels)
 
+    def test_3d_2d_film_entries_create_edition_targets(self):
+        movie = PlannedMovie(
+            canonical_title="Flight of the Butterflies",
+            year=2012,
+            runtime="45m",
+            runtime_seconds=2700,
+        )
+        discs = [
+            PlannedDisc(
+                number=2, disc_format="Blu-ray", is_film=True,
+                extras=[
+                    PlannedExtra(title="The Film (3D) (1080p)", runtime_seconds=0),
+                    PlannedExtra(title="The Film (2D) (1080p)", runtime_seconds=0),
+                ],
+            ),
+        ]
+
+        targets = collect_disc_targets(discs, movie)
+        labels = [t[0] for t in targets]
+        assert "Disc 2: 3D (movie)" in labels
+        assert "Disc 2: 2D (movie)" in labels
+        assert "Flight of the Butterflies (movie)" not in labels
+
     def test_two_editions_match_files(self):
         """Two MKV files match the two editions by duration order when no runtimes."""
         movie = PlannedMovie(
@@ -846,6 +894,102 @@ class TestMultiEditionFilm:
         assert "Theatrical Cut" in t00.matched_label
         assert "Extended Cut" in t02.matched_label
 
+    def test_3d_2d_editions_match_by_size_when_runtime_is_equal(self):
+        movie = PlannedMovie(
+            canonical_title="Flight of the Butterflies",
+            year=2012,
+            runtime="45m",
+            runtime_seconds=2700,
+        )
+        discs = [
+            PlannedDisc(
+                number=2, disc_format="Blu-ray", is_film=True,
+                extras=[
+                    PlannedExtra(title="The Film (3D) (1080p)", runtime_seconds=0),
+                    PlannedExtra(title="The Film (2D) (1080p)", runtime_seconds=0),
+                ],
+            ),
+        ]
+        scanned = [
+            ScannedDisc(
+                folder_name="Disc 2",
+                files=[
+                    ScannedFile(
+                        name="Butterflies_t03.mkv", path="x",
+                        duration_seconds=2653, size_bytes=13_900_886_016,
+                    ),
+                    ScannedFile(
+                        name="Butterflies_t00.mkv", path="x",
+                        duration_seconds=2653, size_bytes=14_494_550_016,
+                    ),
+                ],
+            ),
+        ]
+
+        result = match_discs(scanned, discs, movie)
+
+        assert len(result.matched) == 2
+        large = next(c for c in result.matched if c.file_name == "Butterflies_t00.mkv")
+        small = next(c for c in result.matched if c.file_name == "Butterflies_t03.mkv")
+        assert large.matched_label == "Disc 2: 3D (movie)"
+        assert small.matched_label == "Disc 2: 2D (movie)"
+
+    def test_4k_movie_target_kept_when_3d_2d_entries_are_on_second_disc(self):
+        movie = PlannedMovie(
+            canonical_title="Flight of the Butterflies",
+            year=2012,
+            runtime="45m",
+            runtime_seconds=2700,
+        )
+        discs = [
+            PlannedDisc(
+                number=1, disc_format="Blu-ray 4K", is_film=True,
+                extras=[PlannedExtra(title="The Film (2160p)", runtime_seconds=0)],
+            ),
+            PlannedDisc(
+                number=2, disc_format="Blu-ray", is_film=True,
+                extras=[
+                    PlannedExtra(title="The Film (3D) (1080p)", runtime_seconds=0),
+                    PlannedExtra(title="The Film (2D) (1080p)", runtime_seconds=0),
+                ],
+            ),
+        ]
+        scanned = [
+            ScannedDisc(
+                folder_name="Disc 1",
+                files=[
+                    ScannedFile(
+                        name="title_t00.mkv", path="x",
+                        duration_seconds=2654, size_bytes=18_890_000_000,
+                    ),
+                ],
+            ),
+            ScannedDisc(
+                folder_name="Disc 2",
+                files=[
+                    ScannedFile(
+                        name="Butterflies_t00.mkv", path="x",
+                        duration_seconds=2654, size_bytes=13_421_000_000,
+                    ),
+                    ScannedFile(
+                        name="Butterflies_t03.mkv", path="x",
+                        duration_seconds=2654, size_bytes=9_846_000_000,
+                    ),
+                ],
+            ),
+        ]
+
+        result = match_discs(scanned, discs, movie)
+
+        assert len(result.matched) == 3
+        disc1 = next(c for c in result.matched if c.file_name == "title_t00.mkv")
+        disc2_large = next(c for c in result.matched if c.file_name == "Butterflies_t00.mkv")
+        disc2_small = next(c for c in result.matched if c.file_name == "Butterflies_t03.mkv")
+        assert disc1.matched_label == "Flight of the Butterflies (movie)"
+        assert disc2_large.matched_label == "Disc 2: 3D (movie)"
+        assert disc2_small.matched_label == "Disc 2: 2D (movie)"
+        assert result.unmatched == []
+
     def test_two_editions_with_runtimes_match(self):
         """Two editions with known runtimes match via normal greedy pairing."""
         movie = PlannedMovie(