From e3d020a4096c0ca8182ccbb8d8694cc65aef9546 Mon Sep 17 00:00:00 2001
From: Scott Morris <scott.moris@gmail.com>
Date: Thu, 20 Aug 2026 20:45:21 -0400
Subject: [PATCH 1/7] fix(build): declare audio streams in authored order for
 dvdauthor
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Without explicit `<audio>` declarations, dvdauthor auto-detects a
title's audio streams from the vob itself, and its inferred physical-
track order does not reliably match the order the streams actually
appear in. Confirmed in practice with a mixed AC3+MP2 title: dvdauthor
placed the second (MP2) stream at physical audio 0, silently ignoring
which track was authored as the default — so players default to the
wrong (non-default) audio track regardless of the disc's own intent.

Fix: declare every title's audio streams explicitly, in
`audio_mappings` order, so dvdauthor's physical-track assignment
matches what was authored instead of whatever it infers from the vob.

`dvdauthor_subpicture_language` is renamed to `dvdauthor_language_code`
since it's now shared between subpicture and audio stream declarations
rather than subpicture-only.
---
 .../src/build/authoring/language.rs           |  4 +-
 .../src/build/authoring/tests.rs              | 43 +++++++++++++++++++
 .../src/build/authoring/title.rs              | 43 ++++++++++++++++++-
 3 files changed, 86 insertions(+), 4 deletions(-)

diff --git a/plugins/tauri-plugin-spindle-project/src/build/authoring/language.rs b/plugins/tauri-plugin-spindle-project/src/build/authoring/language.rs
index 4411f709..424266b3 100644
--- a/plugins/tauri-plugin-spindle-project/src/build/authoring/language.rs
+++ b/plugins/tauri-plugin-spindle-project/src/build/authoring/language.rs
@@ -1,4 +1,4 @@
-// ISO 639 language code normalisation for dvdauthor subpicture stream
+// ISO 639 language code normalisation for dvdauthor audio/subpicture stream
 // declarations.
 //
 // (c) Copyright 2026 Liminal HQ, Scott Morris
@@ -6,7 +6,7 @@
 
 use isolang::Language;
 
-pub(super) fn dvdauthor_subpicture_language(language: &str) -> Option<String> {
+pub(super) fn dvdauthor_language_code(language: &str) -> Option<String> {
     let normalised = language
         .trim()
         .split(['-', '_'])
diff --git a/plugins/tauri-plugin-spindle-project/src/build/authoring/tests.rs b/plugins/tauri-plugin-spindle-project/src/build/authoring/tests.rs
index 9303c38f..05e620ba 100644
--- a/plugins/tauri-plugin-spindle-project/src/build/authoring/tests.rs
+++ b/plugins/tauri-plugin-spindle-project/src/build/authoring/tests.rs
@@ -330,6 +330,49 @@ fn dvdauthor_xml_rejects_mixed_menu_aspects_within_one_section() {
         .contains("Menus in the same DVD menu section must share one display aspect"));
 }
 
+#[test]
+fn dvdauthor_xml_declares_audio_streams_in_authored_order() {
+    // Without explicit <audio> declarations, dvdauthor auto-detects audio
+    // streams from the vob itself, and its inferred physical-track order
+    // does not reliably match the order the streams actually appear in —
+    // observed in practice with a mixed AC3+MP2 title, where dvdauthor
+    // placed the second (MP2) stream at physical audio 0 regardless of
+    // which track was marked default. Declaring the order explicitly is
+    // the fix; this pins that the declared order matches audio_mappings.
+    let mut project = test_project();
+    project.disc.titlesets[0].titles[0]
+        .audio_mappings
+        .push(AudioTrackMapping {
+            id: "am-2".to_string(),
+            source_stream_index: 2,
+            output_target: AudioOutputTarget::Mp2,
+            copy_mode: CopyMode::ReEncode,
+            label: "Commentary".to_string(),
+            language: "eng".to_string(),
+            order_index: 1,
+            is_default: false,
+            channel_layout: None,
+            bitrate_bps: None,
+        });
+
+    let plan = generate_build_plan(&project, "/tmp/dvd_output", false).unwrap();
+
+    let ac3_pos = plan
+        .dvdauthor_xml
+        .find("<audio format=\"ac3\" lang=\"en\" />")
+        .expect("expected an ac3 audio declaration");
+    let mp2_pos = plan
+        .dvdauthor_xml
+        .find("<audio format=\"mp2\" lang=\"en\" />")
+        .expect("expected an mp2 audio declaration");
+    assert!(
+        ac3_pos < mp2_pos,
+        "expected the default (ac3) audio track declared before the \
+         non-default (mp2) track\n{}",
+        plan.dvdauthor_xml
+    );
+}
+
 #[test]
 fn dvdauthor_xml_normalises_subpicture_languages_for_dvdauthor() {
     let mut project = test_project();
diff --git a/plugins/tauri-plugin-spindle-project/src/build/authoring/title.rs b/plugins/tauri-plugin-spindle-project/src/build/authoring/title.rs
index ccbbead0..70ae0818 100644
--- a/plugins/tauri-plugin-spindle-project/src/build/authoring/title.rs
+++ b/plugins/tauri-plugin-spindle-project/src/build/authoring/title.rs
@@ -9,7 +9,7 @@ use crate::models::*;
 
 use super::super::dvd_navigation::{playback_action_to_dvd_command_in_context, DvdCommandContext};
 use super::super::util::{format_dvd_timestamp, sanitise_filename, xml_escape};
-use super::language::dvdauthor_subpicture_language;
+use super::language::dvdauthor_language_code;
 
 pub(super) fn append_titles_section(
     xml: &mut String,
@@ -25,6 +25,36 @@ pub(super) fn append_titles_section(
         "      <video format=\"{format_str}\" aspect=\"{aspect_str}\" />\n"
     ));
 
+    // Declare audio streams in our own authored order if any title in this
+    // titleset has audio mappings. Without this, dvdauthor auto-detects
+    // streams from the vob itself, and its inferred physical-track order
+    // does not reliably match the order the streams actually appear in —
+    // confirmed by a mixed AC3+MP2 title where dvdauthor placed the second
+    // (MP2) stream at physical audio 0, silently ignoring which track was
+    // marked default. Explicit declarations pin the order dvdauthor uses.
+    let max_audio = titleset
+        .titles
+        .iter()
+        .map(|t| t.audio_mappings.len())
+        .max()
+        .unwrap_or(0);
+    if max_audio > 0 {
+        for i in 0..max_audio {
+            let mapping = titleset.titles.iter().find_map(|t| t.audio_mappings.get(i));
+            if let Some(am) = mapping {
+                let format = dvdauthor_audio_format(am.output_target);
+                let lang = dvdauthor_language_code(&am.language);
+                let mut attrs = format!(" format=\"{format}\"");
+                if let Some(lang) = lang {
+                    attrs.push_str(&format!(" lang=\"{}\"", xml_escape(&lang)));
+                }
+                xml.push_str(&format!("      <audio{attrs} />\n"));
+            } else {
+                xml.push_str("      <audio />\n");
+            }
+        }
+    }
+
     // Declare subtitle streams if any title in this titleset has subtitle mappings.
     let max_subs = titleset
         .titles
@@ -40,7 +70,7 @@ pub(super) fn append_titles_section(
                 .titles
                 .iter()
                 .find_map(|t| t.subtitle_mappings.get(i).map(|sm| sm.language.as_str()))
-                .and_then(dvdauthor_subpicture_language);
+                .and_then(dvdauthor_language_code);
             match lang {
                 Some(lang) => xml.push_str(&format!(
                     "      <subpicture lang=\"{}\" />\n",
@@ -120,6 +150,15 @@ fn append_title_pgc(
     Ok(())
 }
 
+fn dvdauthor_audio_format(target: AudioOutputTarget) -> &'static str {
+    match target {
+        AudioOutputTarget::Ac3 => "ac3",
+        AudioOutputTarget::Mp2 => "mp2",
+        AudioOutputTarget::Lpcm => "pcm",
+        AudioOutputTarget::Dts => "dts",
+    }
+}
+
 fn expand_title_end_action(
     action: &PlaybackAction,
     current_title: &Title,

From c2abfb353c76346dee5401e2dae5135524bf860e Mon Sep 17 00:00:00 2001
From: Scott Morris <scott.moris@gmail.com>
Date: Thu, 20 Aug 2026 20:49:22 -0400
Subject: [PATCH 2/7] fix(assets): enforce DVD-Video's per-codec audio bitrate
 ceiling
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

A source stream can be a DVD-legal codec by name and still be illegal
to stream-copy because its bitrate exceeds what DVD-Video allows for
that codec — e.g. 640 kbps AC-3 is a legal AC-3 bitstream (produced by
plenty of non-DVD encoders) but exceeds the DVD-Video spec's 448 kbps
AC-3 ceiling. The codec-name check alone was greenlighting these for a
stream copy, which would have shipped an out-of-spec disc.

Adds a `bitrate` compatibility check to `AudioStreamCompatibility`,
separate from `codec`, covering AC3 (448 kbps), MP2 (384 kbps), and
DTS (1536 kbps, rounded up slightly from the DVD spec's 1509.75 kbps
for encoder/muxer bitrate-field rounding). An unknown bitrate on a
ceiling-bearing codec defaults to incompatible rather than
optimistically assuming it's fine. Codecs without a simple bitrate
ceiling (LPCM, whose legality depends on channel count/sample
rate/depth) are unaffected.

The Titles UI now requires both `codec.compatible` and
`bitrate.compatible` before defaulting a track to copy mode, in both
the initial auto-map and the existing-mapping compatibility check.
---
 apps/spindle/src/pages/TitlesPage.tsx         |  13 +-
 .../guest-js/index.ts                         |   1 +
 .../src/inspect.rs                            | 143 ++++++++++++++++++
 .../src/models/asset.rs                       |  20 +++
 4 files changed, 175 insertions(+), 2 deletions(-)

diff --git a/apps/spindle/src/pages/TitlesPage.tsx b/apps/spindle/src/pages/TitlesPage.tsx
index 2f78ebaa..df0643c2 100644
--- a/apps/spindle/src/pages/TitlesPage.tsx
+++ b/apps/spindle/src/pages/TitlesPage.tsx
@@ -550,8 +550,14 @@ function TitleEditor({
 				? { sourceStreamIndex: asset.videoStreams[0].index, copyMode: 'copy' as CopyMode }
 				: null;
 
+		// Both dimensions must hold for a legal stream copy: a DVD-legal
+		// codec name at an over-ceiling bitrate (e.g. 640 kbps AC-3) still
+		// needs a re-encode down to a DVD-legal rate.
 		const audioCompatByStream = new Map(
-			asset.compatibilityDetail?.audioStreams.map((c) => [c.streamIndex, c.codec.compatible]) ?? [],
+			asset.compatibilityDetail?.audioStreams.map((c) => [
+				c.streamIndex,
+				c.codec.compatible && c.bitrate.compatible,
+			]) ?? [],
 		);
 		const audioMappings = asset.audioStreams.map((as_, i) => {
 			const compatible = audioCompatByStream.get(as_.index) ?? false;
@@ -1238,7 +1244,10 @@ function isCopyCompatible(asset: Asset | null, mapping: AudioTrackMapping): bool
 	const compat = asset?.compatibilityDetail?.audioStreams.find(
 		(c) => c.streamIndex === mapping.sourceStreamIndex,
 	);
-	return compat?.codec.compatible ?? true;
+	if (!compat) return true;
+	// Both dimensions must hold: a DVD-legal codec at an over-ceiling
+	// bitrate (e.g. 640 kbps AC-3) still isn't legally copyable as-is.
+	return compat.codec.compatible && compat.bitrate.compatible;
 }
 
 function sourceChannelLabel(asset: Asset | null, mapping: AudioTrackMapping): string | null {
diff --git a/plugins/tauri-plugin-spindle-project/guest-js/index.ts b/plugins/tauri-plugin-spindle-project/guest-js/index.ts
index 9304271d..954e9149 100644
--- a/plugins/tauri-plugin-spindle-project/guest-js/index.ts
+++ b/plugins/tauri-plugin-spindle-project/guest-js/index.ts
@@ -555,6 +555,7 @@ export interface VideoCompatibility {
 export interface AudioStreamCompatibility {
 	streamIndex: number;
 	codec: PropertyCheck;
+	bitrate: PropertyCheck;
 }
 
 export interface ContainerCompatibility {
diff --git a/plugins/tauri-plugin-spindle-project/src/inspect.rs b/plugins/tauri-plugin-spindle-project/src/inspect.rs
index 0fa083e6..dc8c56b0 100644
--- a/plugins/tauri-plugin-spindle-project/src/inspect.rs
+++ b/plugins/tauri-plugin-spindle-project/src/inspect.rs
@@ -506,6 +506,53 @@ fn build_compatibility_detail(
                 a.codec.as_str(),
                 "ac3" | "dts" | "pcm_s16le" | "pcm_s16be" | "mp2" | "lpcm"
             );
+            // DVD-Video's per-codec bitrate ceiling — distinct from, and in
+            // addition to, the codec-name check above. A source can be a
+            // legal DVD codec by name and still be too hot to stream-copy
+            // (e.g. AC-3 above 448 kbps is a valid AC-3 bitstream, produced
+            // by plenty of non-DVD encoders, but not DVD-legal). `None` for
+            // codecs whose legality isn't a simple ceiling (LPCM depends on
+            // channel count/sample rate/depth, not bitrate directly) or for
+            // an already-non-DVD codec, where this check isn't the gate.
+            let bitrate_ceiling_bps: Option<u64> = match a.codec.as_str() {
+                "ac3" => Some(448_000),
+                "mp2" => Some(384_000),
+                // DVD-Video's two canonical DTS rates top out at 1509.75
+                // kbps; round up slightly for encoder/muxer bitrate-field
+                // rounding rather than reject a spec-legal stream on that.
+                "dts" => Some(1_536_000),
+                _ => None,
+            };
+            let bitrate_check = match bitrate_ceiling_bps {
+                Some(ceiling) => {
+                    // Unknown bitrate on a ceiling-bearing codec defaults to
+                    // incompatible (forces a re-encode) rather than
+                    // optimistically assuming it's fine — silently copying
+                    // an out-of-spec stream onto the disc is worse than an
+                    // unnecessary re-encode.
+                    let compatible = a.bitrate_bps.is_some_and(|bps| bps <= ceiling);
+                    PropertyCheck {
+                        value: a
+                            .bitrate_bps
+                            .map_or("unknown".to_string(), |bps| format!("{}kbps", bps / 1000)),
+                        dvd_requires: format!("at most {}kbps for {}", ceiling / 1000, a.codec),
+                        action: if compatible {
+                            "none".to_string()
+                        } else {
+                            "re-encode".to_string()
+                        },
+                        compatible,
+                    }
+                }
+                None => PropertyCheck {
+                    value: a
+                        .bitrate_bps
+                        .map_or("unknown".to_string(), |bps| format!("{}kbps", bps / 1000)),
+                    dvd_requires: "n/a".to_string(),
+                    action: "none".to_string(),
+                    compatible: true,
+                },
+            };
             AudioStreamCompatibility {
                 stream_index: a.index,
                 codec: PropertyCheck {
@@ -518,6 +565,7 @@ fn build_compatibility_detail(
                     },
                     compatible: is_dvd_audio,
                 },
+                bitrate: bitrate_check,
             }
         })
         .collect();
@@ -713,6 +761,101 @@ mod tests {
         ));
     }
 
+    #[test]
+    fn audio_bitrate_over_dvd_ceiling_is_incompatible_despite_legal_codec() {
+        // Regression test: 640 kbps is a legal AC-3 bitstream rate (used
+        // outside DVD, e.g. ATSC) but exceeds DVD-Video's 448 kbps AC-3
+        // ceiling — codec-name compatibility alone must not be enough to
+        // greenlight a stream copy.
+        let audio = vec![AudioStreamInfo {
+            index: 0,
+            codec: "ac3".to_string(),
+            channels: 6,
+            sample_rate: 48000,
+            language: Some("eng".to_string()),
+            bitrate_bps: Some(640_000),
+            title: None,
+        }];
+        let detail = build_compatibility_detail(
+            &[],
+            &audio,
+            &None,
+            CompatibilityAssessment::RemuxCompatible,
+        );
+        let ac3 = &detail.audio_streams[0];
+        assert!(ac3.codec.compatible, "ac3 is a legal DVD codec name");
+        assert!(
+            !ac3.bitrate.compatible,
+            "640 kbps exceeds the 448 kbps DVD-Video AC-3 ceiling"
+        );
+    }
+
+    #[test]
+    fn audio_bitrate_within_dvd_ceiling_is_compatible() {
+        let audio = vec![AudioStreamInfo {
+            index: 0,
+            codec: "ac3".to_string(),
+            channels: 2,
+            sample_rate: 48000,
+            language: Some("eng".to_string()),
+            bitrate_bps: Some(192_000),
+            title: None,
+        }];
+        let detail = build_compatibility_detail(
+            &[],
+            &audio,
+            &None,
+            CompatibilityAssessment::RemuxCompatible,
+        );
+        assert!(detail.audio_streams[0].bitrate.compatible);
+    }
+
+    #[test]
+    fn audio_bitrate_unknown_on_ceiling_bearing_codec_defaults_incompatible() {
+        let audio = vec![AudioStreamInfo {
+            index: 0,
+            codec: "dts".to_string(),
+            channels: 6,
+            sample_rate: 48000,
+            language: Some("eng".to_string()),
+            bitrate_bps: None,
+            title: None,
+        }];
+        let detail = build_compatibility_detail(
+            &[],
+            &audio,
+            &None,
+            CompatibilityAssessment::RemuxCompatible,
+        );
+        assert!(
+            !detail.audio_streams[0].bitrate.compatible,
+            "an unknown bitrate on a codec with a real ceiling must not be optimistically assumed compatible"
+        );
+    }
+
+    #[test]
+    fn audio_bitrate_check_is_not_the_gate_for_non_ceiling_codecs() {
+        // LPCM's legality is channel-count/sample-rate/depth driven, not a
+        // simple bitrate ceiling — its bitrate check shouldn't independently
+        // block a copy just because bitrate_bps is unknown or high.
+        let audio = vec![AudioStreamInfo {
+            index: 0,
+            codec: "pcm_s16le".to_string(),
+            channels: 2,
+            sample_rate: 48000,
+            language: Some("eng".to_string()),
+            bitrate_bps: None,
+            title: None,
+        }];
+        let detail = build_compatibility_detail(
+            &[],
+            &audio,
+            &None,
+            CompatibilityAssessment::RemuxCompatible,
+        );
+        assert!(detail.audio_streams[0].bitrate.compatible);
+    }
+
     #[test]
     fn dvd_compatibility_remux_compatible() {
         let video = vec![VideoStreamInfo {
diff --git a/plugins/tauri-plugin-spindle-project/src/models/asset.rs b/plugins/tauri-plugin-spindle-project/src/models/asset.rs
index 25b4c343..14758dbb 100644
--- a/plugins/tauri-plugin-spindle-project/src/models/asset.rs
+++ b/plugins/tauri-plugin-spindle-project/src/models/asset.rs
@@ -184,6 +184,26 @@ pub struct VideoCompatibility {
 pub struct AudioStreamCompatibility {
     pub stream_index: u32,
     pub codec: PropertyCheck,
+    /// Separate from `codec`: a stream can be a DVD-legal codec by name and
+    /// still be illegal to stream-copy because its bitrate exceeds what
+    /// DVD-Video allows for that codec (e.g. AC-3 above 448 kbps, a rate the
+    /// AC-3 bitstream format itself permits but the DVD-Video spec does not).
+    /// `#[serde(default)]` so project files saved before this field existed
+    /// deserialise cleanly — this is purely advisory (the UI's copy-vs-
+    /// re-encode default), not consulted by the build pipeline itself, so
+    /// treating pre-existing data as charitably "unknown, assume fine"
+    /// until the asset is next re-inspected is the low-risk default.
+    #[serde(default = "default_unknown_compatible_check")]
+    pub bitrate: PropertyCheck,
+}
+
+fn default_unknown_compatible_check() -> PropertyCheck {
+    PropertyCheck {
+        value: "unknown".to_string(),
+        dvd_requires: "n/a".to_string(),
+        action: "none".to_string(),
+        compatible: true,
+    }
 }
 
 /// Compatibility detail for the container format.

From a4ff27ed765f35b03f8fc0e1aec8cd397144e983 Mon Sep 17 00:00:00 2001
From: Scott Morris <scott.moris@gmail.com>
Date: Thu, 20 Aug 2026 20:50:00 -0400
Subject: [PATCH 3/7] fix(build): refuse to re-encode audio tracks to DTS

ffmpeg's only DTS encoder path (`-c:a dts`, reachable only behind
`-strict -2` since it's marked experimental) is confirmed broken, not
merely unsupported in theory: it produces a stream that decodes fine
in isolation but corrupts once actually muxed through the `-f dvd`
program-stream muxer. Real dvdauthor output on a DTS-mapped title
showed hundreds of "audio sector out of range" warnings, and playback
silently fell back to a different audio stream.

DTS is DVD-legal and works fine as a stream copy of an already-DTS
source; re-encoding *to* DTS is not something this toolchain can do
reliably, so it's refused outright rather than shipped broken:

- `build_ffmpeg_transcode_command` now returns `crate::Result<...>`
  and errors out on a DTS re-encode mapping, instead of emitting a
  command that produces a corrupt disc.
- Validation flags a DTS re-encode mapping as an error at project-edit
  time too, so the problem surfaces before a build is even attempted.
- The Titles UI disables DTS as a re-encode target in the output
  dropdown (offering it only for copy-mode tracks, with an explanatory
  tooltip), and falls back the output target to AC3 if a track already
  set to DTS is switched to re-encode mode.
---
 apps/spindle/src/pages/TitlesPage.tsx         |  16 ++-
 .../src/build/executor/tests.rs               |   3 +-
 .../src/build/ffmpeg.rs                       |  66 +++++++++---
 .../src/build/planner/mod.rs                  |   2 +-
 .../src/validation/title.rs                   | 102 ++++++++++++++++++
 5 files changed, 172 insertions(+), 17 deletions(-)

diff --git a/apps/spindle/src/pages/TitlesPage.tsx b/apps/spindle/src/pages/TitlesPage.tsx
index df0643c2..79a5ed1d 100644
--- a/apps/spindle/src/pages/TitlesPage.tsx
+++ b/apps/spindle/src/pages/TitlesPage.tsx
@@ -825,7 +825,13 @@ function TitleEditor({
 									<option value="AC3">AC3 (Dolby Digital)</option>
 									<option value="LPCM">LPCM</option>
 									<option value="MP2">MP2</option>
-									<option value="DTS">DTS</option>
+									<option
+										value="DTS"
+										disabled={am.copyMode !== 'copy'}
+										title="ffmpeg has no reliable DTS encoder — DTS is only supported as a passthrough of an already-DTS source, not as a re-encode target."
+									>
+										DTS{am.copyMode !== 'copy' ? ' (passthrough only)' : ''}
+									</option>
 								</select>
 								<select
 									className="titles__select"
@@ -844,6 +850,14 @@ function TitleEditor({
 													? {
 															...a,
 															copyMode,
+															// DTS re-encode isn't offered (no reliable ffmpeg
+															// encoder) — switching to Re-encode with DTS still
+															// selected must fall back rather than silently keep
+															// an option the UI no longer lets you pick.
+															outputTarget:
+																copyMode === 're-encode' && a.outputTarget === 'DTS'
+																	? 'AC3'
+																	: a.outputTarget,
 															// Channel layout and bitrate only apply to re-encoded
 															// tracks — clear them so a stale selection doesn't
 															// silently reappear if the user switches back later.
diff --git a/plugins/tauri-plugin-spindle-project/src/build/executor/tests.rs b/plugins/tauri-plugin-spindle-project/src/build/executor/tests.rs
index b1cc933f..3d3fc341 100644
--- a/plugins/tauri-plugin-spindle-project/src/build/executor/tests.rs
+++ b/plugins/tauri-plugin-spindle-project/src/build/executor/tests.rs
@@ -238,7 +238,8 @@ fn execute_build_plan_smoke_runs_two_pass_transcode_sequentially() {
         video_info,
         1_500_000.0,
         true,
-    );
+    )
+    .unwrap();
     command[0] = ffmpeg_bin.to_string_lossy().into_owned();
 
     let plan = BuildPlan {
diff --git a/plugins/tauri-plugin-spindle-project/src/build/ffmpeg.rs b/plugins/tauri-plugin-spindle-project/src/build/ffmpeg.rs
index f7a3f6c2..9a495c55 100644
--- a/plugins/tauri-plugin-spindle-project/src/build/ffmpeg.rs
+++ b/plugins/tauri-plugin-spindle-project/src/build/ffmpeg.rs
@@ -32,7 +32,7 @@ pub(crate) fn build_ffmpeg_transcode_command(
     video_info: Option<&VideoStreamInfo>,
     video_bitrate_bps: f64,
     two_pass: bool,
-) -> Vec<String> {
+) -> crate::Result<Vec<String>> {
     let video_bitrate_bps = if video_bitrate_bps > 0.0 {
         video_bitrate_bps.min(MAX_VIDEO_RATE_BPS)
     } else {
@@ -183,14 +183,26 @@ pub(crate) fn build_ffmpeg_transcode_command(
                         ]);
                     }
                     AudioOutputTarget::Dts => {
-                        cmd.extend([
-                            format!("-c:a:{i}"),
-                            "dts".to_string(),
-                            format!("-b:a:{i}"),
-                            bitrate_str(768_000),
-                            format!("-ar:a:{i}"),
-                            "48000".to_string(),
-                        ]);
+                        // Confirmed broken, not merely "quality not
+                        // guaranteed": ffmpeg's native `dca` encoder (only
+                        // reachable with `-strict -2`, since it's marked
+                        // experimental) produces a stream that decodes fine
+                        // in isolation but corrupts once actually muxed
+                        // through the `-f dvd` program-stream muxer — real
+                        // dvdauthor output showed hundreds of "audio sector
+                        // out of range" warnings for a DTS-mapped title, and
+                        // playback silently fell back to a different audio
+                        // stream. DTS is DVD-legal and works fine as a
+                        // stream copy of an already-DTS source (see
+                        // `CopyMode::Copy` above); re-encoding *to* DTS is
+                        // not something this toolchain can do reliably, so
+                        // it's refused here rather than shipped broken.
+                        return Err(crate::Error::Build(format!(
+                            "Cannot re-encode audio track \"{}\" to DTS — ffmpeg has no reliable DTS \
+                             encoder (its native encoder produces DVD-incompatible output). DTS is only \
+                             supported as a stream copy of an already-DTS source; re-encode to AC3 instead.",
+                            am.label
+                        )));
                     }
                 }
                 // Only re-encoded tracks can have their channel layout
@@ -244,7 +256,7 @@ pub(crate) fn build_ffmpeg_transcode_command(
         output_path.display().to_string(),
     ]);
 
-    cmd
+    Ok(cmd)
 }
 
 /// Shared HDR-tonemap / scale-pad-setsar / fps-conform video filter chain
@@ -555,7 +567,7 @@ pub(crate) fn dvd_colour_flags(standard: VideoStandard) -> Vec<String> {
 mod tests {
     use crate::build::generate_build_plan;
     use crate::build::test_support::test_project;
-    use crate::models::{AudioOutputTarget, VideoStandard};
+    use crate::models::{AudioOutputTarget, CopyMode, VideoStandard};
 
     #[test]
     fn ffmpeg_vf_has_scale_and_pad() {
@@ -671,7 +683,8 @@ mod tests {
             None,
             0.0,
             false,
-        );
+        )
+        .unwrap();
 
         let bv_arg = cmd
             .iter()
@@ -706,7 +719,8 @@ mod tests {
             Some(&asset.video_streams[0]),
             5_759_000.0,
             false,
-        );
+        )
+        .unwrap();
 
         let bv_arg = cmd
             .iter()
@@ -756,7 +770,8 @@ mod tests {
             Some(&asset.video_streams[0]),
             5_759_000.0,
             true,
-        );
+        )
+        .unwrap();
 
         assert!(
             !cmd.contains(&"-minrate".to_string()),
@@ -1005,4 +1020,27 @@ mod tests {
             "expected no -b:a flag for LPCM regardless of any bitrate override, got: {cmd:?}"
         );
     }
+
+    #[test]
+    fn ffmpeg_refuses_to_reencode_audio_to_dts() {
+        // Confirmed broken in practice, not merely undesirable: ffmpeg's
+        // only DTS encoder path (`-c:a dts` behind `-strict -2`, since it's
+        // marked experimental) produces a stream that decodes fine alone
+        // but corrupts once muxed through `-f dvd` — real dvdauthor output
+        // showed hundreds of "audio sector out of range" warnings for a
+        // DTS-mapped title, and playback silently fell back to a different
+        // audio stream. Re-encoding to DTS must be refused outright rather
+        // than shipped broken; DTS stays legal only as a stream copy.
+        let mut project = test_project();
+        project.disc.titlesets[0].titles[0].audio_mappings[0].copy_mode = CopyMode::ReEncode;
+        project.disc.titlesets[0].titles[0].audio_mappings[0].output_target =
+            AudioOutputTarget::Dts;
+
+        let result = generate_build_plan(&project, "/tmp/dvd_output", false);
+
+        assert!(
+            result.is_err(),
+            "expected generate_build_plan to refuse a DTS re-encode mapping, got: {result:?}"
+        );
+    }
 }
diff --git a/plugins/tauri-plugin-spindle-project/src/build/planner/mod.rs b/plugins/tauri-plugin-spindle-project/src/build/planner/mod.rs
index bf5d8f5d..bb048dc3 100644
--- a/plugins/tauri-plugin-spindle-project/src/build/planner/mod.rs
+++ b/plugins/tauri-plugin-spindle-project/src/build/planner/mod.rs
@@ -181,7 +181,7 @@ pub fn generate_build_plan_with_options(
                 video_info,
                 video_bitrate_bps,
                 two_pass,
-            );
+            )?;
             command[0] = tools.ffmpeg.clone();
 
             let pass1_command = if two_pass {
diff --git a/plugins/tauri-plugin-spindle-project/src/validation/title.rs b/plugins/tauri-plugin-spindle-project/src/validation/title.rs
index f9a5481e..48d5852b 100644
--- a/plugins/tauri-plugin-spindle-project/src/validation/title.rs
+++ b/plugins/tauri-plugin-spindle-project/src/validation/title.rs
@@ -135,6 +135,29 @@ pub(super) fn validate_titles(
                         ),
                     });
                 }
+                if mapping.output_target == AudioOutputTarget::Dts {
+                    // Confirmed broken, not merely unsupported in theory:
+                    // ffmpeg's only DTS encoder path corrupts once actually
+                    // muxed through `-f dvd` (see the matching refusal in
+                    // `build::ffmpeg::build_ffmpeg_transcode_command`, which
+                    // this mirrors so the problem surfaces at validation
+                    // time too, not just at build time).
+                    issues.push(ValidationIssue {
+                        severity: IssueSeverity::Error,
+                        code: "audio.dts-reencode-unsupported".to_string(),
+                        message: format!(
+                            "Title \"{}\" re-encodes an audio track to DTS, which this toolchain cannot do reliably.",
+                            title.name
+                        ),
+                        context: Some(title.id.clone()),
+                        entity_type: Some("title".to_string()),
+                        entity_name: Some(title.name.clone()),
+                        suggested_fix: Some(
+                            "ffmpeg has no reliable DTS encoder — its native encoder produces DVD-incompatible output. Switch this track to AC3, or to copy mode if the source is already DTS."
+                                .to_string(),
+                        ),
+                    });
+                }
                 if mapping.output_target != AudioOutputTarget::Lpcm {
                     continue;
                 }
@@ -304,3 +327,82 @@ pub(super) fn validate_titles(
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn project_with_one_dts_title(copy_mode: CopyMode) -> SpindleProjectFile {
+        let mut project = SpindleProjectFile::default();
+        project.disc.titlesets.push(Titleset {
+            id: "titleset-1".to_string(),
+            name: "Main".to_string(),
+            titles: vec![Title {
+                id: "title-1".to_string(),
+                name: "Feature".to_string(),
+                source_asset_id: None,
+                video_mapping: None,
+                video_output_profile: None,
+                audio_mappings: vec![AudioTrackMapping {
+                    id: "audio-1".to_string(),
+                    source_stream_index: 0,
+                    output_target: AudioOutputTarget::Dts,
+                    copy_mode,
+                    label: "English".to_string(),
+                    language: "eng".to_string(),
+                    order_index: 0,
+                    is_default: true,
+                    channel_layout: None,
+                    bitrate_bps: None,
+                }],
+                subtitle_mappings: vec![],
+                chapters: vec![],
+                end_action: None,
+                order_index: 0,
+                bitrate_weight: 1.0,
+                bitrate_floor_bps: None,
+                bitrate_ceiling_bps: None,
+                pinned_bitrate_bps: None,
+            }],
+            menus: vec![],
+        });
+        project
+    }
+
+    #[test]
+    fn validate_titles_flags_dts_reencode_as_an_error() {
+        let project = project_with_one_dts_title(CopyMode::ReEncode);
+        let asset_ids: HashSet<&str> = HashSet::new();
+        let asset_map: HashMap<&str, &Asset> = HashMap::new();
+        let mut issues = Vec::new();
+
+        validate_titles(&project, &asset_ids, &asset_map, &mut issues);
+
+        assert!(
+            issues
+                .iter()
+                .any(|i| i.code == "audio.dts-reencode-unsupported"
+                    && i.severity == IssueSeverity::Error),
+            "expected an error-level audio.dts-reencode-unsupported issue, got: {issues:?}"
+        );
+    }
+
+    #[test]
+    fn validate_titles_does_not_flag_dts_copy_mode() {
+        // A track already delivered as DTS and stream-copied through never
+        // touches ffmpeg's broken encoder — nothing to flag.
+        let project = project_with_one_dts_title(CopyMode::Copy);
+        let asset_ids: HashSet<&str> = HashSet::new();
+        let asset_map: HashMap<&str, &Asset> = HashMap::new();
+        let mut issues = Vec::new();
+
+        validate_titles(&project, &asset_ids, &asset_map, &mut issues);
+
+        assert!(
+            !issues
+                .iter()
+                .any(|i| i.code == "audio.dts-reencode-unsupported"),
+            "copy-mode DTS should not be flagged, got: {issues:?}"
+        );
+    }
+}

From ac18dbde746be6b16f21964a86347d69887e195a Mon Sep 17 00:00:00 2001
From: Scott Morris <scott.moris@gmail.com>
Date: Thu, 20 Aug 2026 20:52:46 -0400
Subject: [PATCH 4/7] fix(frontend): check resolution and frame rate before
 defaulting video to copy mode
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Picking a video source stream in the Titles editor defaulted it to
copy mode unconditionally, even when its resolution or frame rate
weren't actually DVD-legal — only the audio side had a compatibility
gate. Since `CompatibilityDetail.video` always assesses whichever
stream inspection treated as primary (in practice `videoStreams[0]`),
picking any other stream also has no compatibility signal to check
against and must default to re-encode rather than assume copy.

Adds `isVideoCopyCompatible()`, checking codec, resolution, and frame
rate together (any one mismatch means re-encode), and uses it both in
the initial auto-map and when the user changes the video source stream.
---
 apps/spindle/src/pages/TitlesPage.tsx | 34 ++++++++++++++++++++++-----
 1 file changed, 28 insertions(+), 6 deletions(-)

diff --git a/apps/spindle/src/pages/TitlesPage.tsx b/apps/spindle/src/pages/TitlesPage.tsx
index 79a5ed1d..a55bbb94 100644
--- a/apps/spindle/src/pages/TitlesPage.tsx
+++ b/apps/spindle/src/pages/TitlesPage.tsx
@@ -547,7 +547,10 @@ function TitleEditor({
 		// Auto-map first video stream and create audio mappings
 		const videoMapping =
 			asset.videoStreams.length > 0
-				? { sourceStreamIndex: asset.videoStreams[0].index, copyMode: 'copy' as CopyMode }
+				? {
+						sourceStreamIndex: asset.videoStreams[0].index,
+						copyMode: (isVideoCopyCompatible(asset) ? 'copy' : 're-encode') as CopyMode,
+					}
 				: null;
 
 		// Both dimensions must hold for a legal stream copy: a DVD-legal
@@ -724,15 +727,23 @@ function TitleEditor({
 					<select
 						className="titles__select"
 						value={title.videoMapping?.sourceStreamIndex ?? ''}
-						onChange={(e) =>
+						onChange={(e) => {
+							const streamIndex = Number(e.target.value);
+							// Compatibility data only covers the inspected/primary
+							// stream (videoStreams[0]) — picking any other stream
+							// is data we have no compatibility signal for, so it
+							// must default to re-encode rather than assume copy.
+							const isPrimaryStream = streamIndex === selectedAsset.videoStreams[0]?.index;
 							onUpdate({
 								...title,
 								videoMapping: {
-									sourceStreamIndex: Number(e.target.value),
-									copyMode: 'copy',
+									sourceStreamIndex: streamIndex,
+									copyMode: (isPrimaryStream && isVideoCopyCompatible(selectedAsset)
+										? 'copy'
+										: 're-encode') as CopyMode,
 								},
-							})
-						}
+							});
+						}}
 					>
 						{selectedAsset.videoStreams.map((vs) => (
 							<option key={vs.index} value={vs.index}>
@@ -1264,6 +1275,17 @@ function isCopyCompatible(asset: Asset | null, mapping: AudioTrackMapping): bool
 	return compat.codec.compatible && compat.bitrate.compatible;
 }
 
+// Unlike audio (a single per-stream codec check), video compatibility is
+// multi-dimensional and unindexed (`CompatibilityDetail.video` assesses
+// whichever stream inspection treated as primary — in practice always
+// videoStreams[0]) — codec, resolution, AND frame rate must all already be
+// DVD-legal for a stream copy to be valid; any one mismatch means re-encode.
+function isVideoCopyCompatible(asset: Asset | null): boolean {
+	const compat = asset?.compatibilityDetail?.video;
+	if (!compat) return true;
+	return compat.codec.compatible && compat.resolution.compatible && compat.frameRate.compatible;
+}
+
 function sourceChannelLabel(asset: Asset | null, mapping: AudioTrackMapping): string | null {
 	const channels = asset?.audioStreams.find((s) => s.index === mapping.sourceStreamIndex)?.channels;
 	if (!channels) return null;

From aabd253dfdd8a35885cc7e151224139351539a87 Mon Sep 17 00:00:00 2001
From: Scott Morris <scott.moris@gmail.com>
Date: Thu, 20 Aug 2026 21:43:44 -0400
Subject: [PATCH 5/7] fix(build): declare copy-mode audio using the real source
 codec
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Follow-up to the audio-stream-declaration-order fix, from Codex
review: `output_target` only reflects what a *re-encoded* stream
becomes — `build_ffmpeg_transcode_command` emits `-c:a copy` for a
`CopyMode::Copy` mapping, ignoring `output_target` entirely and
passing the source stream's own bytes through unchanged. The Titles
UI lets `copyMode` and `outputTarget` be set independently, though, so
a track can end up in copy mode with a stale `output_target` left over
from before the user switched modes (e.g. was re-encoding AC3 -> MP2,
then switched to copy). Declaring that stale target's format to
dvdauthor would tell it a physical AC3 stream is MP2, which can make
dvdauthor reject or mis-author the stream.

`declared_audio_format` now resolves the real source codec (via the
title's `source_asset_id` and the mapping's `source_stream_index`) for
copy-mode mappings, falling back to `output_target` only when the
source asset/stream can't be resolved.
---
 .../src/build/authoring/mod.rs                |  3 +
 .../src/build/authoring/tests.rs              | 31 ++++++++++
 .../src/build/authoring/title.rs              | 61 ++++++++++++++++++-
 3 files changed, 92 insertions(+), 3 deletions(-)

diff --git a/plugins/tauri-plugin-spindle-project/src/build/authoring/mod.rs b/plugins/tauri-plugin-spindle-project/src/build/authoring/mod.rs
index 078eb35b..aef3922f 100644
--- a/plugins/tauri-plugin-spindle-project/src/build/authoring/mod.rs
+++ b/plugins/tauri-plugin-spindle-project/src/build/authoring/mod.rs
@@ -3,6 +3,7 @@
 // (c) Copyright 2026 Liminal HQ, Scott Morris
 // SPDX-License-Identifier: MIT
 
+use std::collections::HashMap;
 use std::path::Path;
 
 use crate::models::*;
@@ -29,6 +30,7 @@ pub(crate) fn generate_dvdauthor_xml(
         VideoStandard::Ntsc => "ntsc",
         VideoStandard::Pal => "pal",
     };
+    let assets: HashMap<&str, &Asset> = project.assets.iter().map(|a| (a.id.as_str(), a)).collect();
 
     let mut xml = String::new();
 
@@ -113,6 +115,7 @@ pub(crate) fn generate_dvdauthor_xml(
             titleset_index,
             &project.disc,
             titles_dir,
+            &assets,
         )?;
 
         xml.push_str("  </titleset>\n");
diff --git a/plugins/tauri-plugin-spindle-project/src/build/authoring/tests.rs b/plugins/tauri-plugin-spindle-project/src/build/authoring/tests.rs
index 05e620ba..c178937e 100644
--- a/plugins/tauri-plugin-spindle-project/src/build/authoring/tests.rs
+++ b/plugins/tauri-plugin-spindle-project/src/build/authoring/tests.rs
@@ -373,6 +373,37 @@ fn dvdauthor_xml_declares_audio_streams_in_authored_order() {
     );
 }
 
+#[test]
+fn dvdauthor_xml_declares_copied_audio_using_the_actual_source_codec() {
+    // A CopyMode::Copy mapping passes the source stream's own bytes through
+    // unchanged (build_ffmpeg_transcode_command emits `-c:a copy`, ignoring
+    // output_target entirely) — but the UI lets output_target and copyMode
+    // be set independently, so a track can end up in copy mode with a
+    // stale output_target left over from before the user switched modes
+    // (e.g. was re-encoding AC3 -> MP2, then switched to copy). Declaring
+    // that stale output_target's format to dvdauthor would tell it a
+    // physical AC3 stream is MP2, which can make dvdauthor reject or
+    // mis-author the stream. The declared format must come from the
+    // source's real codec for copied mappings.
+    let mut project = test_project();
+    project.assets[0].audio_streams[0].codec = "ac3".to_string();
+    project.disc.titlesets[0].titles[0].audio_mappings[0].copy_mode = CopyMode::Copy;
+    project.disc.titlesets[0].titles[0].audio_mappings[0].output_target = AudioOutputTarget::Mp2;
+
+    let plan = generate_build_plan(&project, "/tmp/dvd_output", false).unwrap();
+
+    assert!(
+        plan.dvdauthor_xml.contains("<audio format=\"ac3\" lang=\"en\" />"),
+        "expected the copied stream declared using its real ac3 source codec, not the stale mp2 output_target\n{}",
+        plan.dvdauthor_xml
+    );
+    assert!(
+        !plan.dvdauthor_xml.contains("<audio format=\"mp2\""),
+        "must not declare the stale mp2 output_target for a copy-mode mapping\n{}",
+        plan.dvdauthor_xml
+    );
+}
+
 #[test]
 fn dvdauthor_xml_normalises_subpicture_languages_for_dvdauthor() {
     let mut project = test_project();
diff --git a/plugins/tauri-plugin-spindle-project/src/build/authoring/title.rs b/plugins/tauri-plugin-spindle-project/src/build/authoring/title.rs
index 70ae0818..e3092799 100644
--- a/plugins/tauri-plugin-spindle-project/src/build/authoring/title.rs
+++ b/plugins/tauri-plugin-spindle-project/src/build/authoring/title.rs
@@ -3,6 +3,7 @@
 // (c) Copyright 2026 Liminal HQ, Scott Morris
 // SPDX-License-Identifier: MIT
 
+use std::collections::HashMap;
 use std::path::Path;
 
 use crate::models::*;
@@ -11,6 +12,7 @@ use super::super::dvd_navigation::{playback_action_to_dvd_command_in_context, Dv
 use super::super::util::{format_dvd_timestamp, sanitise_filename, xml_escape};
 use super::language::dvdauthor_language_code;
 
+#[allow(clippy::too_many_arguments)]
 pub(super) fn append_titles_section(
     xml: &mut String,
     format_str: &str,
@@ -19,6 +21,7 @@ pub(super) fn append_titles_section(
     titleset_index: usize,
     disc: &Disc,
     titles_dir: &Path,
+    assets: &HashMap<&str, &Asset>,
 ) -> crate::Result<()> {
     xml.push_str("    <titles>\n");
     xml.push_str(&format!(
@@ -40,9 +43,12 @@ pub(super) fn append_titles_section(
         .unwrap_or(0);
     if max_audio > 0 {
         for i in 0..max_audio {
-            let mapping = titleset.titles.iter().find_map(|t| t.audio_mappings.get(i));
-            if let Some(am) = mapping {
-                let format = dvdauthor_audio_format(am.output_target);
+            let mapping = titleset
+                .titles
+                .iter()
+                .find_map(|t| t.audio_mappings.get(i).map(|am| (t, am)));
+            if let Some((title, am)) = mapping {
+                let format = declared_audio_format(am, title, assets);
                 let lang = dvdauthor_language_code(&am.language);
                 let mut attrs = format!(" format=\"{format}\"");
                 if let Some(lang) = lang {
@@ -159,6 +165,55 @@ fn dvdauthor_audio_format(target: AudioOutputTarget) -> &'static str {
     }
 }
 
+/// The format dvdauthor should declare for one audio stream. `output_target`
+/// only reflects what a *re-encoded* stream becomes — a `CopyMode::Copy`
+/// mapping passes the source stream's own bytes through unchanged
+/// (`build_ffmpeg_transcode_command` emits `-c:a copy`, ignoring
+/// `output_target`), so declaring `output_target`'s format for a copied
+/// stream can tell dvdauthor a physical stream is a codec it isn't — e.g. an
+/// AC3 source left in copy mode with a stale `output_target` of MP2 from
+/// before the user switched modes. Resolve the *actual* source codec for
+/// copied mappings instead, falling back to `output_target` only if the
+/// source asset/stream can't be resolved (so declaration never regresses to
+/// no declaration at all).
+fn declared_audio_format(
+    am: &AudioTrackMapping,
+    title: &Title,
+    assets: &HashMap<&str, &Asset>,
+) -> &'static str {
+    if am.copy_mode == CopyMode::Copy {
+        if let Some(format) = title
+            .source_asset_id
+            .as_deref()
+            .and_then(|id| assets.get(id))
+            .and_then(|asset| {
+                asset
+                    .audio_streams
+                    .iter()
+                    .find(|s| s.index == am.source_stream_index)
+            })
+            .and_then(|stream| dvdauthor_format_for_source_codec(&stream.codec))
+        {
+            return format;
+        }
+    }
+    dvdauthor_audio_format(am.output_target)
+}
+
+/// Maps an inspected source codec name (ffprobe-style, as stored on
+/// `AudioStreamInfo`) to the format dvdauthor expects in an `<audio>`
+/// declaration. `None` for anything not DVD-legal to copy as-is — callers
+/// fall back to the mapping's `output_target` in that case.
+fn dvdauthor_format_for_source_codec(codec: &str) -> Option<&'static str> {
+    match codec {
+        "ac3" => Some("ac3"),
+        "mp2" => Some("mp2"),
+        "dts" => Some("dts"),
+        "pcm_s16le" | "pcm_s16be" | "lpcm" => Some("pcm"),
+        _ => None,
+    }
+}
+
 fn expand_title_end_action(
     action: &PlaybackAction,
     current_title: &Title,

From dafba503d41de81feeb39e94bfb206a882b9262a Mon Sep 17 00:00:00 2001
From: Scott Morris <scott.moris@gmail.com>
Date: Thu, 20 Aug 2026 21:43:51 -0400
Subject: [PATCH 6/7] fix(assets): fold the audio bitrate ceiling into the
 overall compatibility result
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Follow-up to the audio bitrate ceiling check, from Codex review: the
new per-stream `bitrate` check landed in `build_compatibility_detail`,
but `assess_dvd_compatibility` (which sets the asset's overall
`RemuxCompatible`/`TransformCompatible`/`ReEncodeRequired` label) still
only checked audio codec *name*. An otherwise DVD-compatible MPEG-2
asset with 640 kbps AC3 was still reported `RemuxCompatible` overall
even though selecting it forces an audio re-encode — the Assets page
badge told users the file was fine to remux when it wasn't.

Extracts the ceiling table and the compatibility check into shared
`audio_bitrate_ceiling_bps`/`audio_bitrate_is_dvd_legal` helpers, used
by both `assess_dvd_compatibility`'s overall `has_dvd_audio` check and
`build_compatibility_detail`'s per-stream `bitrate` check, so the two
can no longer drift apart.
---
 .../src/inspect.rs                            | 107 ++++++++++++++----
 1 file changed, 82 insertions(+), 25 deletions(-)

diff --git a/plugins/tauri-plugin-spindle-project/src/inspect.rs b/plugins/tauri-plugin-spindle-project/src/inspect.rs
index dc8c56b0..98a3ad13 100644
--- a/plugins/tauri-plugin-spindle-project/src/inspect.rs
+++ b/plugins/tauri-plugin-spindle-project/src/inspect.rs
@@ -422,13 +422,17 @@ fn assess_dvd_compatibility(
         (fr - 29.97).abs() < 0.1 || (fr - 25.0).abs() < 0.1 || (fr - 23.976).abs() < 0.1
     });
 
-    // Check audio compatibility
+    // Check audio compatibility. Codec name alone isn't sufficient — a
+    // stream can be a legal DVD codec by name and still be over that
+    // codec's DVD-Video bitrate ceiling (e.g. 640 kbps AC-3), which is
+    // equally disqualifying for a remux/stream-copy. See
+    // `audio_bitrate_is_dvd_legal` for the ceiling table.
     let has_dvd_audio = audio_streams.is_empty()
         || audio_streams.iter().any(|a| {
             matches!(
                 a.codec.as_str(),
                 "ac3" | "dts" | "pcm_s16le" | "pcm_s16be" | "mp2" | "lpcm"
-            )
+            ) && audio_bitrate_is_dvd_legal(&a.codec, a.bitrate_bps)
         });
 
     if is_mpeg2 && is_dvd_resolution && is_dvd_framerate && is_mpeg_container && has_dvd_audio {
@@ -440,6 +444,37 @@ fn assess_dvd_compatibility(
     }
 }
 
+/// DVD-Video's per-codec audio bitrate ceiling. `None` for codecs whose
+/// legality isn't a simple ceiling (LPCM depends on channel count/sample
+/// rate/depth, not bitrate directly) or for an already-non-DVD codec, where
+/// this check isn't the gate.
+fn audio_bitrate_ceiling_bps(codec: &str) -> Option<u64> {
+    match codec {
+        "ac3" => Some(448_000),
+        "mp2" => Some(384_000),
+        // DVD-Video's two canonical DTS rates top out at 1509.75 kbps; round
+        // up slightly for encoder/muxer bitrate-field rounding rather than
+        // reject a spec-legal stream on that.
+        "dts" => Some(1_536_000),
+        _ => None,
+    }
+}
+
+/// Whether a stream's bitrate is legal for its codec under DVD-Video, on top
+/// of (not instead of) the codec-name check. A source can be a legal DVD
+/// codec by name and still be too hot to stream-copy — e.g. AC-3 above 448
+/// kbps is a valid AC-3 bitstream, produced by plenty of non-DVD encoders,
+/// but not DVD-legal. An unknown bitrate on a ceiling-bearing codec defaults
+/// to incompatible rather than optimistically assuming it's fine — silently
+/// copying an out-of-spec stream onto the disc is worse than an unnecessary
+/// re-encode.
+fn audio_bitrate_is_dvd_legal(codec: &str, bitrate_bps: Option<u64>) -> bool {
+    match audio_bitrate_ceiling_bps(codec) {
+        Some(ceiling) => bitrate_bps.is_some_and(|bps| bps <= ceiling),
+        None => true,
+    }
+}
+
 fn build_compatibility_detail(
     video_streams: &[VideoStreamInfo],
     audio_streams: &[AudioStreamInfo],
@@ -507,30 +542,11 @@ fn build_compatibility_detail(
                 "ac3" | "dts" | "pcm_s16le" | "pcm_s16be" | "mp2" | "lpcm"
             );
             // DVD-Video's per-codec bitrate ceiling — distinct from, and in
-            // addition to, the codec-name check above. A source can be a
-            // legal DVD codec by name and still be too hot to stream-copy
-            // (e.g. AC-3 above 448 kbps is a valid AC-3 bitstream, produced
-            // by plenty of non-DVD encoders, but not DVD-legal). `None` for
-            // codecs whose legality isn't a simple ceiling (LPCM depends on
-            // channel count/sample rate/depth, not bitrate directly) or for
-            // an already-non-DVD codec, where this check isn't the gate.
-            let bitrate_ceiling_bps: Option<u64> = match a.codec.as_str() {
-                "ac3" => Some(448_000),
-                "mp2" => Some(384_000),
-                // DVD-Video's two canonical DTS rates top out at 1509.75
-                // kbps; round up slightly for encoder/muxer bitrate-field
-                // rounding rather than reject a spec-legal stream on that.
-                "dts" => Some(1_536_000),
-                _ => None,
-            };
-            let bitrate_check = match bitrate_ceiling_bps {
+            // addition to, the codec-name check above; see
+            // `audio_bitrate_is_dvd_legal`/`audio_bitrate_ceiling_bps`.
+            let bitrate_check = match audio_bitrate_ceiling_bps(&a.codec) {
                 Some(ceiling) => {
-                    // Unknown bitrate on a ceiling-bearing codec defaults to
-                    // incompatible (forces a re-encode) rather than
-                    // optimistically assuming it's fine — silently copying
-                    // an out-of-spec stream onto the disc is worse than an
-                    // unnecessary re-encode.
-                    let compatible = a.bitrate_bps.is_some_and(|bps| bps <= ceiling);
+                    let compatible = audio_bitrate_is_dvd_legal(&a.codec, a.bitrate_bps);
                     PropertyCheck {
                         value: a
                             .bitrate_bps
@@ -888,6 +904,47 @@ mod tests {
         ));
     }
 
+    #[test]
+    fn dvd_compatibility_over_ceiling_audio_bitrate_is_not_remux_compatible() {
+        // An otherwise DVD-compatible MPEG-2 asset with a 640 kbps AC-3
+        // track (a legal AC-3 bitstream rate, but over DVD-Video's 448 kbps
+        // AC-3 ceiling) must not be reported RemuxCompatible overall — the
+        // per-stream bitrate check in `build_compatibility_detail` already
+        // flags this stream as needing a re-encode, and the overall
+        // assessment must agree rather than only checking codec name.
+        let video = vec![VideoStreamInfo {
+            index: 0,
+            codec: "mpeg2video".to_string(),
+            width: 720,
+            height: 480,
+            frame_rate: Some(29.97),
+            aspect_ratio: Some("16:9".to_string()),
+            scan_type: Some("interlaced".to_string()),
+            bitrate_bps: Some(6_000_000),
+            title: None,
+            color_transfer: None,
+            color_primaries: None,
+            dolby_vision_profile: None,
+        }];
+        let audio = vec![AudioStreamInfo {
+            index: 1,
+            codec: "ac3".to_string(),
+            channels: 6,
+            sample_rate: 48000,
+            language: Some("eng".to_string()),
+            bitrate_bps: Some(640_000),
+            title: None,
+        }];
+        let container = Some("mpeg".to_string());
+        assert!(
+            !matches!(
+                assess_dvd_compatibility(&video, &audio, &container),
+                CompatibilityAssessment::RemuxCompatible
+            ),
+            "640 kbps AC-3 exceeds the DVD-Video ceiling and must not report RemuxCompatible"
+        );
+    }
+
     #[test]
     fn dvd_compatibility_transform_required() {
         let video = vec![VideoStreamInfo {

From fcae297f0fb19ee1a6f1a1aeb8959abf8f9c0ead Mon Sep 17 00:00:00 2001
From: Scott Morris <scott.moris@gmail.com>
Date: Thu, 20 Aug 2026 21:44:19 -0400
Subject: [PATCH 7/7] docs: document the DTS refusal and audio bitrate ceiling
 behaviour
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Per AGENTS.md's docs-sync convention, from Codex review: this PR's
DTS re-encode refusal and audio bitrate ceiling check are both
user-facing behaviour changes that weren't reflected in README.md or
SPEC.md.

- README: notes that compatibility explanations now cover per-codec
  DVD-Video audio bitrate ceilings, not just codec-name matching.
- SPEC §12.2.4: documents that DTS output is confirmed unavailable as
  a re-encode target regardless of environment (not merely "not yet
  probed"), and that copy eligibility requires both codec name and
  bitrate to be DVD-legal.
- SPEC §21.2: updates the DTS error example to the actual message the
  app now emits.
- SPEC §26 open question 9: narrowed now that DTS re-encoding isn't
  offered at all — the remaining question is only about copy-mode DTS
  passthrough, which was never gated by the broken encoder.
---
 README.md | 2 +-
 SPEC.md   | 8 ++++----
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/README.md b/README.md
index 0791cec2..6029c35e 100644
--- a/README.md
+++ b/README.md
@@ -15,7 +15,7 @@ Current DVD authoring capabilities include:
 - menu editing with authored scene documents, layers, still-image composition nodes, and motion menus with intro/loop timing, audio beds, and timeout actions
 - animated button highlights authored as keyframe tracks on a timeline strip and compiled into the disc's subpicture stream
 - semantic interaction graphs and remote-navigation preview simulation
-- asset inspection with embedded metadata title surfacing, compatibility explanations, fix-oriented validation, and still-image imports for menu authoring
+- asset inspection with embedded metadata title surfacing, compatibility explanations (including per-codec DVD-Video audio bitrate ceilings, not just codec-name matching), fix-oriented validation, and still-image imports for menu authoring
 - DVD build planning and execution with diagnostics export and toolchain checks
 - bitmap subtitle muxing plus first-pass text subtitle rendering for DVD authoring
 
diff --git a/SPEC.md b/SPEC.md
index adc21439..74ba1281 100644
--- a/SPEC.md
+++ b/SPEC.md
@@ -543,8 +543,8 @@ The native toolchain adapter should detect which encoders and pass-through paths
 This matters especially for:
 
 - MP2 output availability
-- DTS output availability
-- copy and passthrough eligibility for existing compliant streams
+- DTS output availability — confirmed unavailable as a re-encode target regardless of environment: ffmpeg's only DTS encoder path produces a stream that decodes fine in isolation but corrupts once muxed through the DVD program-stream muxer, so re-encoding to DTS is refused outright at validation and build time. DTS remains available as a stream copy of an already-DTS source.
+- copy and passthrough eligibility for existing compliant streams — a source stream is only copy-eligible when both its codec name _and_ its bitrate are DVD-legal (e.g. AC-3 above 448 kbps is a valid AC-3 bitstream but exceeds the DVD-Video ceiling and still requires a re-encode despite the codec name matching)
 
 ### 12.2.5 Planner integration
 
@@ -1102,7 +1102,7 @@ The app should not hide the build pipeline, but it also should not dump raw tool
 
 - "Title 3 exceeds estimated disc budget by 412 MB after adding the second audio track."
 - "Subtitle track 2 is text-based and must be converted before DVD authoring."
-- "Requested DTS output is not available in the current toolchain configuration."
+- "Cannot re-encode audio track \"English\" to DTS — ffmpeg has no reliable DTS encoder (its native encoder produces DVD-incompatible output). DTS is only supported as a stream copy of an already-DTS source; re-encode to AC3 instead."
 - "Menu button 'Scenes' points to a missing chapter menu."
 
 ---
@@ -1514,7 +1514,7 @@ These should be resolved during design review.
 6. Should the project file remain pure JSON in v1, or should a sidecar cache database be introduced immediately? — This affects portability, transparency, migration complexity, and how derived data is separated from authored data.
 7. How should menu highlight/select assets be modelled internally to support both ease of use and DVD constraints? — This matters because button visuals are simple in the UI but have strict authored-disc implications.
 8. How much of the generated build pipeline should be user-overridable? — This determines how inspectable and hackable the tool should be for advanced users without making the normal workflow fragile.
-9. Should DTS output require a separate advanced-compatibility acknowledgement even when toolchain support is present? — This is about distinguishing legal authoring from broadly safe playback compatibility.
+9. ~~Should DTS output require a separate advanced-compatibility acknowledgement even when toolchain support is present?~~ Narrowed by the confirmed-broken ffmpeg DTS encoder (§12.2.4): DTS re-encoding isn't offered at all, toolchain-independent, so the open question is now only about copy-mode DTS passthrough, which is already unrestricted since it never touches the broken encoder.
 10. How aggressively should the app recommend Half-D1 over Full-D1 when bitrate pressure is high? — This affects how opinionated the planner becomes when trading resolution against expected quality.
 11. How should autogenerated menus be regenerated after the user has manually customised them? — This raises important questions about preserving edits, reapplying templates, and avoiding destructive regeneration.
 12. Should generated chapter, audio, and subtitle menus be opt-in per title or derived automatically from project rules? — This affects how much automation the app performs by default and how predictable the authored structure feels.