feat(audio): align a fetched manifest to the local file before storing

The signature had a producer and a reader but no consumer, so nothing
ever fingerprinted anything. `ManifestAligner` runs on the fetch path,
before the windows are stored.

A local alignment supersedes the server's offset. The server has never
seen this file — its offset is a runtime-difference inference at best,
while the local comparison is against the media the windows will actually
be drawn over. It also needs no round trip, so no signature leaves the
instance. This is what jRay's spec already meant by matching being a
consumer concern: the server never rewrites a manifest, so one stored
manifest serves every trim of the same cut.

The offset has two terms and only one is in the server's pseudocode. Both
windows are centred on their own file's midpoint, so unequal runtimes
start them at different absolute times; a release with 40 s of extra head
material recovers 20 s from the slide and 20 s from the anchor
difference. Using the slide alone is wrong by half the runtime difference
on every shifted release.

Degradation, never failure. Signatures off, no manifest signature, media
under the window, a `v2:` producer, a missing binary, a decode error —
each applies the server's offset rather than refusing, because a
signature is an enhancement to cut matching and must never break a fetch.

"Un-comparable" and "does not match" are kept distinct, which a test
caught: `Compare` returns null for both, and conflating them would report
a 90-second extra as content disagreeing with its own manifest. A genuine
disagreement is stored anyway — the audio may legitimately differ, a
different language track being the obvious case — and surfaced as a
caveat that outranks the tier's, since it is the stronger statement.

The applied offset, score, slide and the local file's own signature are
written beside the truth file: the offset is otherwise unrecoverable once
the windows are shifted, and the stored signature lets a later fetch
align without decoding again. Provenance is never injected into the truth
file, so the bytes served back stay the producer's (JR-004).

`docs/audio-alignment.md` documents the mechanism end to end.

TRACES: JR-047 | SR-003

Jellyfin.Plugin.JRay/Controllers/ManifestController.cs

@@ -31,6 +31,7 @@ public class ManifestController : ControllerBase
     private readonly ILibraryManager _libraryManager;
     private readonly IManifestExchangeClient _exchange;
     private readonly IManagedTruthStore _truthStore;
+    private readonly ManifestAligner _aligner;
     private readonly ILogger<ManifestController> _logger;
 
     /// <summary>
@@ -39,16 +40,19 @@ public class ManifestController : ControllerBase
     /// <param name="libraryManager">Library manager.</param>
     /// <param name="exchange">Manifest exchange client.</param>
     /// <param name="truthStore">Managed truth store.</param>
+    /// <param name="aligner">Aligns a fetched manifest to the local file.</param>
     /// <param name="logger">Logger.</param>
     public ManifestController(
         ILibraryManager libraryManager,
         IManifestExchangeClient exchange,
         IManagedTruthStore truthStore,
+        ManifestAligner aligner,
         ILogger<ManifestController> logger)
     {
         _libraryManager = libraryManager;
         _exchange = exchange;
         _truthStore = truthStore;
+        _aligner = aligner;
         _logger = logger;
     }
 
@@ -102,35 +106,53 @@ public class ManifestController : ControllerBase
             return NotFound(new { error = "no configured server had an acceptable manifest" });
         }
 
+        // Align before storing. The server has never seen this file, so where a
+        // local audio alignment is possible it supersedes the offset the server
+        // sent — and it needs no round trip, so no signature leaves the
+        // instance (JR-047).
+        var alignment = await _aligner.AlignAsync(
+                item.Path ?? string.Empty,
+                item.RunTimeTicks is { } ticks ? TimeSpan.FromTicks(ticks).TotalSeconds : 0.0,
+                outcome.Manifest,
+                outcome.Tier,
+                outcome.OffsetSec,
+                config.ComputeAudioSignatures,
+                cancellationToken)
+            .ConfigureAwait(false);
+
+        var caveat = ManifestConverter.DescribeCaveat(alignment.Tier, alignment.OffsetSec, alignment);
+
         // The offset is applied here, once, so the stored truth is always in the
         // local file's own timebase and no reader needs offset awareness.
-        var truth = ManifestConverter.ToTruthFile(outcome.Manifest, outcome.OffsetSec, item.Path ?? string.Empty);
+        var truth = ManifestConverter.ToTruthFile(outcome.Manifest, alignment.OffsetSec, item.Path ?? string.Empty);
         var provenance = new TruthProvenance
         {
             Source = TruthSource.Fetched,
             ServerUrl = outcome.ServerUrl,
-            MatchTier = outcome.Tier,
-            OffsetSec = outcome.OffsetSec,
-            Caveat = ManifestConverter.DescribeCaveat(outcome.Tier, outcome.OffsetSec),
+            MatchTier = alignment.Tier,
+            OffsetSec = alignment.OffsetSec,
+            Alignment = alignment,
+            Caveat = caveat,
             RecordedAt = DateTime.UtcNow,
         };
 
         await _truthStore.SaveAsync(itemId, truth, provenance, cancellationToken).ConfigureAwait(false);
 
         _logger.LogInformation(
-            "Stored manifest for {ItemId} from {Server} at tier {Tier} (offset {Offset}s)",
+            "Stored manifest for {ItemId} from {Server} at tier {Tier} (offset {Offset}s, aligned by {Source})",
             itemId,
             outcome.ServerUrl,
-            outcome.Tier,
-            outcome.OffsetSec);
+            alignment.Tier,
+            alignment.OffsetSec,
+            alignment.Source);
 
         return Ok(new ManifestFetchResult
         {
             ServerUrl = outcome.ServerUrl,
-            Match = outcome.Tier.ToString().ToLowerInvariant(),
-            OffsetSec = outcome.OffsetSec,
+            Match = alignment.Tier.ToString().ToLowerInvariant(),
+            OffsetSec = alignment.OffsetSec,
             ActorCount = truth.Actors.Count,
-            Caveat = ManifestConverter.DescribeCaveat(outcome.Tier, outcome.OffsetSec),
+            Caveat = caveat,
         });
     }